Trabalho de pesquisa sobre registos de dados, registos de segmentos, registos de apontador de pilha e Índice

Registos de dados

Os 8 GPRs, ou Registos de Uso Geral, são os seguintes (por ordem de introdução na pilha ao executar a instrução PUSHAD):

• EAX - Acumulador. Usado em operações aritméticas.
• ECX - Contador. Usado em loops.
• EDX - Registo de Dados. Usado em operações de entrada/saída e em multiplicações e divisões. É também uma extensão do Acumulador.
• EBX - Base. Usado para apontar para dados no segmento DS.
• ESP - Apontador da Pilha (Stack Pointer). Aponta para o topo da pilha (endereço mais baixo dos elementos da pilha).
• EBP - Apontador da base do frame. Usado para aceder a argumentos de procedimentos passados pela pilha.
• ESI - Índice da fonte de dados a copiar (Source Index). Aponta para dados a copiar para DS:EDI.
• EDI - Índice do destino de dados a copiar (Destination Index). Aponta para o destino dos dados a copiar de DS:ESI.

Estes 8 registos têm 32 bits cada um e dizem-se Estendidos. 

Os 16 bits de ordem mais baixa de cada um dos registos podem ser acedidos através das versões não estendidas destes. As versões de 16 bits têm os mesmo nomes que as de 32 bits, com excepção de a letra E ser retirada (ex: EAX → AX). As versões estendidas dos registos não existem em gerações anteriores à 80386 ― a primeira geração de processadores 32 bits da arquitectura x86.

As versões não estendidas dos quatro primeiros GPRs dividem-se ainda em dois grupos de 8 bits cada um. O octeto (byte) de ordem mais alta é acedido trocando o X por um H(exemplo: AX → AH), e o octeto de ordem mais baixa trocando o X por um L (ex: AX → AL).

Registos de segmento

Há 6 registos de segmento.

• CS - Segmento do Código.
• DS - Segmento de Dados.
• ES - Segmento com dados extra.
• FS - Segmento com mais dados.
• GS - Segmento com ainda mais dados.
• SS - Segmento da Pilha (Stack).

trabalho de Pesquisa Estrutura de uma programa Assembly

Modelos de memória:

• SMALL: código e dados são menores que 64kb, mas estão em segmentos diferentes.
• MEDIUM: código é maior que 64kb mas os dados são menores.
• COMPACT: código é menor que 64kb e os dados são maiores.
• LARGE: códigos e dados são maiores que 64kb, mas arrays não são.
• HUGE: tudo pode ser maior que 64kb.

Segmentos de Dados

O registrador Segmento de Dados é utilizado para apontar para um segmento de memória que estiver sendo utilizada no armazenamento de dados do programa em execução.

Segmento de Pilha

O registrador Segmento de Pilha é utilizado para identificar o segmento que será utilizado como pilha (stack), com o objetivo de armazenar os dados temporários do programa em execução.

Segmento de Código

O registrador Segmento de Código é utilizado para apontar para uma área de memória que contém o código de programa que está em execução.

Operações aritméticas

ADD destino, fonte

SUB destino, fonte

Usadas para adicionar (ou subtrair) dados entre:

• registo e registo
• registo e posição de memória
• adicionar (ou subtrair) um número diretamente a (de) um registo ou posição de memória.

Combinações válidas de operandos:

Exemplos de instruções válidas:

ADD AX,BX                  ;soma o conteúdo de BX com AX, resultado em AX

ADD AX,WORD1         ;soma o conteúdo da posição de memória word1, 

                                       ;ao registo AX, resultado em AX.

SUB WORD2, AX         ;subtrai o conteúdo do registo AX ao conteúdo da posição de memória WORD2, resultando em WORD2.

SUB BL,5                       ;subtrai 5 decimal ao conteúdo de BL

Graficamente: suponha a instrução ADD AX, DX

INC destino

DEC destino

Usadas para adicionar 1 (incrementar) ou subtrair 1 (decrementar) ao/do conteúdo de:

• Um registo
• Uma posição de memória

Exemplos

• INC CX ;incrementa o conteúdo de CX
• INC WORD1 ;incrementa o conteúdo da posição de memória WORD1
• DEC BYTE2 ;decrementa o conteúdo da posição de memória BYTE2
• DEC CL ;decrementa o conteúdo de CL (Byte baixo de CX)

Graficamente: Suponha a instrução INC BYTE1

NEG destino

Usada para subtrair o conteúdo destino pelo seu valor negativo, operando sobre:

• Um registo
• Uma posição de memória

Exemplos:

• NEG BX ;gera o valor negativo do conteúdo de BX.
• NEG WORD1 ;idem, no conteúdo da posição de memória WORD1.

Graficamente: Suponha a instrução NEG BX

MUL fonte

MUL (multiply) - Usada com números em representação não sinalizada

Multiplicação com números em formato byte:

• registos de 8 bits e vairáveis de tipo DB.
• segundo operando é assumido em AL
• resultado (destino) pode ser 16 bits e encontra-se em AX.

Multiplicação com números em formato word:

• registos de 16 bits e variáveis do tipo DW
• segundo operando é assumido em AX
• resultado pode ser 32 bits (tamanho doubleword) e encontra-se em:

DX - 16 bits mais significativos (high word).

AX - 16 bits menos significativos (low word).

Exemplos de casos de multiplicação:

1. Suponha que AL contenha 80h e BL contenha FFh:

Antes:    AL = 80h = 10000000b = 128

             BL = FFh = 11111111b = 255

2. Suponha que AX contenha 0001h e BX contenha FFFFh:

antes:   AX = 0001h = 0000000000000001b = 1

            BX = FFFh = 1111111111111111n = 65535

DIV fonte

• DIV (divide) - Usada com números em representação não-sinalizada.
• Fonte deve ser considerada como divisor (não pode ser uma constante).

Divisão com números em formato byte:

• O divisor é de 8 bits (1 byte)
• O dividendo é assumido em AX (16 bits)
• Após a execução: O quociente de 8 bits estará em AL, o resto de 8 bits estará em AH.

Divisão com números em formato word:

• O divisor é de 16 bits (1 word)
• O dividendo é de 32 bits:
• DX → 16 bits mais significativos do dividendo (high word).
• AX → 16 bits menos significativos do dividendo (low word).

Após a execução: -o quociente de 16 bits estará em AX.

                            -o resto dos bits estará em DX.

Exemplos de casos de divisão

1. Suponha que DX e AX contenham 0000h e 0005h, e BX contenha FFFEh;

Antes:

          DX: AX = 00000005h = 5

          BX = 0000FFFEh = 65534

2. Suponha que AX contenha 0005h e BL contenha FFh:

antes:  

AX = 005h = 5

BL = 00FFh = 256

3. Suponha que AX contenha 00FBh e BL contenha FFh

antes: 

           AX = 00FBh = 251

           BL = 00FFh = 256

Programa em Assembly (trabalho em bloco de notas).

.model small

.stack 200h  ;definir o tamanho da pilha

.data

firststring db "Digite a letra F:     ;primeiro conjunto de caracteres

secondstring db "Muito bem voce digitou a letra Fquot; ;segundo conjunto de caracteres

thirdstring db "Era para voce digitar a letra F seu ignorantequot; ;terceiro conjunto de caracteres

.code ;início do código

Inicio:

mov ax, @data ;mover data para AX

mov ds, ax

mov ah,9h ;funcão para imprimir caracteres no ecrã

mov dx, offset

int 21h

mov ah,0

int 16h

push ax ;insere ax na pilha

mov DL, AL ;não sensível a maiúsculas/minúsculas

mov AH,2h

int 21h

pop ax ;elimina ax

CMP AL, "f ;semelhante a uma instrução if (comparar)

JNE DigitoErrado ;saltar para outra parte do código

mov ax, seg secondstring

mov ds, ax

mov dx, offset secondstring

mov ah, 9h

int 21h

DigitoErrado: ;salta para aqui se AL <> ''f''

mov dx, offset thirdstring

mov ah,9h

int 21h

mov ax, 4c00h ;função para sair do programa

int 21h

end Inicio

Comandos no DOS:

tasm test1 ;compila o ficheiro objeto

tlink test1 ;cria o ficheiro executável

Formato de dados, variáveis e constantes

Números

• Exemplos:
• Binário: 111011b ou 111011B
• Decimal: 64223 ou 64223d ou 64223D
• 111011 é considerado decimal (ausência do B) 2184D (número negativo)
• Hexadecimal: 64223h ou 64223H
• 0FFFF começa com um decimal e acaba com h 1B4Dh

Números inválidos:

• Exemplos
• 1,234 carácter inválido (vírgula)
• FFFFh não começa por um número de 0 a 9; difícil distinguir do nome de uma variável
• 1B4D não termina em h ou H.

Caracteres ASCII:

Caracteres isolados ou strings de caracteres devem estar escritos dentro de aspas simples (‘) ou duplas (“).

• Exemplos: 
• “A” ou ‘A’
•  ‘ola’

Variáveis

• Variável é um nome simbólico para um dado atualizável pelo programa.
• Cada variável possui um tipo e recebe um endereço de memória;
• Usam-se pseudo-instruções para definir o tipo da variável;
• O assembly atribui o endereço de memória.

• Definição de variáveis do tipo byte:
• Nome DB valor_inicial

                   Exemplos:

                                  Alfa DB 0 ;equivale a 0

                                  BIT DB ? ;não inicializada

• Definição de variáveis do tipo word:
• Nome DW valor_inicial

           Exemplos:

                         WORD1 DW 0h ;equivale a 0h

                         CONTA DW 0150h ;equivale a 150h

                         C DW ? ;não inicializada

• Array: sequência de bytes ou words consecutivos na memória
• armazenar dados relacionados.
• armazenar carateres ASCII organizados (texto).

         Exemplos:

                       BYTE_ARRAY DB 10h, 20h, 30h

                       WORD_ARRAY DW 1000h, 223h, 0h, 0FFFFh

                       LETRAS DB ‘abC’ ; é equivalente aos carateres ASCII

Formato de uma declaração (linha de programa):

Formato de uma declaração (linha de programa):

[nome] [cod. oper] [operando(s)] [comentário]

Exemplo:

INICIO:                   MOV   CX, 5h                            ;inicializar contador

A separação entre os campos deve ser do tipo <espaço> ou <tab>.

• O campo nome.
• Pode ser um rótulo de instrução, um nome-de-rotina, um nome de variável, contendo de 1 a 31 carateres, iniciando por uma letra e contendo apenas letras, números e os caracteres ?.@_:$%.
• Campo de código de operação.
• Contém o código de operação.
• Campo de operandos:
•  instruções podem conter 0, 1 ou 2 operandos no 8086.
• Exemplos:
• NOP ;sem operandos: não faz nada.
• INC AX ;um operando: soma 1 ao conteúdo de AX
• ADD A,2d ;dois operandos: soma 2 ao conteúdo da palavra de memória A.

No caso de instruções de dois operandos:

• O primeiro, operado destino: registo ou posição de memória onde o resultado é armazenado. O conteúdo incial é modificado;
• O segundo, operando fonte: não é modificado pela instrução.
• Os operandos são separados por uma vírgula.

• Campo de comentário:
• Um ponto-e-vírgula (;) marca o início desse campo;
• O assembly ignora tudo após esse marcador;
• Comentários são opcionais;
• Exemplos:
• MOV CX, 0                               ;movimenta 0 para CX
   (inicialização dos registos)                (linha inteira de comentários)

Programação de microprocessadores - Intel 8086

Introdução à linguagem Assembly do 8086

A sintaxe assembly de 8086.

A linguagem assembly não é sensível a maiúsculas/minúsculas.

Para facilitar a compreensão do texto do programa, segue-se:

• Uso de letra maiúscula para código.
• Uso de letra minúscula para comentários.

Declarações (statements):

• Instruções, que são convertidas em código de máquina.
• Directivas, que instruem o assembler a realizar alguma tarefa específica:
• Alocar espaço de memória para variáveis.
• Criar uma sub-rotina (procedure ou procedimento).
•