ASSEMBLY – aula 2
Hugo Calazans
[email protected]
Roteiro
123456-
Recapitulação (Intel x AT&T)
Pilha e command line arguments
Procedimentos
Simulando alguns comandos C
Assembly inline
Linux Man Pages
Intel x AT&T
- recapitulação
Intel Code
AT&T Code
mov
eax,1
movl
$1,%eax
mov
ebx,0ffh
movl
$0xff,%ebx
int
80h
int
$0x80
mov
ebx, eax
movl
%eax, %ebx
mov
eax,[ecx]
movl
(%ecx),%eax
mov
eax,[ebx+3]
movl
3(%ebx),%eax
mov
eax,[ebx+20h]
movl
0x20(%ebx),%eax
add
eax,[ebx+ecx*2h]
addl
(%ebx,%ecx,0x2),%eax
lea
eax,[ebx+ecx]
leal
(%ebx,%ecx),%eax
sub
eax,[ebx+ecx*4h-20h]
subl
-0x20(%ebx,%ecx,0x4),%eax
Intel x AT&T
- recapitulação

Diferenças:
12345-
Ordenação entre source e destination
Nome dos registradores (prefixação)
Operandos imediatos (prefixação)
Menção feita ao tamanho dos operandos
Manipulação de operandos na memória
Intel x AT&T
- Exemplo: Fatorial

C
int fatorial (int numero) {
int fat = 1;
if (numero <= 1)
return 1;
fat = numero * fatorial (numero - 1);
return fat;
}
Intel x AT&T
- Exemplo: Fatorial

Intel
L1:
L2: ret
mov eax, 5
mov ebx, 1
cmp eax, 0 //compara 0 com o valor em eax
je L2
//pula p/ L2 se 0==eax (je – pula se igual)
imul ebx, eax
// ebx = ebx*eax
dec eax
//decrementa eax
jmp L1
// pulo incondicional para L1
Intel x AT&T
- Exemplo: Fatorial

AT&T
movl $5, %eax
movl $1, %ebx
L1:cmpl $0, %eax //compara 0 com o valor em eax
je L2
//pula p/ L2 se 0==eax (je – pula se igual)
imull %eax, %ebx // ebx = ebx*eax
decl %eax
//decrementa eax
jmp L1
// pulo incondicional para L1
L2: ret
Intel x AT&T
- Exemplo: Ponto de entrada

NASM
section .data
section .text
global _start
_start:
push epb
mov ebp,esp
push ebx
push esi
push edi
; código do seu programa
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
Intel x AT&T
- Exemplo: Ponto de entrada

AT&T
.data
.globl main
main:
pushl %epb
movl %ebp,%esp
pushl %ebx
pushl %esi
pushl %edi
; código do seu programa
popl %edi
popl %esi
popl %ebx
movl %esp,%ebp
popl %ebp
Pilha e Argumentos de
linha de comando

Exemplo:
– ./programa infra software 677
PILHA
4
“programa”
“infra”
“software”
“677”
Pilha e Argumentos de
linha de comando

Exemplo:
– ./programa infra software 677
INTEL
pop eax
AT&T
pop %eax
O que é?
# de args
pop ebx
pop ecx
pop %ebx
pop %ecx
“programa”
“infra”
pop edx
pop eax
pop %edx
pop %eax
“software”
“677”
Procedimentos?

Diferentemente do TASM, NASM não
possui o conceito de procedimento
– Tudo é Label!

Nada de keywords "proc" ou "endp"
– basta colocar uma label

Boa prática
– comentários delimitando o bloco de código
Procedimentos?
No DOS, sim!
DOS
proc fileWrite:
mov ah, 40h
mov bx, [filehandle]
mov cl, [stuffLen]
mov dx, offset stuffToWrite
int 21h
ret
endp fileWrite
Procedimentos?
No Linux, não. Labels!
INTEL
fileWrite:
mov eax,4
mov ebx, [filedesc]
mov ecx, stuffToWrite
mov edx, [stuffLen]
int 80h
ret
; endp fileWrite
AT&T
fileWrite:
movl $4, %eax
movl ($filedesc), %ebx
movl $stuffToWrite, %ecx
movl ($stuffLen), %edx
int $0x80
ret
; endp fileWrite
Gerando Código Assembly

Como gerar código assembly de um
programa escrito em C?
– gcc -S nomeDoPrograma.c


Será gerado um arquivo assembly com o
nome “nomeDoPrograma.s”
Estratégia muito boa para se aprender
assembly
– Construir programas em C e compilar com o
parâmetro “-S” para gerar o código “.s”
Simulando comandos C
- If-then-else
C
if (EAX == 'w') {
writeFile();
} else {
doSomethingElse();
}
NASM
cmp eax, 'w'
jne skipWrite
; Se não, skip
call writeFile
jmp outOfThisMess
skipWrite:
call doSomethingElse
outOfThisMess:
... ; resto do programa
Simulando comandos C
- If-then-else
C
if (EAX == 'w') {
writeFile();
} else {
doSomethingElse();
}
AT&T
cmpl 'w‘, %eax
jne skipWrite ; Se não, skip
call writeFile
jmp outOfThisMess
skipWrite:
call doSomethingElse
outOfThisMess:
... ; resto do programa
Simulando comandos C
- while
C
int i = 0;
while(i< 100){
i = i + 1;
}
NASM
mov eax, 0
whileLoop: mov ebx, 100
cmp eax, ebx
jge WhileTerminado
inc eax
jmp WhileLoop
WhileTerminado:
;resto do código
Simulando comandos C
- while
C
int i = 0;
while(i< 100){
i = i + 1;
}
AT&T
movl $0, %eax
whileLoop: movl $100, %ebx
cmpl %ebx, %eax
jge WhileTerminado
incl %eax
jmp WhileLoop
WhileTerminado:
;resto do código
Assembly Inline
- funções inline em C

O que é inline function?
– Uma forma de instruir o compilador a
inserir o código de uma determinada
função dentro do código de quem a
chama
Assembly Inline
- funções inline em C

Benefícios
– Redução do overhead existente para a
chamada de uma função
– Possível simplificações em tempo de
compilação, de forma que não
necessariamente todo o código da função
inline precise ser incluído
Assembly Inline
- funções inline em C

Desvantagens
– Possível aumento do tamanho do código

Como usar?
– Colocando a palavra chave “inline” na
declaração da função
Assembly Inline


Rotinas assembly escritas como
funções inline
Características
– Convenientes
– Velozes
– Amplamente utilizadas na programações
de sistemas
Assembly Inline

Como declarar?
– asm("assembly code");

Importância
– Atua como interface entre funções
assembly e os programas C que as
contêm
– Atuação sobre operandos e produção de
resultados visíveis para variáveis C
Assembly Inline

Exemplo 1:
– Move o conteúdo de ecx para eax:
__asm__("movl %ecx, %eax");

Exemplo 2:
– Move o conteúdo de ecx para o endereço da memória
apontado por eax:
asm("movb %ecx, (%eax)");
}
– Observe nos dois exemplos acima a possibilidade de se utilizar
__asm__(“código”) ou asm(“código”)
Assembly Inline

No caso de mais de uma instrução:
– Escreve-se uma por linha
– Entre aspas
– Com o sufixo “\n\t” ao final da instrução
– Isso se deve ao fato de que GCC envia
cada instrução como uma String ao GNU
Assembler
Assembly Inline

Exemplo 3:
#include <stdio.h>
int main()
{
__asm__ ( "movl %eax, %ebx\n\t“
"movl $56, %esi\n\t“
"movl %ecx, $label(%edx,%ebx,$4)\n\t"
"movb %ah, (%ebx)");
}
Assembly Inline

Exemplo 4:
#include <stdio.h>
int main()
{
__asm__("
movl $1,%eax
xor %ebx,%ebx
int $0x80
");
}
// SYS_exit
Linux Man Pages

O que são?
– documentação extensiva presente na
maior parte dos SOs da família UNIX

Comando
– man <page_name>

Ótima referência para system calls
– Section 2

Executadas a partir do serviço de interr 80h
Linux Man Pages
- Organização típica
1. General Commands
2. System Calls
3. Subroutines
4. Special Files
5. File Formats
6. Games and screensavers
7. Macros and Conventions
8. Maintenence Commands
Linux Man Pages

A partir do terminal do unix:
– Exemplo: digite “man 2 write”

Online:
– http://www.linuxmanpages.com/
– http://man.he.net/
– http://www.die.net/doc/linux/man/
Assembly – Referências
www.cin.ufpe.br/~htcrs/if677/
Exercício

Escreva programas em C que
implementem:
– Loops
– Impressão de String na tela


Gere o código assembly
correspondente a esses programas
Analise o código gerado