Lanzar una excepción de C++ después de un salto de asso en línea

Question

Tengo un extraño código de auto modificación, pero en la raíz es un problema bastante simple: quiero poder ejecutar un jmp (o un call) y luego desde ese punto arbitrario arrojó una excepción y lo atrapó el bloque try/catch que contenía jmp/call.

Pero cuando hago esto (en gcc 4.4.1 x86_64) la excepción da como resultado un terminate() como lo haría si la excepción fuera lanzada desde fuera de un try/catch. Realmente no veo cómo esto es diferente a lanzar una excepción desde el interior de una biblioteca remota, pero obviamente es porque simplemente no funciona.

¿Cómo puedo ejecutar un jmp o call pero todavía arrojar una excepción al original try/catch? ¿Por qué este try/catch no sigue manejando estas excepciones como lo haría si la función se llamara normalmente?

El código:

#include <iostream> 
#include <stdexcept> 

using namespace std; 

void thrower() 
{ 
    cout << "Inside thrower" << endl; 
    throw runtime_error("some exception"); 
} 

int main() 
{ 
    cout << "Top of main" << endl; 

    try { 
     asm volatile (
      "jmp *%0" // same thing happens with a call instead of a jmp 
      : 
      : "r"((long)thrower) 
      : 
     ); 
    } catch (exception &e) { 
     cout << "Caught : " << e.what() << endl; 
    } 
    cout << "Bottom of main" << endl << endl; 
} 

La salida esperada:

Top of main 
Inside thrower 
Caught : some exception 
Bottom of main 

La salida real:

Top of main 
Inside thrower 
terminate called after throwing an instance of 'std::runtime_error' 
    what(): some exception 
Aborted 

Answer 1

Si está utilizando gcc 4.4.7 (y superior) en Linux x86-64 , con mecanismo enana mango excepción (que podría ser la opción por defecto), tengo una manera de resolver esto .

Suponga que su código de ensamblaje en línea es una función inline_add. Llamará a otra función add, que podría arrojar una excepción. Aquí está el código:

extern "C" int add(int a, int b) { 
    throw "in add"; 
} 

int inline_add(int a, int b) { 
    int r = 0; 
    __asm__ __volatile__ (
     "movl %1, %%edi\n\t" 
     "movl %2, %%esi\n\t" 
     "call add\n\t" 
     "movl %%eax, %0\n\t" 
     :"=r"(r) 
     :"r"(a), "r"(b) 
     :"%eax" 
    ); 
    return r; 
} 

Si llama inline_add así:

try { 
    inline_add(1, 1); 
} catch (...) { 
    std::cout << "in catch" << std::endl; 
} 

que va de choque, porque gcc no proporciona el marco de excepción para inline_add. Cuando se trata de una excepción, tiene que crach. (Ver here para la 'compatibilidad con C')

así que tenemos que fingir un marco de excepción para él, pero sería difícil de piratear con el conjunto de gcc, sólo tiene que utilizar funciones con marco de excepción adecuado para rodearlo

se define una función como esta:

void build_exception_frame(bool b) { 
    if (b) { 
     throw 0; 
    } 
} 

y llamar inline_add así:

try { 
    inline_add(1, 1); 
    build_exception_frame(false); 
} catch (...) { 
    std::cout << "in catch" << std::endl; 
} 

y que sólo wo rks.

build_exception_frame debe venir después de la llamada, o no va a funcionar

Adicionalmente, para evitar optimiziong gcc podría asumir build_exception_frame, tenemos que añadir lo siguiente:

void build_exception_frame(bool b) __attribute__((optimize("O0"))); 

Puede comprobar el código de ensamblaje que genera gcc para verificar el código.

Parece que gcc proporciona el marco de excepción para el total try/catch, siempre que haya una función que pueda arrojar, y la posición importa.

Necesito ver cómo funciona gcc en eso más adelante.

Si alguien sabe acerca de eso, tenga la amabilidad de informarme. Gracias.

Answer 2

¿Ha mirado el código ensamblador generado por gcc si su intento {} bloque simplemente contenía una llamada de función? Estoy bastante seguro de que el compilador C++ hace algo más que un salto en ese punto, ya que necesita poder rastrear la pila cuando ocurre una excepción.

Su código podría funcionar si pudiera imitar los pasos que toma gcc al estructurar la llamada a la función.

Actualización:this question puede dar más información. En particular, la porción de lanzamiento y captura de Itanium ABI puede ser útil: link

Answer 3

¿Ha visto cómo maneja su implementación las excepciones? Implica buscar direcciones de PC en tablas para averiguar qué estaba haciendo el programa en el lugar específico que arrojó, y lo que estaban haciendo todos los llamadores. Al menos en Mac OS X GCC.

El único otro sistema que he visto, Metrowerks Codewarrior para Mac (hacia atrás cuando) usaba un sistema similar, aunque algo más transparente. El compilador puede insertar funciones de forma transparente para cualquier tipo de cambio de contexto de excepción.

No tiene una oración para hacer que este portátil.

Answer 4

Una vez que realiza el ensamblaje en línea, tiene un comportamiento definido en la implementación (7.4/1).

Debe intentar configurar un marco de pila; los detalles son específicos de la plataforma y no sé cómo hacerlo en x86_64.