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).
• 
  

Os registos do 8086 (Visão Geral)

• O registo IP corresponde ao contador de Programa - PC
• Todos os registos são de 16 bits.
• AH → byte alto de AX; 8 bits; AL → byte baixo de AX; 8 bits.

Flag de Controle

• TF → Flag de trap (armadilha).
• TF=1  → Apos a execução do próxima instrução ocorra  uma interrupção; a própria interrupção faz TF=0.
• TF=0  → Caso contrario.

• IF → Flag de interrupção.
• IF=1 → Habilita a ocorrência de interrupções.
• IF=0  → Inibe interrupções

• DF → Flag de direção: Usado para indicar a direção em que as operacaoes com strings são realizadas.
• DF=1 → Decremento do endereço de memoria (Down).
• DF=0 → Incremento do endereço de memoria(Up).

Flags de estado:

 Flags de estado:

• CF - Flag de Carry 
• CF = 1 → após instruções de soma que geram “vai um” ou após instruções de subtração que não geram “empréstimo” (“empresta um”). 
• CF = 0 → caso contrário. 
• PF - Flag de Paridade 
• PF = 1 → caso o byte inferior do resultado de alguma operação aritmética ou lógica apresentar um número par de “1’s”; 
• PF = 0 → caso contrário (número ímpar). 
• AF - Flag de Carry Auxiliar: utilizado em instruções com números BCD 
• AF = 1 → caso exista o “vai um” do bit 3 para o bit 4 de uma adição ou caso não não exista “empréstimo” do bit 4 para o bit 3 numa subtração. 
• AF = 0 → caso contrário. 
• ZF - Flag de Zero 
• ZF = 1 → caso o resultado da última operação aritmética ou lógica seja igual a zero; 
• ZF = 0 → caso contrário. 
• SF - Flag de sinal: utilizado para indicar se o número resultado é positivo ou negativo em termos aritméticos (se não ocorrer erro de transbordo - overflow) 
• SF = 1 → número negativo. 
• SF = 0 → número positivo. 
• OF - Flag de Overflow (erro de transbordo). 
• OF = 1 → qualquer operação que produza overflow. 
• OF = 1 → caso contrário. 
• IF - Flag de Interrupção 
• IF = 1 → habilita a ocorrência de interrupções. 
• IF = 0 → inibe interrupções. 
• DF - Flag de Direção: usado para indicar a direção em que as operações com strings são realizadas. 
• DF = 1 → decremento do endereço de memória (DOWN) 
• DF = 0 → incremento do endereço de memória (UP).

Registos de sinalizadores (Flags):

Registos de sinalizadores (Flags):

• Indica o estado do microprocessador durante a execução de cada instrução; 
• Conjunto de bits individuais, cada qual indicando alguma propriedade; 
• Subdividem-se em Flags de estado (status) e Flags de controle- 
• Organização 

1 registo de 16 bits. 

6 flags de estado. 

3 flags de controle. 

7 bits não utilizados (sem função)

Linguagem Assembly

• A linguagem Assembly tem um conjunto de instruções muito primitivo; 
• Torna-se impossível entender os algoritmos, a menos que se façam comentários; 

Vantagens da Linguagem Assembly: 

• Alta eficiência: produz programas em linguagem de máquina que podem ser mais rápidos e menores que os obtidos por outras linguagens. 
• Algumas operações são facilitadas, como escrever em posições de memória específicas e portas de E/S, sendo praticamente impossível em linguagens de alto nível. 

Vantagens das linguagens de alto nível: 

• Próximos às linguagens naturais (facilidade de conversão de algorítmos); 
• Menor tempo de codificação e menor quantidade de linhas de programa; 
• Um programa em linguagem de alto nível roda em qualquer computador, desde que haja um compilador ou interpretador adequado (portabilidade). 

As Linguagens de Alto Nível nasceram para expandir as possibilidades de programação, numa forma textual mais próxima da humana.

Necessitam de tradução para linguagem de máquina, por meio de compiladores (mais comum) ou interpretadores.

Memória

Memória: Local do computador (hardware) onde se armazenam temporária ou definitivamente dados.

Posição de memória ou endereço: Local físico da memória onde se localiza o dado.

Organização da memoria:

Organização de um computador digital:

Um computador digital pode ser descrito de uma forma simplificada segundo o seguinte diagrama:

• Unidade central de Processamento (UCP/CPU)
• Unidade de controle
• Unidade Lógica e Aritmética (UAL/ULA)
• Registos de uso geral
• Registos específicos:
• Registos de dados de memória (RDM)
• Registos de endereços de memória (REM)
• Contador de programa (Program Counter/PC)
• Registo de instruções (RI)
• Apontador de pilha (stack pointer (SP)

Posição de Bits:

Obs

Words são armazenados em  bytes consecutivos em memoria de 8 bits.

Byte  Baixo= byte inferior ou byte de menor ordem - endereço N

Byte alto= byte superior ou byte de maior ordem - endereço N+1

Trabalho de pesquisa nº1 Assembly

A estrutura de um programa em Assemblay.

•  Linguagem de baixo-nível;
• Os programas em asemblay não são executáveis; 
• Permite escrever programas que são mais rapidamente executados que programas escritos em linguagem e alto-nível;
• Os programas escritos em  assembly são mais pequenos e logo mais rápidos;
• Utiliza linguagem de maquina com palavras abreviadas indicando a operação  a ser realizada pelo processador. 

modelos de memoria:

•  Permite ao CPU determinar como esta estruturado o programa.
• SMALL- o código e os dados estão em segmentos diferentes.
• MEDIUM - o código pode ser maior que 64K, mas os seus dados têm que ter menos que 64K.
• COMPACT - o código é menos de 64K, mas os dados podem ter mais que 64K.
• LARGE - o código e os dados podem ter mais que 64K, embora os arrays não possam ser maiores que 64K.
•  HUGE - o código os dados e os arrays podem ter mais de 64K.

Segmento de Dados DS - é 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 ou SS - O registador 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 ou CS -  O registador 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.