Como sempre ando vendo por aí duvidas de como juntar o código em C com Assembly, hoje resolvi fazer esse artigo para tirar todas as dúvidas referente a isto.

Primeiro devemos saber como o C processa os parâmetros e o retorno de dados, na verdade isso é bem simples. Quando passamos os parâmetros para o código o C joga os dados na pilha, então para um arquivo como:

teste.c:

int soma(int x, int y)
{
return x+y;
}

int main(void)
{
int r;

r = soma(5, 6);

return 0;
}

Teremos o seguinte código assembly:

teste.asm:

_soma:
push     ebp
mov    ebp, esp
mov    eax, DWORD [ebp + 12]
add    eax, DWORD [ebp + 8]
pop    ebp
ret

_main:
push    ebp
mov    ebp, esp
sub    esp, 24
and    esp, -16
mov    eax, 0
add    eax, 15
add    eax, 15
shr    eax, 4
sal    eax, 4
mov DWORD [ebp - 8], eax
mov    eax, DWORD [ebp -8]
call    __alloca
call    ___main
mov    [esp+4], 6
mov    [esp], 5
call    _soma
mov    [ebp - 4], eax
mov    eax, 0
leave
ret

Parece ser muito complicado não? Mas vou explicar cada linha!

Como você deve ter percebido, o C adiciona um underscore antes do nome de cada função, a função _soma é de longe bem fácil de entender, como a função recebe os dados da pilha primeiro ela deverá manipula-los, então ela salva o EBP na pilha e move o valor de ESP para ele, a pilha agora deverá ser algo do tipo:

VALOR 6
VALOR 5
VALOR DE EIP
VALOR DE EBP

No código assembly gerado, podemos ver que o EAX é quem recebe o retorno, por isso todas as manipulação são feitas encima dele, então

mov eax, DWORD [ebp+12]

seria nosso Y e

add eax, DWORD [ebp + 8]

seria o mesmo que return x+y; depois disso o valor de EBP é retomado e a função volta de onde foi chamada.

Na função _main, vamos aquele amontoado de código gerado para alocar as variáveis, mas podemos ignora-lo, o que interessa mesmo é esta parte:

mov    [esp+4], 6
mov    [esp], 5
call    _soma
mov    [ebp - 4], eax
mov    eax, 0
leave
ret

As três primeiras linhas de código como podemos ver seria os valores passados a pilha e a chamada a função, seria o mesmo que fazer:

push 5
push 6
call _soma

E como o valor de retorno está em EAX, o [EBP - 4], representa nossa variável r e como podemos ver, todas as variáveis criadas dentro das funções ficam na pilha, por isso o uso de EBP. Como termino return 0, é representado como:

mov eax, 0
leave        ; Libera o espaço usado por _main na pilha
ret        ; Retorna

Acredito que depois disso podemos entender, em geral, como o C gerá o código Assembly, mas pera ai! Não estamos esquecendo de algo?

Claro e como podemos juntar um arquivo assembly com um C? Se você estiver usando o DJGPP e o NASM, você pode fazer o seguinte:

nasm -fcoff assembly.asm -o assembly.o
gcc -c arquivo.c -o arquivo.o

ld -r assembly.o arquivo.o -o combinado.o

Para isso vou dar um exemplo final:

arqasm.asm:

[BITS 32]

[SECTION .text]

_soma:
push     ebp
mov    ebp, esp
mov    eax, DWORD [ebp + 12]
add    eax, DWORD [ebp + 8]
pop    ebp
ret

arqc.c:

int soma(int x, int y);

int teste(void)
{
int r;

r = soma(5, 6);

return 0;
}

Se alguêm tiver interesse em ver como o GCC gerá os códigos para o assembly, você poderá tentar o seguinte comando:

gcc -c arquivo.c -S teste.s

Espero que tenham gostado, se tiverem dúvidas ou algo estiver errado, mandem um comentário.

10 Respostas para “Juntando código C com Assembly”

Deixe uma Resposta

Nome (requerido)

E-Mail (não será publicado) (requerido)

Website