ASSEMBLY

1
ASSEMBLY

• Ciro Ceissler
• clac_at_cin.ufpe.br / ciro.ceissler_at_gmail.com

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
• Cada família de processador tem sua própria
  linguagem assembly (Ex. X86, ARM, SPARC, MIPS)
• Por essa razão Assembly não é uma linguagem
  portável, ao contrário da maioria das linguagens
  de alto nível

4
Assembly

• Antes do assembly
• adição do microprocessador de sinal digital (DSP)
  TMS-320C54x da Texas Instruments
• 0000000SIAAAAAAA
• instrução de adição dos computadores B-200, B-300
  e B-500 da Burroughs Corporation
• Campo O M N AAA BBB CCC
• Código 1 2 3 100 200 300

5
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

6
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

7
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

8
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

9
Assembly - Assembler

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

10
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

11
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

12
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

13
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
14
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

15
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

16
Assembly - Registradores

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

17
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

18
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

19
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.

20
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

21
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

22
Assembly - Registradores

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

23
Assembly - Registradores

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

24
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

25
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

26
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

27
Assembly Exemplo Pilha

• push ax
• push bx
• push cx
• push dx
• push ds
• push es
• push di
• push si

pusha push es, ds popa pop es, ds
28
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

29
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
30
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

31
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

32
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

33
Assembly - Instruções

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

34
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)

35
Assembly - Instruções

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

36
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)

37
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.

38
Assembly - Seções

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

39
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

40
Assembly - Seções

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

41
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

42
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

43
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

44
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

45
Assembly - Interrupções
46
Assembly Organização do Programa

• Um programa é constituido por várias regiões de
  memória.
• Pilha
• Heap
• Código
• Dados

47
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 modo de 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

48
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

49
Assembly - Include

• .stack
• .data
• include arquivo1.asm
• include arquivo2.asm
• .code
• start
• include arquivo3.asm
• end start

50
Assembly Carregar Arquivos

• .data
• arquivo1 db 'dat/arquivo1' , 0
• arquivo2 db 'dat/arquivo2' , 0
• arquivo3 db 'dat/arquivo3' , 0
• arquivo4 db 'dat/arquivo4' , 0
• arquivo5 db 'dat/arquivo5' , 0
• arquivo6 db 'dat/arquivo6' , 0
• arquivo7 db 'dat/arquivo7' , 0
• arquivo8 db 'dat/arquivo8' , 0

51
Assembly - Procedimentos

• .text
• call NomeProcedimento
• NomeProcedimento PROC NEAR
• mov ax, 0x0F
• ret
• NomeProcedimento ENDP

52
Assembly Interrupção de Vídeo

• Exemplo
• mov ah, 0
• mov al, 13h modo video 320200
• int 10h
• Video Display Area (RAM)
• A000 -gt gráficos de alta resolução
• B000
• B800

53
Assembly Referências

• www.cin.ufpe.br/clac/infra_de_software
• http//www.wagemakers.be/english/doc/vga
• http//www.scribd.com/doc/13290971/INTERRUPCOES
• http//maven.smith.edu/thiebaut/ArtOfAssembly/art
  ofasm.html
• http//www.xs4all.nl/smit/asm04001.htmvga
• http//arapaho.nsuok.edu/kingw/CS3173/Chapter9.ht
  m
• http//burks.bton.ac.uk/burks/language/asm/asmtut/
  asm8.htm