Resumo assembly x86 16 bits

ASSEMBLY X86
DISCIPLINA DE ARQUITETURA DE
COMPUTADORES
CURSOS DE BACHARELADO EM ENGENHARIA DE
COMPUTAÇÃO E CIÊNCIA DA COMPUTAÇÃO
Prof.ª M.ª Eng.ª Elaine Cecília Gatto
Bauru-SP
2015

Arquitetura de Computadores
Engenharia de Computação / Ciência da Computação
Resumo Conjunto de Instruções e Assembly X86
_______________________________________________
Page 2 of 22
SUMÁRIO
1. INTRODUÇÃO............................................................................................................................................................4
2. OPERAÇÕES PRIMITIVAS MAIS COMUNS.................................................................................................................4
3. PROJETO DO CONJUNTO DE INSTRUÇÕES ...............................................................................................................4
3.1 Código da Operação ...........................................................................................................................................5
Tamanho fixo:.......................................................................................................................................................5
Tamanho variável: ................................................................................................................................................5
3.2 Operando............................................................................................................................................................6
4. FORMATOS DE INSTRUÇÕES.....................................................................................................................................6
4.1 Instruções com quatro operandos .....................................................................................................................6
4.2. Instruções Com Três Operandos .......................................................................................................................6
4.3. Instruções Com Dois Operandos .......................................................................................................................7
4.4. Instruções Com Um Operandos.........................................................................................................................7
4.5. EXEMPLO ...........................................................................................................................................................7
5. MODOS DE ENDEREÇAMENTO...............................................................................................................................10
5.1 Imediato............................................................................................................................................................10
5.1 Direto................................................................................................................................................................11
5.2 Indireto .............................................................................................................................................................11
5.3 Por Registrador.................................................................................................................................................11
5.4 Indexado ...........................................................................................................................................................11
6. ASSEMBLY X86 16 bits ............................................................................................................................................12
6.1 Organização de Dados......................................................................................................................................12
6.2 Registradores....................................................................................................................................................13
Registradores Gerais...........................................................................................................................................13
Registradores de Segmento................................................................................................................................14
Registradores de Deslocamento.........................................................................................................................14
6.3 Interrupções .....................................................................................................................................................15
Interrupção por Hardware..................................................................................................................................15
Interrupção por Exceção.....................................................................................................................................15
Interrupção por Software...................................................................................................................................16
6.4 Linguagem Assembly ........................................................................................................................................16
6.5 DEBUG...............................................................................................................................................................17
Comandos básicos ..............................................................................................................................................17

_______________________________________________
Page 3 of 22
Operações...........................................................................................................................................................17
Exemplo ..............................................................................................................................................................18
Solução ...............................................................................................................................................................18
Referências .................................................................................................................................................................22

_______________________________________________
Page 4 of 22
1. INTRODUÇÃO
O hardware funciona através de ordens simples e básicas. O hardware não é capaz de manipular diretamente ordens
mais complexas. Instrução de máquina: ordens que são transmitidas ao hardware para serem interpretadas e executadas por um
conjunto de bits. Especifica para o hardware que determinada operação deve ser realizada. Set Instruction ou Conjunto de
Instruções: grupo de instruções de máquina. Define o que um processador é capaz de realizar, permitindo ao programador do
compilador escrever o código de acordo. Quais operações o processador poderá realizar? Como cada operação será realizada?
ISA: instruction set architecture ou arquitetura do conjunto de instruções. É a interface entre o hardware e o software
(e os compiladores). Computadores de uso geral: possui um conjunto básico de instruções primitivas. Um programador pode
combinar essas instruções de diferentes modos, obtendo diferentes resultados. O computador, como conhecemos hoje, é capaz
de executar diversos tipos diferentes de programas. Exemplo: Notepad e AutoCAD. A “inteligência” e a versatilidade do
sistema computacional estão na combinação das instruções primitivas visto que o hardware é imutável. Computadores devem
ser capazes de executar programas em diversas linguagens.
Quando uma máquina nova é desenvolvida, surgem as seguintes perguntas: A nova máquina é compatível com a
antecessora? A nova máquina pode executar meu sistema operacional? A nova máquina executará todos os meus programas de
aplicação existentes sem modificação? Ninguém quer jogar fora seus programas antigos e começar do zero novamente! Isto faz
parte do projeto do ISA. DESAFIO: construir máquinas melhores sujeitas às limitações da compatibilidade.
2. OPERAÇÕES PRIMITIVAS MAIS COMUNS
 Transferencia de uma palavra de dados de uma célula para outra;
 Somar dois operandos, guardando o resultado em um deles ou em um terceiro operando;
 Desviar para outro endereço fora da sequencia;
 Testar uma condição. Se o teste resultar em verdadeiro, desvia para outro endereço;
 Realizar operação lógica AND entre dois valores;
 Parar a execução de um programa;
 Adicionar 1 a um valor de operando;
 Transferencia de byte da porta de E/S para a MP e vice-versa;
 Substituição do operando por seu valor absoluto.
3. PROJETO DO CONJUNTO DE INSTRUÇÕES
Quais são os elemetos requeridos para a execução de uma operação? Qual o formato binário da instrução de máquina?
Quais tipos de dados serão manipulados? No projeto então é definido: Quais operações o processador realizará? Como as

_______________________________________________
Page 5 of 22
operações são identificadas? Como as operações são executadas: necessário especificar a sequencia de microoperações que de
fato realizarão a tarefa? Formato básico de uma instrução:
Código da operação Operandos
3.1 Código da Operação
Indica ao processador o que fazer e como fazer – Operation Code ou OpCode. Este código é único para cada
operação. Indica qual é a operação a ser executada. É o nome da instrução propriamente dita. Sinaliza para a unidade de
controle o procedimento a ser seguido para execuação da operação. É a instrução em si. Linguagem simbólica de máquina =
linguagem assembly = representação dos bits da instrução.
A quantidade de bits por campo é definida pelo projetista. A quantidade no C.OP. define o limite máximo de
instruções que o processador poderá executar: Se OpCode com 7 bits, então, 27 = 128 instruções; Se OpCode com 8 bits,
então, 28 = 256 instruções. A quantidade de bits no OpCode pode ser definido de duas formas pelo projetista: Tamanho fixo ou
Tamanho variável.
Tamanho fixo:
Quantidade definida de bits. Típico de arquiteturas RISC. Se sabe, exatamente, quantas instruções o processador pode
executar. Mais simples de implementar e manipular durante a execução. Conforme a tecnologia avança, são necessárias mais
instruções e o tamanho de OpCode cresce com isso, pois precisa acomodar todos os códigos necessários, o que afeta
diretamente a memória principal (mais endereçamento é necessário). A memória principal é um dos componentesmais caros de
um computador, o ideal é que seu espaço não seja desperdiçado mas sim usado com eficiência. Exemplos: Intel 8080 e 8085 –
8 bits de OpCode.
Tamanho variável:
Quantidade indefinida de bits, podendo variar conforme a operação a ser realizada. Típico de arquiteturas CISC.
Codifica uma quantidade maior de instruções com menor quantidade de bits. Permite campos de operandos com tamanhos
diferentes. Mais instruções com quantidades diferentes de operandos. Permite aumentar o tamanho total da instrução, o que
também acarreta problemas com a memória principal. Exemplos: Intel 8086, 8088 e 80286 – 1 byte de OpCode; Intel 386, 486
e Pentium – varia entre 1 e 2 bytes de OpCode
A decisão sobre a quantidade de bits a ser adotada no OpCode afeta o projeto como um todo. Se o projeto tem muitas
instruções: Maior flexibilidade; Compilação mais rápida; Instruções de máquina mais complexas são mais completas, o que
acarreta um código de programa compilado mais simples de ser traduzido de uma linguagem de alto nível para baixo nível;
Hardware do processador é mais complexo, portanto, aumenta o custo de fabricação, visto que mais circuitos integrados serão
necessários; O decodificador de instruções também sérá mais complexo e levará mais tempo para decodificar as instruções, o
que afeta o desempenho do sistema como um todo;

_______________________________________________
Page 6 of 22
3.2 Operando
Indica ao processador qual dado ou dados a operação se realizará, ou seja, o endereço do dado. Pode haver instruções
com mais de um campo operando e este campo também pode indicar o próprio valor do dado.
É o dado que se deseja manipular; Pode estar armazenado em uma posição da memória ou registrador ou ainda
explicito no campo; O endereço do local onde está armazenado o dado se encontra neste campo; Modo de endereçamento: é a
diversidade de apresentação do dado na instrução – formas diferentes do dado aparecer na instrução; Dois aspectos importantes
sobre os operandos: Quantidade de operandos; Modo de endereçamento;
Ambos os campos são formados por uma quantidade de bits. Formato de instruções, largura dos campos e conteúdo
variam de acordo com a arquitetura.
4. FORMATOS DE INSTRUÇÕES
4.1 Instruções com quatro operandos
Opcode Operando 1 Operando 2 Operando 3 Endereço Da Próxima
Instrução
Código da operação Registrador Destino
(registrador que
armazenará o
resultado da operação)
Registrador Fonte Registrador Fonte IP – próxima instrução
Exemplo: ADD X, Y, Z, P ; X = Y + Z
Vantagem: Esse formato de instrução é completa pois possui todos os operandos necessários de uma operação
aritmética;
Desvantagem: Precisa de mais espaço na memória principal e desperdiça espaço em outros tipos de operações; (nem
todas as operações precisam de quatro operandos!)
Atualmente nenhuma máquina utiliza instruções com 4 operandos. A próxima instrução a ser executada sempre estará
armazenada no PC – Contador de Programa/Programm Counter ou IP – Instruction Pointer/Ponteiro de Instrução. São
necessários 5 acessos a memória: 1 para buscar a instrução e mais 4 para cada operando.
4.2. Instruções Com Três Operandos
Opcode Operando 1 Operando 2 Operando 3
Código da operação Registrador Destino Registrador Fonte Registrador Fonte
Exemplo: ADD X, Y, Z ; X = Y + Z
São necessários 4 acessos a memória: 1 para buscar a instrução e mais 3 para cada operando.

_______________________________________________
Page 7 of 22
4.3. Instruções Com Dois Operandos
Opcode Operando 1 Operando 2
Código da operação Registrador Destino Registrador Fonte
Exemplo: ADD X, Y ; X = X + Y
4.4. Instruções Com Um Operandos
Opcode Operando 1
Código da operação Registrador Destino e Fonte
Exemplo: ADD X ; ACC = ACC + X
ACC – Registrador Acumulador. Ele é um operando implícito. Armazena o valor de um dos dados. Armazena o
resultado da operação. Duas instruções fazem a transferencia de dados entre a memória principal e o registrador ACC:
LDA X ;ACC = X
STA X ;Op = X
LDA = instrução de carga. Carrega um valor de um registrador. STA: instrução de armazenamento. Armazea um
valor em um registrador. Em instruções de um operando é necessário sempre carregar e armazenar valores para não perde-los.
4.5. EXEMPLO
Dado o código em linguagem de alto nível X = A * ( B + C * D – E / F ), converta-o em instruções de:
a) quatro operandos;
b) três operando;
c) dois operandos;
d) um operandos.
Suponha que cada campo, de cada formato de instrução, suporte 5 bits. Responda às perguntas abaixo.
1) Quantas linhas de código são geradas para cada formato de instrução? Qual formato possui menos linhas e, qual
formato possui mais linhas?
2) Quantos acessos à memória são necessários para cada formato de instrução? Qual formato possui menos acessos e,
qual formato possui mais?
3) Quantas instruções de adição, subtração, multiplicação, divisão e de transferência de dados existem em cada código
gerado?

_______________________________________________
Page 8 of 22
4) Qual a quantidade de bits total de cada formato de instrução? Qual formato tem menos bits e, qual formato tem
mais bits?
5) Qual a quantidade de bits total para cada código gerado? Qual formato tem menos bits e, qual formato tem mais
bits?
6) Qual a quantidade total de acessos à memória para cada código gerado? Qual formato tem menos acessos e, qual
formato tem mais acessos?
7) De acordo com os cálculos realizados nas questões anteriores, uma instrução com um operando é mais vantajosa
que uma instrução de três operandos? Explique.
SOLUÇÃO
Primeiro você deve se perguntar qual operação tem prioridade de resolução. Lembram-se das prioridades de
operadores? Precisam também resolver a expressão de dois em dois operandos. Lembrem-se, o processador só manipula
operações com dois operandos, mesmo que o formato da instrução tenha mais de dois operandos. Devemos nos lembrar aqui
da matemática básica:
X = A * ( B + C * D – E / F ) 1.º Fazemos a multiplicação C * D
X = A * ( B + T1 – E / F ) O resultado da multiplicação fica armazenado em uma variável temporária T1
X = A * ( B + T1 – E / F ) 2.º Fazemos da divisão E / F
X = A * ( B + T1 – T2 ) O resultado da divisão fica armazenado em uma variável temporária T2
X = A * ( B + T1 – T2 ) 3.º Fazemos a soma B + T1
X = A * ( T3 – T2 ) O resultado da soma fica armazenado em uma variável temporária T3
X = A * ( T3 – T2 ) 4.º Fazemos a subtração T3 – T2
X = A * ( T4 ) O resultado da subtração fica armazenado em uma variável temporária T4
X = A * ( T4 ) 5.º Fazemos a multiplicação A * T4
X = X O resultado da multiplicação precisa ser armazenado em X
a) MPY T1, C, D, P
DIV T2, E, F, P
ADD T3, B, T1, P
SUB T4, T3, T2, P
MPY X, A, T4, P
b) MPY T1, C, D ; T1 = C * D
DIV T2, E, F ; T2 = E / F
ADD T3, B, T1 ; T3 = B * T1
SUB T4, T3, T2 ; T4 = T3 * T2
MPY X, A, T4 ; X = A * T4

_______________________________________________
Page 9 of 22
c) MOV X, C ; X = C
MPY X, D ; X = X * D
MOV T1, E ; T1 = E
DIV T1, E ; T1 = T1 / E
ADD X, B ; X = X + B
SUB X, T1 ; X= X – T1
MPY X, A ; X = X * A
d) LDA C ; ACC = C
MPY D ; ACC = ACC * D
STA X ; X = ACC
LDA E ; ACC = E
DIV F ; ACC = ACC / F
STA T1 ; T1 = ACC
LDA B ; ACC = B
ADD X ; ACC = ACC + X
SUB T1 ; ACC = ACC – T1
MPY A ; ACC = ACC * A
STA A ; A = ACC
1) Para o formato de instrução de quatro operandos existem 5 linhas de código assembly. Para o formato de instrução de três
operandos existem 5 linhas de código assembly. Para o formato de instrução de dois operandos existem 7 linhas de código
assembly. Para o formato de instrução de um operando existe 11 linhas de código assembly.
2) Para o formato de instrução de quatro operandos são necessários 5 acessos a memória: 1 para buscar a instrução e mais 4
para cada operando. Este é o formato que tem o maior número de acessos à memória. Para o formato de instrução de três
operandos são necessários 4 acessos a memória: 1 para buscar a instrução e mais 3 para cada operando. Para o formato de
instrução de dois operandos são necessários 3 acessos a memória: 1 para buscar a instrução e mais 2 para cada operando. Para
o formato de instrução de um operando são necessários 2 acessos a memória: 1 para buscar a instrução e mais 1 para cada
operando. Este é o formato que possui menos acessos à memória.
3) Quantas instruções de adição, subtração, multiplicação, divisão e de transferência de dados existem em cada código gerado?
Adição Subtração Multiplicação Divisão Transferência
Quatro operandos 1 1 2 1 0
Três operandos 1 1 2 1 0
Dois operandos 1 1 2 1 2
Um operando 1 1 2 1 6

_______________________________________________
Page 10 of 22
4) Considerando que cada campo possui 5 bits, cada formato de instrução terá:
5 bits 5 bits 5 bits 5 bits 5 bits Total
Quatro Operandos OpCode Op1 Op2 Op3 P.I. 5 campos * 5 bits = 25 bits (maior)
Três Operandos OpCode Op1 Op2 Op3 - 4 campos * 5 bits = 20 bits
Dois Operandos OpCode Op1 Op2 - - 3 campos * 5 bits = 20 bits
Um Operando OpCode Op1 - - - 2 campos * 5 bits = 10 bits (menor)
5) Para encontrarmos a resposta precisamos multiplicar a quantidade de linhas do código assembly pela quantidade de bits de
cada formato, como a seguir:
Operandos Quantidade de Linhas Quantidade de Bits por Linha Total
Quatro 5 25 5 * 25 = 125 bits
Três 5 20 5 * 20 = 100 bits (menor)
Dois 7 20 7 * 20 = 140 bits (maior)
Um 11 10 11 * 10 = 110 bits
6) Para encontrarmos a resposta precisamos multiplicar a quantidade de linhas do código assembly pela quantidade de acessos
de cada formato, como a seguir:
Operandos Quantidade de Linhas Quantidade de Acessos Total
Quatro 5 5 5 * 5 = 25 acessos (maior)
Três 5 4 5 * 4 = 20 acessos (menor)
Dois 7 3 7 * 3 = 21 acessos
Um 11 2 11 * 2 = 22 acessos
Aqui não há muitas diferenças na quantidade de acessos para cada código gerado. Em um programa maior,
provavelmente essas diferenças influenciarão de forma significativa no desempenho da máquina.
5. MODOS DE ENDEREÇAMENTO
5.1 Imediato
Método simples e rápido. Indica o valor do dado no próprio campo operando. Não busca o dado do campo operando
na memória. Curto tempo de execução da instrução. O dado é transferido da memória junto com a instrução. Utilizado em:
Inicialização de contadores (valor fixo); Operação com constantes (valor fixo) matemáticas; Armazenamento de ponteiros;
Deslocamento de bits. Intel Pentium e AMD Athlon usam algumas instruções de modo imediato: desvio, movimentação,
operações aritméticas com constantes, entre outras. Exemplos:
MOV R, Op

_______________________________________________
Page 11 of 22
MOV AL, 22H ;Copia o valor hexadecimal 22 para o registrador AL – 1 byte de tamanho;
MOV EBX, 33445566H ;Copia o valor hexadecimal 33445566 para o registrador EBX – 32 bits;
5.1 Direto
O campo operando indica o endereço de memória onde está o dado. Requer apenas uma referência à memória
principal para buscar o dado. O dado deve ser transferido do dispositivo de entrada para a memória principal. Variável de
programa: quando um dado varia de valor a cada execução do programa. Representa simbolicamente o endereço do dado.
Exemplo: MOV AX, B4
5.2 Indireto
O campo operando representa o endereço de uma célula de memória. O conteúdo da célula de memória NÃO É um
dado, mas sim OUTRO endereço de memória. Usa mais ciclos de memória para buscar o dado. PONTEIRO: é o endereço
intermediário, indica ou aponta para a localização do dado.
Exemplo: MOV AX, 3B
5.3 Por Registrador
Usa-se registradores no lugar da memória principal. Execução rápida pois o dado encontra-se no registrador.
Exemplo: Escrever, em linguagem assembly, no modo de endereçamento direto, as instruções do seguinte trecho de programa
em linguagem de médio nível.
Dois modos de endereçamento por registrador: DIRETO (contém o dado a ser manipulado) e INDIRETO (contém o
endereço de uma célula de memória onde o dado se encontra).
VANTAGENS: Execução rápida. Economia de espaço. Só é vantajoso se o modo proporcionar redução de ciclos de
memória. As vantagens nem sempre são aplicáveis e por isso podem se tornar desvantagens.
DESVANTAGEM: Em arquiteturas CISC: Dificuldade em definir quais dados serão armazenados no registrador e
quais na memória principal: quem faz isso é o compilador e ocorre devido aos poucos registradores existentes e aos muitos
dados que devem ser manipulados. Exemplos: ADD registrador, registrador; ADD registrador, memória; ADD registrador,
registrador, registrador.
5.4 Indexado
Manipulação de endereços de acesso a elementos de tipos especiais de dados. Os endereços são ponteiros para os
elementos. Exemplo: vetores e outras estruturas de dados. Indexado: obtém-se o endereço do dado de um elemento por meio de
seu índice. Endereço = campo operando + valor contido no registrador de índice.

_______________________________________________
Page 12 of 22
6. ASSEMBLY X86 16 bits
É linguagem de montagem. É utilizada para programar um computador de baixo nível. O programa é montado dentro
do processador. Não é uma linguagem de máquina. Linguagem de máquina: Utilizada por um MICROPROCESSADOR para
controlar funções de um computador digital. MICROPROCESSADOR: É um circuito que possui a capacidade de executar
diversos tipos de funções distintas. É usado em um computador.
Linguagem de máquina: Só aceita e manipula informações numéricas expressas em notação de códigos binários.
Assembly: Linguagem de programação que surgiu entre a década de 40 e 50. Objetivo: facilitar o trabalho de codificação de
um programa de computador. É composta por códigos alfabéticos muito mais fáceis de se utilizar que códigos binários ou
hexadecimais.
Mnemônicos: São as instruções da linguagem Assembly. ASSEMBLER: É o nome dado ao programa montador. É o
programa utilizado para compilar um programa escrito em linguagem de montagem, tornando-o executável. É o ambiente de
programação. É responsável por traduzir o programa-fonte para o programa-objeto. PORTANTO: assembler é diferente de
assembly!
Compiladores disponíveis para a linguagem Assembly: MASM (microsoft), MASM (ibm), TASM (borland),
EMU8086 (http://www.emu8086.com/)
Saber programar em linguagem Assembly significa conhecer e saber usar melhor os requisitos mais íntimos de um
microprocessador, e por conseguinte, saber controlar melhor as funções de um computador digital. É usada na criação e
desenvolvimento de rotinas escritas nas formas de DLLs, drivers, programas embutidos (computadores de bordo), etc.
Algumas linguagens de alto nível possuem algum tipo de interação com rotinas de programas escritos em Assembly. Códigos
Assembly são rápidos e pequenos (compilado) mas o código-fonte é extenso.
Assembly é totalmente dependente de hardware. Um código Assembly para INTEL não é o mesmo que um para a
AMD. Portanto, não é portável. EMU8086: Ambiente de programação. Programa de simulação do modo de operação interna
de um microprocessador padrão 8086. Modo gráfico.
6.1 Organização de Dados
Nibble: É um conjunto numérico de 4 bits. Representa-se até 16 valores diferentes. É a menor estrutura numérica manipulada
internamente em um computador digital. Usa-se nibble para facilitar a representação de valores binários em formato
hexadecimal.
3 2 1 0
MSB LSB
Bytes: É um conjunto de oito bits. Representa-se numericamente até 256 valores diferentes. Um byte é formado pelo conjunto
de dois nibbles.
7 6 5 4 3 2 1 0
MSB LSB

_______________________________________________
Page 13 of 22
Word: Representa um conjunto de 16 bits. Representa-se numericamente até 65.356 valores diferentes (de 0 a 65.356). É
formado por dois bytes. É formado por quatro nibbles. Também pode ser representado valores numéricos entre -32.766 até
32.767. Representação de numeros inteiros. Representação de deslocamento de segmento.
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
MSB LSB
Double Word: É um conjunto de dois words. Um conjunto de 32 bits. Formada por um conjunto de quatro bytes ou oito
nibbles. Representa-se 4.294.967.296 valores numéricos diferentes. Representa-se também numeros entre -2.147.483.648 e
2.147.483.647. Utilizado para representar: Valores inteiros de 32 bits, Valores de ponto flutuante de 32 bits; Endereços
segmentados.
Quad Word: É um conjunto de dois double words. É um conjunto de 64 bits. É formado por dois double words, ou quatro
words, ou oito bytes ou ainda dezesseis nibbles. Representa-se 18.446.744.073.709.551.616 valores numéricos diferentes.
Representa-se -9.223.372.036.854.7756.808 à -9.223.372.036.854.7756.808. Usado em microprocessadores de 64 bits.
6.2 Registradores
Utilizados para armazenar os valores que serão manipulados por um programa. A arquitetura X86 da Intel é formada
por 14 registradores. Cada um manipula 16 bits. São divididos em quatro grupos funcionais:
Registradores gerais: AX, BX, CX, DX;
Registradores de segmento: CS, DS, ES, SS
Registradores de ponteiros: SI, DI, SP, BP, IP
Registradores de estado: F
Registradores Gerais
Cada registrador tem 16 bits de dados. Cada registrador pode ser dividido em 2 duas partes com 8 bits cada um.
 AX (accumulator extended, AH – AL): pode ser utilizado em: operações aritméticas, Acessos de portas de entrada e
saída; Chamadas de interrupções, Transferência de dados, Etc.
 BX (base extended, BH-BL): Pode ser utilizado como ponteiro para acessar a memória no sentido de obter algum
valor de retorno ou mesmo definir valores que serão usados para auxiliar operações aritméticas efetuadas com o
registrador ah.
 CX (counter extended, CH-CL): Usado para receber alguns valores de interrupções. Principal finalidade: servir como
contador de laços de repetição e operações de deslocamento registradas em CL.
 DX (data extended, DH-DL): Operações aritméticas. Acessos de portas de entrada e saída. Algumas chamadas de
interrupções.

_______________________________________________
Page 14 of 22
Registradores de Segmento
Tem 16 bits. Usados para acessar uma determinada área de memória (OFFSET). São utilizados para auxiliar o
microprocessador a encontrar o caminho pela memória do computador. Não podem ser divididos em grupos de 8 bits.
 CS (Code Segment): Usado para apontar para uma área de memória que contém o segmento de código de programa
que se encontra em execução. Obs.: a mudança do valor existente nesse registrador pode resultar em travamento do
computador
 DS (Data Segment): usado para apontar para a área de memória que estiver sendo utilizada no armazenamento dos
dados do programa em execução. A mudança no valor existente nesse registrador de segmento pode ocasionar a
obtenção de dados incorretos.
 ES (Extra Data Segment): Usado para determinar um segmento extra de endereço de dados distante da área em que se
está operando. Por exemplo: necessário quando é preciso acessar a memória do vídeo.
 SS (Stack Segment): Usado para identificar a área de memória que será usada como pilha, com o objetivo de
armazenar dados temporários para a execução de um determinado programa. Algumas vezes pode conter o mesmo
valor encontrado no registrador de segmento DS. A mudança do valor pode trazer resultados imprevisíveis
relacionados aos dados.
Registradores de Deslocamento
Registradores de apontamento. Registradores de deslocamento. Registradores de índice. Associados ao acesso de uma
determinada posição de memória previamente conhecida. Não podem ser divididos em grupos de 8 bits. Quatro registradores
são manipuláveis, apenas o IP não é.
 IP (instruction pointer): Apontador da próxima instrução. Possui o valor de deslocamento do código da próxima
instrução a ser executada. É de uso interno do microprocessador. Guarda o deslocamento da próxima instrução de um
programa. O valor só pode ser lido.
SI e DI: Utilizados para manipular índices de uma tabela.
 SI (Source Index): usado para a leitura dos dados de tipo string de uma tabela.
 DI (Destination Index): usado para a escrita de dados do tipo string em uma tabela. Usado na definição de
endereçamento distante associado ao registrador de segmento ES.
SP e BP: Permitem acesso à pilha de programa. Pilha de programa: memória para armazenamento de dados.
Possibilita armazenar dados em memória, sem utilizar registradores gerais. É um mecanismo que armazena dados de cima para
baixo.
 BP (Base Pointer): armazena o endereço da base da pilha.
 SP (Stack Pointer): armazena o endereço do topo da pilha.

_______________________________________________
Page 15 of 22
6.3 Interrupções
Interrupções tornam possível controlar vários dispositivos associados ao computador. O funcionamento da interrupção
ocorre pela comunicação entre dispositivos externos e o microprocessador. INT: instrução utilizada para interrupções. Faixa de
valores de INT: 00h – FFh (número hexadecimal). Total de 256 interrupções possíveis. Tabela de interrupções: Fica
armazenada nos primeiros 1024 bytes da memória (endereço físico de 0 a 1023). É um conjunto de vetores indexados aos
registradores CS e IP. Cada vetor ocupa 4 bytes (2 bytes para cada registrador).
ISR: Interrupt Service Routine – outro nome para a tabela de interrupções. Possui o endereço das funções de cada uma
das interrupções existentes. Três categorias: Interrupção por hardware, Interrupção por exceção, Interrupção por software.
Interrupção por Hardware
Possibilita acionar periféricos externos. Faixa de valores: 08h a 0Fh. IRQ: Interrupt request. Linha pela qual a
interrupção se conecta com o microprocessador. São controladas por rotinas do S.O. ou da ROM-BIOS. Máximo de
dispositivos externos: oito (se for um microprocessador intel 8086. processadores mais atuais manipulam mais dispositivos).
Este tipo de interrupção é gerenciada pelo próprio comptuador. Não é possível mudar seu estado de comportamento.
 08h: IRQ0. Opera o chip temporizador do sistema.
 09h: IRQ1. Opera o teclado.
 0Ah: IRQ2. Interrupção reservada.
 0Bh: IRQ3. Opera as portas de comunicação COM2.
 0Ch: IRQ4. Opera as portas de comunicação COM1
 0Dh: IRQ5. Opera uma unidade de disco.
 0Eh: IRQ6. Opera unidade de discos flexíveis.
 0Fh: IRQ7. Opera porta LPT1 para impressora do tipo paralela
Interrupção por Exceção
Possibilita fazer o controle condicional interno do microprocessador, retornando algum tipo de erro. Exemplo: divisão
por zero. Faixa de valores: 0 a 7. Oito tipos de interrupções.
 00h: falha de divisão quando o divisor é igual a zero
 01h: execução passo a passo num processo de debug quando FLAG TF é setado
 02h: interrupção reservada para a condição de operação para NMI (Non Maskable Interrupt)
 03h: ocorre na definição da execução de um ponto de parada (Breakpoint) sobre a execução da instrução
INT3
 04h: ocorre quando há estouro registrado no FLAG OF quando da execução da instrução INTO

_______________________________________________
Page 16 of 22
Interrupção por Software
Efetua o acionamento de determinadas interrupções desejas por intermédio de um programa em execução, podendo
interferir na ação de algum periférico conectado ao microcomputador. As interrupções mais utilizadas são as da ROM-BIOS.
 10h: escrita de caractere no monitor de vídeo
 13h: operações de leitura e escrita em disco
 14h: comunicação com porta serial
 16h: leitura de caractere no teclado
 17h: operações com impressora
 19h: ação de reset
 1Ah: retorna a hora do sistema
 20h: finaliza a operação do sistema
 21h: operações de leitura e escrita nos periféricos padrão conectados ao sistema
 33h: utilização do mouse
6.4 Linguagem Assembly
Denominações semelhantes: ASM86, X86, ASM8086. Todos os microprocessadores da família INTEL possuem
basicamente o mesmo conjunto de instruções existentes no padrão do microprocessador 8086 e 8088. Assembly 8086 possui
116 instruções (mnemonicos) diferentes destinadas ao controle do microprocessadores. Os outros microprocessadores INTEL
possuem novas, e mais, instruções a cada novo lançamento. Seis grupos funcionais: Transferência de dados, Aritméticas,
Manipulação de bits, Manipulação de strings, Controle de programa, Controle do microprocessadores.
 Transferência de dados: Instruções destinadas à movimentação de dados. Podem ser movimentados: Entre
registradores, Entre registradores e posições de memória, Entre registradores e unidades de entrada e saída.
 Aritméticas: Instruções destinadas aos cálculos matemáticos básicos: Adição, Subtração, Multiplicação, Divisão.
 Manipulação de bits: Instruções que fazem o deslocamento de bits em um registrador ou posição de memória. As
funções de operações lógicas de conjunção (ou), disjunção (e) e negação são incluídas neste grupo.
 Manipulação de strings: Fazem o controle de grupos de sequencias de caracteres. Comparação. Análise.
Movimentação.
 Controle de programa: Instruções que controlam a execução do código de programa. Pode ser: Execução sequencial,
Com laços
 Sub-rotinas, Subprogramas. Podem manipular as interrupções de um programa em execução. A interrupção ocorre por
vários motivos. Exemplo: Aceitar uma entrada de dados via teclado. É necessário fazer uma interrupção no programa,
para que o dado possa ser digitado, e após aceitar o dado continua sua execução.
 Controle de microprocessador: Instruções que possibilitam o acesso dos registradores de controle do
microprocessador com o objetivo de mudar seu estado de comportamento.

_______________________________________________
Page 17 of 22
6.5 DEBUG
Para executar o debug em arquiteturas 32 bits:
Entrar no programa CMD.EXE
Digitar CD.. e apertar enter
Digitar novamente CD.. e apertar enter
Digitar DEBUG e apertar enter
Para executar o debug em arquiteturas 64 bits:
Comandos básicos
R: mostra o estado dos registradores
Q: sai do debug
T: executa a operação
E: permite inserir o código da operação no deslocamento indicado
IP: permite alterar o deslocamento da próxima instrução
A: permite inserir código assembly
G: usado para executar operações com caracteres
U: lista o código do programa criado
Operações
ADIÇÃO
OpCode Registradores Gerais Operação Assembly
00D8 AL, BL AL  AL + BL ADD AL, BL
01D8 AX, BX AX  AX + BX ADD AX, BX
02D8 BL, AL BL  BL + AL ADD BL, AL
03D8 BX, AX BX  BX + AX ADD BX, AX
SUBTRAÇÃO
OpCode Registradores Gerais Operação Assembly
28D8 AL, BL AL  AL - BL SUB AL, BL
29D8 AX, BX AX  AX - BX SUB AX, BX
2AD8 BL, AL BL  BL - AL SUB BL, AL
2BD8 BX, AX BX  BX - AX SUB BX, AX

_______________________________________________
Page 18 of 22
MULTIPLICAÇÃO
OpCode Registradores Gerais Operação
F6E3 BL AX  AL * BL (MPY AL, BL)
F7E3 BX DX:AX  AX – BX (dx armazena parte do resultado quando este
ultrapassa os 16 bits) [MPY AX, BX]
DIVISÃO
OpCode Registradores Gerais Operação
F6F3 BL AX  AL / BL (AL = quociente. AH = resto) [DIV AL, BL]
F7F3 BX DX:AX  AX / BX (AX = quociente. DX = resto) [DIV, AX, BX]
Exemplo
Dados os números decimais 1.500 (AX) e 500 (BX), efetue as quatro operações básicas aritméticas no Debug para
todos os códigos de cada uma delas. Anote os valores iniciais e finais de todos os registradores.
Solução
Primeiro devemos converter os números decimais para hexadecimais. No debug são usados 4 bits para o número
hexadecimal. O primeiro passo é converter os números decimais para binário e só depois para hexadecimal, conforme mostram
as tabelas abaixo.
Convertendo 1500: (1.500)10 = (0000 0101 1101 1100)2 = (05DC)16
0 0 0 0 0 1 0 1 1 1 0 1 1 1 0 0
215
214
213
212
211
210
29
28
27
26
25
24
23
22
21
20
32768 16384 8192 4096 2048 1024 512 256 128 64 32 16 8 4 2 1
0 0 0 0 0 1 0 1 1 1 0 1 1 1 0 0
23
22
21
20
23
22
21
20
23
22
21
20
23
22
21
20
8 4 2 1 8 4 2 1 8 4 2 1 8 4 2 1
0 4 + 1 = 5 8 + 4 + 1 = 13 = D 8 + 4 = 12 = C
Convertendo 500: (500)10 = (0000 0001 1111 0100)2 = (01F4)16
0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0
215
214
213
212
211
210
29
28
27
26
25
24
23
22
21
20
32768 16384 8192 4096 2048 1024 512 256 128 64 32 16 8 4 2 1
0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0
23
22
21
20
23
22
21
20
23
22
21
20
23
22
21
20

_______________________________________________
Page 19 of 22
8 4 2 1 8 4 2 1 8 4 2 1 8 4 2 1
0 1 8 + 4 + 2 +1 = 15 = F 4
00D8
01D8
Neste exemplo setamos IP para 0102 pois o primeiro OPCODE ficou armazenado em 0100 e 0101. O OPCODE 01D8
ficará armazenado em 0102 e 0103.

_______________________________________________
Page 20 of 22
02D8
03D8
28D8
29D8

_______________________________________________
Page 21 of 22
2AD8
2BD8

_______________________________________________
Page 22 of 22
Referências
MANZANO, J. A. N. G. Fundamentos em Programação Assembly: Para Computadores IBM-PC. A partir dos
Microprocessadores Intel 8086/8088. Editora Érica, 2009.
MONTEIRO, M. A. Introdução à Organização de Computadores. Editora LTC, 2007.

Resumo assembly x86 16 bits

Mais conteúdo relacionado

Mais procurados (16)

Destaque (19)

Semelhante a Resumo assembly x86 16 bits (20)

Mais de Elaine Cecília Gatto (20)

Último (20)

Resumo assembly x86 16 bits