ASSEMBLY

1
ASSEMBLY

• Lucas Aranha
• lab3_at_cin.ufpe.br

2
Assembly

• Assembly é uma linguagem de baixo nível, chamada
  freqüentemente de linguagem de montagem
• É uma linguagem considerada difícil,
  principalmente porque o programador precisa
  conhecer a estrutura da máquina para usá-la

3
Assembly

• A linguagem Assembly é atrelada à arquitetura de
  uma certa CPU, ou seja, ela depende completamente
  do hardware
• Por essa razão Assembly não é uma linguagem
  portável, ao contrário da maioria das linguagens
  de alto nível

4
Assembly - História

• As primeiras linguagens Assembly surgiram na
  década de 50, na chamada segunda geração das
  linguagens de programação
• A segunda geração visou libertar os programadores
  de dificuldades como lembrar códigos numéricos e
  calcular endereços

5
Assembly - História

• Assembly foi muito usada para várias aplicações
  até os anos 80, quando foi substituída pelas
  linguagens de alto nível
• Isso aconteceu principalmente pela necessidade de
  aumento da produtividade de software

6
Assembly - História

• Atualmente Assembly é usada para manipulação
  direta de hardware e para sistemas que necessitem
  de performance crítica
• Device drivers, sistemas embarcados de baixo
  nível e sistemas de tempo real são exemplos de
  aplicações que usam Assembly

7
Assembly - Assembler

• A linguagem Assembly é de baixo nível, porém
  ainda precisa ser transformada na linguagem que a
  máquina entende
• Quem faz isso é o Assembler. O Assembler é um
  utilitário que traduz o código Assembly para a
  máquina

8
Assembly - Assembler

• Exemplo
• Antes -gt mov al, 061h (x86/IA-32)
• Depois -gt 10110000 01100001

9
Assembly - Fundamentos

• Byte, Word e Dword são blocos de dados básicos. O
  processador trabalha com o tamanho de dados
  adequados para executar as instruções
• Um byte possui 8 bits, um word possui 16 bits ou
  2 bytes e um dword possui 32 bits ou 4 bytes

10
Assembly - Fundamentos

• Em Assembly é comum representar os números na
  forma hexadecimal. Isso acontece porque é
  interessante visualizar o número na forma de
  dados
• A representação hexadecimal facilita o tratamento
  de números muito grandes e permite saber quais
  bits estão ligados ou desligados

11
Assembly - Fundamentos

• Um algarismo hexadecimal pode ser representado
  por quatro algarismos binários
• Logo um byte pode ser representado como dois
  números hexa, um word como quatro números hexa e
  um dword como oito números hexa

12
Assembly - Fundamentos
Binário Hexa Decimal Tipo
10000000 80 128 byte
1000000000000001 8001 32.769 word
1111111111111111 FFFF 65.535 word
11111111111111111111111111111111 FFFFFFFF 4.294.967.295 dword
13
Assembly - Registradores

• Registradores são áreas especiais dentro do
  processador que são mais rápidas que operandos de
  memória.
• Como vamos trabalhar com o processador Intel,
  existem apenas 8 registradores de uso geral

14
Assembly - Registradores

• São eles
• EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP
• Os registradores ESP e EBP só devem ser usados
  preferencialmente para trabalhar com a pilha

15
Assembly - Registradores

• Nos registradores de uso geral (Exceto ESI e EDI)
  é permitido usar três modos de acesso diferentes,
  ilustrados pela figura abaixo

16
Assembly - Registradores

• EAX -gt Chamado de Acumulador, geralmente é
  usado para operações aritméticas e para guardar
  resultados
• EBX -gt Chamado de Base, geralmente é usado para
  armazenar dados em geral e para endereços de
  memória

17
Assembly - Registradores

• ECX -gt Chamado de Contador, como o nome já diz
  é usado como contador, principalmente para
  controlar loops
• EDX -gt Chamado de registrador de dados, é usado
  geralmente para guardar o endereço de uma
  variável na memória

18
Assembly - Registradores

• ESI e EDI -gt Respectivamente Source Index e
  Destination Index, são menos usados do que os
  registradores descritos anteriormente. Geralmente
  usa-se ESI e EDI para movimentação de dados, com
  ESI guardando o endereço fonte de uma variável e
  EDI guardando o endereço destino. Não podem ser
  acessados em nível de Byte.

19
Assembly - Registradores

• ESP e EBP -gt Respectivamente Stack Pointer e
  Base Pointer, só devem ser usados para
  manipulação da pilha. O Registrador ESP guarda a
  referência para o topo da pilha, enquanto o
  registrador EBP é usado para andar pela pilha

20
Assembly - Registradores

• Entre os registradores que não são de uso geral,
  existe um registrador muito relevante para o
  programador, o registrador flags
• Através do registrador flags podemos saber se
  dois valores são iguais, se um é maior que outro
  ou se um valor é negativo, além de outras
  informações

21
Assembly - Registradores

• O gt Overflow
• D gt Direction
• I gt Interrupt Enable
• T gt Trap
• S gt Signal

22
Assembly - Registradores

• Z gt Zero
• A gt Auxiliar Carry
• P gt Parity
• C gt Carry

23
Assembly - Pilha

• Todos os programas fazem uso da pilha em tempo de
  execução, porém nas linguagens de alto nível não
  é preciso se preocupar com o funcionamento da
  pilha
• Já em Assembly, o programador precisa saber
  trabalhar com a pilha, pois ela é uma ferramenta
  importante

24
Assembly - Pilha

• A pilha é uma área de dados existente na memória
  em tempo de execução, na qual seu programa pode
  armazenar dados temporariamente
• O processador é rápido no acesso à pilha, tanto
  para escrever quanto para ler

25
Assembly - Pilha

• As principais funcionalidades da pilha são
• - Preservar valores de registradores em funções
• - Preservar dados da memória
• - Transferir dados sem usar registradores
• - Reverter a ordem de dados
• - Chamar outras funções e depois retornar
• - Passar parâmetros para funções

26
Assembly - Instruções

• Movimentação de dados
• - mov destino, fonte (Sintaxe Intel)
• - mov fonte, destino (Sintaxe ATT)
• Obs Nas instruções ATT, é necessário informar o
  tamanho do dado com que se está trabalhando

27
Assembly - Instruções
Intel ATT
mov eax, 1 movl 1, eax
mov ebx, 0ffh movl 0xff, ebx
mov eax, ebx movl (ebx), eax
mov eax, ebx3 movl 3(ebx), eax
28
Assembly - Instruções

• Instrução de soma
• - add destino, fonte (Sintaxe Intel)
• Exemplo add eax,ebxecx
• - add fonte, destino (Sintaxe ATT)
• Exemplo addl (ebx,ecx),eax

29
Assembly - Instruções

• Instrução de subtração
• - sub destino, fonte (Sintaxe Intel)
• Exemplo sub eax,ebx
• - sub fonte, destino (Sintaxe ATT)
• Exemplo subl ebx,eax

30
Assembly - Instruções

• Instruções de operações lógicas
• - and/or/xor destino, fonte (Sintaxe Intel)
• Exemplo and ax,bx
• - and/or/xor fonte, destino (Sintaxe ATT)
• Exemplo andw bx,ax

31
Assembly - Intruções

• Instrução de comparação
• - cmp operando1, operando2 (Sintaxe Intel)
• Exemplo cmp 08h, eax
• - cmp operando1, operando2 (Sintaxe ATT)
• Exemplo cmp 0x8, eax

32
Assembly - Instruções

• Instruções de jump
• Pulo incondicional
• - jmp 100 (Sintaxe Intel)
• - jmp eax (Sintaxe Intel)
• - jmp 100 (Sintaxe ATT)
• - jmp eax (Sintaxe ATT)

33
Assembly - Instruções

• Pulo condicional
• - je 100 (Sintaxe Intel)
• - jne eax (Sintaxe Intel)
• - je 100 (Sintaxe ATT)
• - jne eax (Sintaxe ATT)

34
Assembly - Instruções

• Instruções de manipulação da pilha
• - push eax (Sintaxe Intel)
• - push eax (Sintaxe ATT)
• - pop eax (Sintaxe Intel)
• - pop eax (Sintaxe ATT)

35
Assembly - Seções

• O código Assembly é dividido em seções. As
  principais seções no Linux são
• - section .data -gt A seção .data é usada para
  declarar variáveis inicializadas. Porém essas
  variáveis não mudam no decorrer do programa.
  Essa seção é usada geralmente para definir nomes
  de arquivos, constantes, entre outros.

36
Assembly - Seções

• - Exemplo
• section .data
• mensagem db 'Hello world!'
• msglength equ 12

37
Assembly - Seções

• - section .bss -gt É a seção usada para declarar
  as variáveis do programa
• - Exemplo
• section .bss
• nomearq resb 230 Reserva 230 bytes
• numero resb 1 Reserva 1 byte
• array resw 10 Reserva 10 words

38
Assembly - Seções

• - section .text -gt Essa é a seção onde o código
  do programa é escrito
• - Exemplo
• section .text
• global _start
• _start . . .
• . . .
• . . .

39
Assembly Interrupções

• Interrupções são chamadas ao processador
  requisitando um serviço
• O nome interrupção vem do fato de que o
  processador tem sua atividade atual interrompida
  quando recebe um sinal de chamada

40
Assembly - Interrupções

• Quando isso acontece, o processador salva o
  processo atual e executa a rotina daquela
  interrupção
• Após a execução da rotina, que geralmente está
  armazenada em uma tabela na memória RAM, o
  processador retorna ao processo em que estava
  anteriormente

41
Assembly - Interrupções

• Para se chamar uma interrupção no Linux, é feito
  o seguinte processo
• - Coloca-se o número da interrupção no
  registrador EAX
• - Coloca-se os argumentos requeridos pela
  interrupção nos devidos registradores
• - Chama-se a interrupção
• O resultado geralmente será retornado em EAX

42
Assembly - Interrupções

• - Exemplo (Sintaxe Intel)
• mov eax,1 Interrupção Exit
• mov ebx,0 Argumento em EBX
• int 80h Chamada da interrupção
• - Exemplo (Sintaxe ATT)
• movl 1,eax
• movl 0, ebx
• int 0x80

43
Assembly - Exemplo

• Hello World (Sintaxe Intel)
• section .data
• hello db 'Hello world!',10 A string 'Hello
  World! e um linefeed
• helloLenght equ -hello Tamanho da string
  hello
• section .text
• global _start
• _start
• mov eax,4 Interrupção de escrita (sys_write)
• mov ebx,1 Argumento que indica onde a string
  vai ser escrita
• mov ecx,hello Argumento que indica o endereço
  da string
• mov edx,helloLenght Argumento que indica o
  tamanho da string
• int 80h Chamada da interrupção
• mov eax,1 Interrupção exit (sys_exit)
• mov ebx,0 Argumento da interrupção
• int 80h Chamada da interrupção

44
Assembly - Exemplo

• Hello World (Sintaxe ATT)
• .data
• hello .string "Hello World!\n"
• .text
• .globl main
• main
• mov 4,eax
• mov 1,ebx
• mov hello,ecx
• mov 13,edx
• int 0x80
• mov 1,eax
• mov 0,ebx
• int 0x80

45
Assembly Referências

• www.cin.ufpe.br/lab3
• No meu public estarei atualizando o arquivo
  Links-if677.txt sempre que encontrar
  referências interessantes