llamada directa mediante ensamblado en línea de GCC

Question

Si desea llamar a una función de C/C++ de ensamblado en línea, usted puede hacer algo como esto:

void callee() {} 
void caller() 
{ 
    asm("call *%0" : : "r"(callee)); 
} 

GCC entonces emitir código que se parece a esto:

movl $callee, %eax 
call *%eax 

Esto puede ser problemático ya que la llamada indirecta destruirá la tubería en las CPU más antiguas.

Dado que la dirección de callee es eventualmente una constante, se puede imaginar que sería posible usar la restricción i. Citando del CCG en línea docs:

`i'

An immediate integer operand (one with constant value) is allowed. This includes symbolic constants whose values will be known only at assembly time or later.

si trato de utilizar de esta manera:

asm("call %0" : : "i"(callee)); 

me sale el siguiente error desde el ensamblador:

Error: suffix or operands invalid for `call'

Esto se debe a GCC emite el código

call $callee 

En lugar de

call callee 

Así que mi pregunta es si es posible hacer que la salida del CCG correcta call.

Answer 1

me dieron el answer de la lista de correo de GCC:

asm("call %P0" : : "i"(callee)); 

Ahora sólo tengo que averiguar lo que realmente significa %P0, ya que parece ser una característica no documentada ...

Editar: Después de mirar el código fuente de GCC, no está exactamente claro qué significa el código P frente a una restricción. Pero, entre otras cosas, evita que GCC ponga un $ frente a valores constantes. Que es exactamente lo que necesito en este caso.

Answer 2

Qué tal.

asm volatile ("call $callee"); 

ya que conoce el nombre del símbolo, de todos modos.

Editar: El punto que quería hacer es que no tiene que pasar por las convenciones de gcc para los argumentos asm aquí, sino que solo tiene que hacer el procesamiento de texto para hacer el trabajo.

Answer 3

El truco es la concatenación literal de cadenas. Antes de que GCC empiece a tratar de obtener un significado real de su código, concatenará literales adyacentes, de modo que aunque las cadenas de ensamblaje no sean las mismas que las utilizadas en su programa, deben concatenarse si lo hace:

#define ASM_CALL(X) asm("\t call " X "\n") 


int main(void) { 
    ASM_CALL("my_function"); 
    return 0; 
} 

dado que está utilizando GCC también se podría hacer

#define ASM_CALL(X) asm("\t call " #X "\n") 

int main(void) { 
    ASM_CALL(my_function); 
    return 0; 
} 

Si no lo sabe ya que debe ser consciente de que llamar a las cosas de ensamblado en línea es muy complicado. Cuando el compilador genera sus propias llamadas a otras funciones, incluye código para configurar y restaurar cosas antes y después de la llamada. Sin embargo, no sabe que debería hacer algo de esto por su llamada. Tendrá que incluirlo usted mismo (es muy difícil hacerlo bien y puede romper con una actualización del compilador o indicadores de compilación) o asegurarse de que su función esté escrita de tal manera que no parezca haber cambiado ningún registro o condición del pila (o variable en ella).

editar esto solo funcionará para nombres de funciones C, no C++, ya que están destrozados.

Answer 4

Si va a generar código de 32 bits (por ejemplo, la opción -m32 gcc), la siguiente línea asm emite una llamada directa:

asm ("call %0" :: "m" (callee)); 

Answer 5

Tal vez me estoy perdiendo algo aquí, pero

extern "C" void callee(void) 
{ 

} 

void caller(void) 
{ 
    asm("call callee\n"); 
} 

debería funcionar bien. Necesita una "C" externa para que el nombre no se decore en función de las reglas de creación de nombres de C++.