A linguagem ASSEMBLY - Adriano Maranhão · surgiram na década de 50, na chamada segunda geração...

A linguagem ASSEMBLY

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

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

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

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


� 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


� 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 - 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

Assembly - Assembler

�  Exemplo: Antes -> mov al, 061h (x86/IA-32) Depois -> 10110000 01100001

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


�  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”


� 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


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

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


� 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


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


�  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


�  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


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


�  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


�  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


�  O => Overflow �  D => Direction �  I => Interrupt Enable �  T => Trap �  S => Signal


� Z => Zero � A => Auxiliar Carry �  P => Parity � C => Carry

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

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

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

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

Assembly - Instruções

� 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


Intel

AT&T

mov eax, 1

movl $1, %eax

mov ebx, 0ffh

movl $0xff, %ebx

mov eax, [ebx]

movl (%ebx), %eax

mov eax, [ebx+3]

movl 3(%ebx), %eax


�  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


�  Instrução de subtração:

- sub destino, fonte (Sintaxe Intel) Exemplo: sub eax,ebx - sub fonte, destino (Sintaxe AT&T) Exemplo: subl %ebx,%eax


�  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


�  Instrução de comparação:

- cmp operando1, operando2 (Sintaxe Intel)

Exemplo: cmp 08h, eax - cmp operando1, operando2 (Sintaxe

AT&T) Exemplo: cmp $0x8, %eax


�  Instruções de jump: “Pulo” incondicional: - jmp [100] (Sintaxe Intel) - jmp eax (Sintaxe Intel)

- jmp *100 (Sintaxe AT&T) - jmp *%eax (Sintaxe AT&T)


“Pulo” condicional: - je [100] (Sintaxe Intel) - jne eax (Sintaxe Intel)

- je *100 (Sintaxe AT&T) - jne *%eax (Sintaxe AT&T)


�  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

� 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

_start: . . . . . . . . .

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


� 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


�  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


- 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 – Organização do Programa

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

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

Assembly - Exemplo

�  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 - Include

.stack

.data include arquivo1.asm include arquivo2.asm

.code start: include arquivo3.asm

end start

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

Assembly - Procedimentos

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

Assembly – Interrupção de Vídeo

�  Exemplo mov ah, 0 mov al, 13h ; modo video 320*200 int 10h � Video Display Area (RAM) ◦ A000 -> gráficos de alta resolução ◦ B000 ◦ B800

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/

artofasm.html �  http://www.xs4all.nl/~smit/asm04001.htm#vga �  http://arapaho.nsuok.edu/~kingw/CS3173/

Chapter9.htm �  http://burks.bton.ac.uk/burks/language/asm/asmtut/

asm8.htm

A linguagem ASSEMBLY - Adriano Maranhão · surgiram na década de 50, na chamada segunda geração...

Documents

Transcript of A linguagem ASSEMBLY - Adriano Maranhão · surgiram na década de 50, na chamada segunda geração...