ASSEMBLY

1. ASSEMBLY Ciro Ceissler clac@cin.ufpe.br / ciro.ceissler@gmail.com

2. 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 Assembly

3. 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 Assembly

4. 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 Assembly

5. 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 Assembly - História

6. 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 Assembly - História

7. 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 Assembly - História

8. 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 Assembly - Assembler

9. Exemplo: Antes -> mov al, 061h (x86/IA-32) Depois -> 10110000 01100001 Assembly - Assembler

10. 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 Assembly - Fundamentos

11. 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” Assembly - Fundamentos

12. 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 Assembly - Fundamentos

13. Assembly - Fundamentos

14. 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 Assembly - Registradores

15. 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 Assembly - Registradores

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. EAX -> Chamado de “Acumulador”, geralmente é usado para operações aritméticas e para guardar resultados • EBX -> Chamado de “Base”, geralmente é usado para armazenar dados em geral e para endereços de memória Assembly - Registradores

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

19. ESI e EDI -> 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. Assembly - Registradores

20. ESP e EBP -> 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 Assembly - Registradores

21. 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 Assembly - Registradores

22. Assembly - Registradores • O => Overflow • D => Direction • I => Interrupt Enable • T => Trap • S => Signal

23. Assembly - Registradores • Z => Zero • A => Auxiliar Carry • P => Parity • C => Carry

24. 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 Assembly - Pilha

25. 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 Assembly - Pilha

26. 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 Assembly - Pilha

27. push ax push bx push cx push dx push ds push es push di push si pusha push es, ds popa pop es, ds Assembly – Exemplo Pilha

28. Movimentação de dados: - mov destino, fonte (Sintaxe Intel) - mov fonte, destino (Sintaxe AT&T) • Obs: Nas instruções AT&T, é necessário informar o tamanho do dado com que se está trabalhando Assembly - Instruções

29. Assembly - Instruções

30. Instrução de soma: - add destino, fonte (Sintaxe Intel) Exemplo: add eax,[ebx+ecx] - add fonte, destino (Sintaxe AT&T) Exemplo: addl (%ebx,%ecx),%eax Assembly - Instruções

31. Instrução de subtração: - sub destino, fonte (Sintaxe Intel) Exemplo: sub eax,ebx - sub fonte, destino (Sintaxe AT&T) Exemplo: subl %ebx,%eax Assembly - Instruções

32. Instruções de operações lógicas: - and/or/xor destino, fonte (Sintaxe Intel) Exemplo: and ax,bx - and/or/xor fonte, destino (Sintaxe AT&T) Exemplo: andw %bx,%ax Assembly - Instruções

33. Instrução de comparação: - cmp operando1, operando2 (Sintaxe Intel) Exemplo: cmp 08h, eax - cmp operando1, operando2 (Sintaxe AT&T) Exemplo: cmp $0x8, %eax Assembly - Instruções

34. Instruções de jump: “Pulo” incondicional: - jmp [100] (Sintaxe Intel) - jmp eax (Sintaxe Intel) - jmp *100 (Sintaxe AT&T) - jmp *%eax (Sintaxe AT&T) Assembly - Instruções

35. “Pulo” condicional: - je [100] (Sintaxe Intel) - jne eax (Sintaxe Intel) - je *100 (Sintaxe AT&T) - jne *%eax (Sintaxe AT&T) Assembly - Instruções

36. Instruções de manipulação da pilha: - push eax (Sintaxe Intel) - push %eax (Sintaxe AT&T) - pop eax (Sintaxe Intel) - Pop %eax (Sintaxe AT&T) Assembly - Instruções

37. O código Assembly é dividido em seções. As principais seções no Linux são: - section .data -> 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. Assembly - Seções

38. - Exemplo: section .data mensagem: db 'Hello world!' msglength: equ 12 Assembly - Seções

39. - section .bss -> É 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 Assembly - Seções

40. - section .text -> Essa é a seção onde o código do programa é escrito - Exemplo: section .text global _start _start: . . . . . . . . . Assembly - Seções

41. 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 Assembly - Interrupções

42. 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 Assembly - Interrupções

43. 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 Assembly - Interrupções

44. - Exemplo (Sintaxe Intel): mov eax,1 ; Interrupção Exit mov ebx,0 ; Argumento em EBX int 80h ; Chamada da interrupção - Exemplo (Sintaxe AT&T): movl $1,%eax movl $0, %ebx int $0x80 Assembly - Interrupções

45. Assembly - Interrupções

46. Um programa é constituido por várias regiões de memória. • Pilha • Heap • Código • Dados Assembly – Organização do Programa

47. 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 Assembly - Exemplo

48. Hello World (Sintaxe AT&T) .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 Assembly - Exemplo

49. .stack .data include arquivo1.asm include arquivo2.asm .code start: include arquivo3.asm end start Assembly - Include

50. .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 Assembly – Carregar Arquivos