ASSEMBLY Lucas Aranha lab 3cin ufpe br Assembly
ASSEMBLY Lucas Aranha lab 3@cin. ufpe. br
Assembly n Assembly é uma linguagem de baixo nível, chamada freqüentemente de “linguagem de montagem” n É uma linguagem considerada difícil, principalmente porque o programador precisa conhecer a estrutura da máquina para usá-la
Assembly n A linguagem Assembly é atrelada à arquitetura de uma certa CPU, ou seja, ela depende completamente do hardware n Por essa razão Assembly não é uma linguagem portável, ao contrário da maioria das linguagens de alto nível
Assembly - História n As primeiras linguagens Assembly surgiram na década de 50, na chamada segunda geração das linguagens de programação n A segunda geração visou libertar os programadores de dificuldades como lembrar códigos numéricos e calcular endereços
Assembly - História n Assembly foi muito usada para várias aplicações até os anos 80, quando foi substituída pelas linguagens de alto nível n Isso aconteceu principalmente pela necessidade de aumento da produtividade de software
Assembly - História n Atualmente Assembly é usada para manipulação direta de hardware e para sistemas que necessitem de performance crítica n Device drivers, sistemas embarcados de baixo nível e sistemas de tempo real são exemplos de aplicações que usam Assembly
Assembly - Assembler n A linguagem Assembly é de baixo nível, porém ainda precisa ser transformada na linguagem que a máquina entende n Quem faz isso é o Assembler. O Assembler é um utilitário que traduz o código Assembly para a máquina
Assembly - Assembler n Exemplo: Antes -> mov al, 061 h (x 86/IA-32) Depois -> 101100001
Assembly - Fundamentos n 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 n Um byte possui 8 bits, um word possui 16 bits ou 2 bytes e um dword possui 32 bits ou 4 bytes
Assembly - Fundamentos n Em Assembly é comum representar os números na forma hexadecimal. Isso acontece porque é interessante visualizar o número na forma de dados n A representação hexadecimal facilita o tratamento de números muito grandes e permite saber quais bits estão “ligados” ou “desligados”
Assembly - Fundamentos n Um algarismo hexadecimal pode ser representado por quatro algarismos binários n 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 Binário Hexa Decimal Tipo 10000000 80 128 byte 8001 32. 769 word 1111111 111 FFFF 65. 535 word 1111111111111 FFFF 4. 294. 967. dword 295 1000000 001
Assembly - Registradores n Registradores são áreas especiais dentro do processador que são mais rápidas que operandos de memória. n Como vamos trabalhar com o processador Intel, existem apenas 8 registradores de uso geral
Assembly - Registradores São eles: EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP n n Os registradores ESP e EBP só devem ser usados preferencialmente para trabalhar com a pilha
Assembly - Registradores n Nos registradores de uso geral (Exceto ESI e EDI) é permitido usar três modos de acesso diferentes, ilustrados pela figura abaixo:
Assembly - Registradores n EAX -> Chamado de “Acumulador”, geralmente é usado para operações aritméticas e para guardar resultados n EBX -> Chamado de “Base”, geralmente é usado para armazenar dados em geral e para endereços de memória
Assembly - Registradores n ECX -> Chamado de “Contador”, como o nome já diz é usado como contador, principalmente para controlar loops n EDX -> Chamado de registrador de dados, é usado geralmente para guardar o endereço de uma variável na memória
Assembly - Registradores n 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 n 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 n Entre os registradores que não são de uso geral, existe um registrador muito relevante para o programador, o registrador flags n 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 n n n O => Overflow D => Direction I => Interrupt Enable T => Trap S => Signal
Assembly - Registradores n n Z => Zero A => Auxiliar Carry P => Parity C => Carry
Assembly - Pilha n 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 n Já em Assembly, o programador precisa saber trabalhar com a pilha, pois ela é uma ferramenta importante
Assembly - Pilha n 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 n 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 - Instruções n Movimentação de dados: - mov destino, fonte (Sintaxe Intel) - mov fonte, destino (Sintaxe AT&T) n Obs: Nas instruções AT&T, é necessário informar o tamanho do dado com que se está trabalhando
Assembly - Instruções Intel AT&T mov eax, 1 movl $1, %eax mov ebx, 0 ffh movl $0 xff, %ebx mov eax, [ebx] movl (%ebx), %eax mov eax, [ebx+3] movl 3(%ebx), %eax
Assembly - Instruções n 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 n 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 n 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 - Intruções n Instrução de comparação: - cmp operando 1, operando 2 (Sintaxe Intel) Exemplo: cmp 08 h, eax - cmp operando 1, operando 2 (Sintaxe AT&T) Exemplo: cmp $0 x 8, %eax
Assembly - Instruções n 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 “Pulo” condicional: - je [100] (Sintaxe Intel) - jne eax (Sintaxe Intel) - je *100 (Sintaxe AT&T) - jne *%eax (Sintaxe AT&T)
Assembly - Instruções n 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 - Seções n 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 - Exemplo: section. data mensagem: db 'Hello world!' msglength: equ 12
Assembly - Seções - 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 - section. text -> Essa é a seção onde o código do programa é escrito - Exemplo: section. text global _start: . .
Assembly – Interrupções n Interrupções são chamadas ao processador requisitando um serviço n 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 n Quando isso acontece, o processador salva o processo atual e executa a rotina daquela interrupção n 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 n n 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 - Exemplo (Sintaxe Intel): mov eax, 1 ; Interrupção Exit mov ebx, 0 ; Argumento em EBX int 80 h ; Chamada da interrupção - Exemplo (Sintaxe AT&T): movl $1, %eax movl $0, %ebx int $0 x 80
Assembly - Exemplo n Hello World (Sintaxe Intel) section. data hello: db 'Hello world!', 10 ; A string 'Hello World!‘ e um linefeed hello. Lenght: equ $-hello ; Tamanho da string hello section. text global _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, hello. Lenght ; Argumento que indica o tamanho da string int 80 h ; Chamada da interrupção mov eax, 1 ; Interrupção exit (sys_exit) mov ebx, 0 ; Argumento da interrupção int 80 h ; Chamada da interrupção
Assembly - Exemplo n Hello World (Sintaxe AT&T) . data hello: . string "Hello World!n". text. globl main: mov $4, %eax mov $1, %ebx mov $hello, %ecx mov $13, %edx int $0 x 80 mov $1, %eax mov $0, %ebx int $0 x 80
Assembly – Referências www. cin. ufpe. br/~lab 3 No meu public estarei atualizando o arquivo “Links-if 677. txt” sempre que encontrar referências interessantes
- Slides: 45