Programar em Assembly com GAS/Instruções

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Instruções GNU Assembler[editar | editar código-fonte]

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[editar | editar código-fonte]

Na linguagem assembly as instruções e operadores são representados da forma seguinte:

label:  mnemônico  argumento1, argumento2, argumento3
Exemplo: mover_dados: movl $hoje,%eax

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:

movw $0, %ax

Instruções de movimentação de dados[editar | editar código-fonte]

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:

  MOVER  Fonte,Destino
    movw    %ax, %bx 
Coloca o conteudo do registro %ax dentro de %bx . movw $4,%bx Agora o registrador %bx contem 4

Instruções para manipulação de stack[editar | editar código-fonte]

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:

PUSH "GUARDAR"  Fonte
pushl $4
  • Em uma pilha(stack) o primeiro dado a entrar é o último a sair.

Exemplo:

pushw %ax
pushw %bx
pushw %cx


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 :

     POP "RECUPERAR" Destino
     popw %ax
  • Para retornar os valores da pilha referentes à cada registrador é necessário seguir a ordem inversa utilizada com PUSH.
     popw %cx
     popw %bx
     popw %ax

Instrução call e ret[editar | editar código-fonte]

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:

rotina :  # call executa o código a partir desse label.
movw %0x01,%bx
ret       # Atualiza o apontador de instrução
label:
call rotina
movw  %ax,%bx # Instrução executada depois da instrução ret

Instruções para operações booleanas[editar | editar código-fonte]

Instruções de transferência de controle condicional[editar | editar código-fonte]

Operações com string[editar | editar código-fonte]

Instruções de controle de flag[editar | editar código-fonte]

Instruções de acesso a portas de entrada e saída[editar | editar código-fonte]

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.

IN {destinação},{porta}

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.

OUT {fonte},{porta}

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

Instruções de uso geral[editar | editar código-fonte]