ASSEMBLY – aula 2

Hugo Calazans
André Ricardo
Roteiro
1- Intel x AT&T
2- Pilha e command line arguments
3- Procedimentos
4- Simulando alguns comandos C
5- Assembly inline
6- Criando um projeto C/C++ no eclipse
7- Exemplos de código c/c++
8- Exemplos de código Assembly inline
9- Linux Man Pages
10- Referências
Intel x AT&T

 Diferenças:
1- Ordenação entre source e destination
2- Nome dos registradores
3- Operandos imediatos (immediate)
4- Tamanho dos operandos
5- Operandos na memória
Intel x AT&T

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
- Exemplo: Fatorial
 C

int fatorial (int numero) {

int y = 1;
if (numero <= 1)
return 1;
y = numero * fatorial (numero - 1);
return y;
}
Intel x AT&T
- Exemplo: Fatorial
 Intel
.globl main
main:
mov eax, 5
mov ebx, 1
L1: 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
L2: ret
Intel x AT&T
- Exemplo: Fatorial
 AT&T
.globl main
main:
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
; código do seu programa
section .data
pop edi
section .text pop esi
global _start pop ebx
mov esp,ebp
_start: pop ebp
push epb
mov ebp,esp
push ebx
push esi
push edi
Intel x AT&T
- Exemplo: Ponto de entrada
 AT&T
.data
; código do seu programa
.globl main
popl %edi
main: popl %esi
pushl %epb popl %ebx
movl %ebp,%esp movl %esp,%ebp
pushl %ebx popl %ebp
pushl %esi
pushl %edi
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 AT&T O que é?

pop eax pop %eax # de args
pop ebx pop %ebx “programa”
pop ecx pop %ecx “infra”
pop edx pop %edx “software”
pop eax pop %eax “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 AT&T

fileWrite: fileWrite:
mov eax,4 movl $4, %eax
mov ebx, [filedesc] movl ($filedesc), %ebx
mov ecx, stuffToWrite movl $stuffToWrite,
mov edx, [stuffLen] %ecx
int 80h movl ($stuffLen), %edx
ret int $0x80
; endp fileWrite 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 NASM
cmp eax, 'w'
if (EAX == 'w') {
writeFile(); jne skipWrite ; Se não, skip
} else {
doSomethingElse(); call writeFile
} jmp outOfThisMess

skipWrite:
call doSomethingElse

outOfThisMess:
... ; resto do programa
Simulando comandos C
- If-then-else
C AT&T
cmpl 'w‘, %eax
if (EAX == 'w') {
writeFile(); jne skipWrite ; Se não, skip
} else {
doSomethingElse(); call writeFile
} jmp outOfThisMess

skipWrite:
call doSomethingElse

outOfThisMess:
... ; resto do programa
Simulando comandos C
- while
C NASM

int i = 0; mov eax, 0

whileLoop: mov ebx, 100
while(i< 100){ cmp eax, ebx
i = i + 1; jge WhileTerminado
} inc eax
jmp WhileLoop

WhileTerminado:
;resto do código
Simulando comandos C
- while
C AT&T

int i = 0; movl $0, %eax

whileLoop: movl $100, %ebx
while(i< 100){ cmpl %ebx, %eax
i = i + 1; 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 // SYS_exit
xor %ebx,%ebx
int $0x80
");
}
Criando um projeto
C/C++ no eclipse
Exemplo Código C/C++
Executando a aplicação
Hello World usando
Interrupções
Chamando funções
externas
Chamando funções externas
(múltiplos parametros)
Chamando funções externas
(múltiplos parametros)
Obtendo o tempo de
sistema
Criando e Modificando
Arquivos
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

http://www/~htcrs/if677/assembly/referencias.txt