# Instruções GNU Assembler

Uma instrução é o operação básica que o processador pode executar. As instruções são armazenadas na memória principal, a fim de ser processada pelo processador. Uma instrução é composta por:
* O código de operação (ou Opcode) que representa a ação que o processador deve executar.
* O código do operando que define os parâmetros da ação. O código de operação depende da operação. Ele pode ser um dado ou um endereço da memória.
Para que servem as instruções?
Vamos ver algumas operações de bases que podemos obter utilizando instruções.
* Movimentar dados :
** Colocar um valor dentro de um registro.
** Colocar dados contido em um registro na memoria principal e vice-versa.
* Operações Aritméticas :
** Adicionar e subtrair o valor de dois registro e colocar o resultado em um terceiro.
* Operações lógicas :
** Combinar o valor de dois registro com operações booleanas(operações bit a bit).
* Operações de desvio "JUMP" :
** Salto de um lugar a outro ; em assembly as instruções são executadas de maneira sequencial, uma depois da outra.
* Comparações:
** Comparar o valor de dois registros.
* Manipular cadeias de caracteres(strings).
* Controle do processador.
* Controle de interrupções.
* Realizar operações de entrada e saída
** Troca de informações entre o processador e periféricos.

## Instruções e operadores

Na linguagem assembly as instruções e operadores são representados da forma seguinte:
label: Uma etiqueta é um identificador que é seguido por dois pontos. mnemônico E um nome reservado de uma classe de códigos de operação de instrução que têm a mesma função.
Quando usamos a norma AT&T devemos especificar o tamanho colocando uma letra no final da instrução:
* B : Byte, 1 octeto
* W : Word, 2 octetos
* L : Long Word, 4 octetos
* Q : Quad Word, 8 octetos
Exemplo:

## Instruções de movimentação de dados

Em assembly a movimentação de dados e feita com a instrução "MOV" que é o mnemônico de "MOVER". MOV se encarrega de passar o conteúdo do operando Fonte para o do Destino (AT&T). O GNU assembler usa a syntaxe AT&T para seus operadores.
Exemplo:

## Instruções para manipulação de stack

A instrução PUSH se encarrega de guardar o conteúdo do operando Fonte na Pilha. Sintaxe AT&T pushb,pushw,pushl,pushf . pushf : Guarda o conteúdo do registrador de estado na pilha.
Exemplo:
* Em uma pilha(stack) o primeiro dado a entrar é o último a sair.
Exemplo:
POP esta instrução recupera o conteúdo guardado na pilha. Sintaxe AT&T popb,popw,popl,popf. popf : Tira da pilha e coloca no registrador de estado.
Exemplo :
* Para retornar os valores da pilha referentes à cada registrador é necessário seguir a ordem inversa utilizada com PUSH.

### Instrução call e ret

Com essa duas instruções a pilha pode ser usada sem nos dar conta . Quando usamos a instrução call para a chamada de um novo procedimento o endereço estocado no registro %ip (Da próxima instrução depois de call) é colocado na pilha e o da próxima rotina é colocado no registrador %ip.
A instrução ret(Que não tem argumento)desempilha e coloca no registro %ip . O registro %ip é o equivalente de %eip no modo 32 bits. Exemplo:

## Instruções de acesso a portas de entrada e saída

IN: instrução para operações de entrada de dados. Lê um valor 8 bits na porta {porta} (16 bits) e estoca em {destinação}.O único registro autorizado para porta {porta} é DX.
OUT: instrução para operações de saída de dados. Escreve o valor {fonte} (8 bits) na porta {porta} (16 bits). O único registro autorizado para porta {porta} é DX.
Instruções para leitura e escritura de uma sequência de octetos (E/S por blocos):
ins:Essa instrução solicita uma porta de entrada/saída e retorna o resultado no endereço ES:DI e incrementa/decrementa o registrador DI outs:Essa instrução move dados do endereço DS:SI para a porta especificada em DX e incrementa/decrementa o registrador SI