Chiamare funzioni C da linguaggio assembly x86

Question

È possibile generare funzioni linguaggio assembly dalle funzioni C tramite GCC, in modo che possano essere richiamate da un programma in linguaggio assembly? So che gcc compila il codice da computer C (che può essere facilmente smontato in linguaggio assembly), e so già che è possibile effettuare il inline assembly language functions in C, ma non ho ancora trovato un modo per richiamare le funzioni C dai programmi in linguaggio assembly, che è fondamentalmente l'inverso di questo.

Qui, sto tentando di incorporare una funzione C in un programma di assemblaggio x86. Se l'inlining non è possibile, c'è un altro modo per invocare una funzione C da un programma in linguaggio assembly?

.686p 
.model flat,stdcall 
.stack 2048 

.data 

.code 
start: 

invoke ExitProcess, 0 

printSomething PROC ;now I'm attempting to inline a C function here 
    void printSomething(thingToPrint){ 
     printf("This is a C function that I want to invoke from an assembly language program."); 
     printf("There must be some way to do this - is it possible somehow?"); 
    } 
printSomething ENDP 

end start 

Answer 1

Sto andando dalla memoria qui, quindi potrei essere leggermente fuori su un dettaglio o due. Tuttavia, dovrei sperare di essere abbastanza per farti andare nella giusta direzione.

Si sta andando ad avere bisogno di dire al assembler GCC che la vostra routine printSomething() non è definito nel file di assiemi. In "C" si utilizza la parola chiave extern. Per il montaggio è necessario utilizzare .globl.

.globl printSomething 

Se si utilizza un assemblatore diverso rispetto a GCC di, la parola chiave potrebbe essere diverso.

La prossima grande domanda è "come passare gli argomenti"? Questo dipende molto dal processore e dal sistema operativo. Dal momento che il titolo della tua domanda indica x86, assumerò che tu stia utilizzando sia la modalità a 16 o 32 bit e l'ABI standard x86 (a differenza di x86-64, che differisce anche da Windows a Linux). I parametri C vengono passati alla routine chiamata spingendoli nello stack. Sono spinti in pila da destra a sinistra.

Così,

printSomething (arg1, arg2, arg3, arg4); 

si traduce in ...

pushl arg4 
pushl arg3 
pushl arg2 
pushl arg1 
call printSomething 
addl $0x10, %esp 

Si può chiedere se stessi, che cosa è questo

addl $0x10, %esp 

? Abbiamo passato (aka spinto) quattro argomenti a 32 bit alla routine (sullo stack). Sebbene la routine sappia aspettarsi tali argomenti, NON è responsabile di farli fuoriuscire dallo stack. Il chiamante è responsabile per questo. Quindi, dopo che torniamo dalla routine, regoliamo il puntatore dello stack per scartare i quattro argomenti a 32 bit che abbiamo precedentemente inserito nello stack.

Nell'esempio precedente, suppongo che stiamo operando in modalità a 32 bit. Se fosse a 16 bit mode, sarebbe ...

pushw arg4 
pushw arg3 
pushw arg2 
pushw arg1 
call printSomething 
addw $0x8, %sp 

mi rendo conto che nel tuo esempio, printSomething() richiede solo un (1) discussione e nel mio esempio ho usato quattro (4) . Basta regolare il mio esempio come è necessario.

Per le fasi finali, è necessario compilare i file sia il C e il montaggio in file oggetto, collegare i file oggetto e quindi eseguire.

Spero che questo aiuti.