Chiamata diretta tramite l'assembly inline di GCC

Question

Se si desidera chiamare una funzione C/C++ da assembly inline, si può fare qualcosa di simile:

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

GCC sarà poi emettere il codice che assomiglia a questo:

movl $callee, %eax 
call *%eax 

Questo può essere problematico poiché la chiamata indiretta distruggerà la pipeline su CPU meno recenti.

Poiché l'indirizzo di callee è infine una costante, si può immaginare che sarebbe possibile utilizzare il vincolo i. Citando dal GCC linea 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.

Se cerco di usare in questo modo:

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

ricevo il seguente errore dal assembler:

Error: suffix or operands invalid for `call'

Questo perché GCC emette il codice

call $callee 

Invece di

call callee 

Quindi la mia domanda è se sia possibile fare uscita GCC il corretto call.

Answer 1

ho avuto la answer dalla mailing list di GCC:

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

Ora ho solo bisogno di scoprire che cosa significa in realtà %P0 perché sembra essere una caratteristica non documentata ...

Edit: Dopo aver esaminato il codice sorgente GCC, non è esattamente chiaro cosa significhi il codice P davanti a un vincolo. Ma, tra le altre cose, impedisce a GCC di mettere uno $ di fronte a valori costanti. Quale è esattamente ciò di cui ho bisogno in questo caso.

Answer 2

Come circa.

asm volatile ("call $callee"); 

poiché si conosce il nome del simbolo, comunque.

Modifica: Il punto che volevo fare è che non devi seguire le convenzioni di gcc per gli argomenti asm qui, ma devi solo eseguire l'elaborazione del testo per eseguire il lavoro.

Answer 3

Il trucco è la concatenazione letterale stringa. Prima di GCC inizia cercando di ottenere qualsiasi significato reale dal codice sarà concatenare stringhe letterali adiacenti, quindi, anche se il montaggio stringhe non sono le stesse di altre stringhe che si utilizzano nel programma dovrebbero essere concatenati se lo fai:

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


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

dal momento che si sta utilizzando GCC si potrebbe anche fare

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

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

Se non si conosce già si dovrebbe essere consapevoli del fatto che chiamare le cose dal montaggio in linea è molto difficile. Quando il compilatore genera le proprie chiamate ad altre funzioni, include il codice per impostare e ripristinare le cose prima e dopo la chiamata. Non sa che dovrebbe fare nulla per la tua chiamata, però. Dovrai o includerlo tu stesso (molto difficile da ottenere e potrebbe interrompere l'aggiornamento del compilatore o i flag di compilazione) o assicurarti che la tua funzione sia scritta in modo tale da non sembrare che abbia cambiato alcun registro o condizione del stack (o variabile su di esso).

modifica questo funzionerà solo per i nomi di funzioni C - non C++ in quanto vengono manchiati.

Answer 4

Se si sta generando codice a 32 bit (ad esempio -m32 gcc opzione), la seguente linea asm emette una chiamata diretta:

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

Answer 5

Forse mi manca qualcosa qui, ma

extern "C" void callee(void) 
{ 

} 

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

dovrebbe funzionare bene. È necessaria la "C" extern in modo che il nome non venga decorato in base alle regole di mangling dei nomi C++.