PONTIFCIA UNIVERSIDADE CATLICA DO RIO GRANDE DO SUL

FACULDADE DE ENGENHARIA

Vanessa Borba de Souza

Mrcia Federizzi

Arquitetura Intel x8086 Simuladores

Trabalho desenvolvido para a disciplina de

Arquitetura de Computadores - EC.

Prof. Eduardo Bezerra

Porto Alegre, 28 de Abril de 2009

Sumrio

Introduo..........................................................................................................................3
Arquitetura do microprocessador 8086.............................................................................4
Registradores de Uso Geral................................................................................5
Registradores de Segmento................................................................................6
Apontador de Instruo: IP..................................................................................7
Registrador de FLAGS............................................................................................7
Memria......................................................................................................................9
Modos de Endereamento.................................................................................10
Linguagem Assembly......................................................................................................11
Introduo ao Projeto dos Simuladores...........................................................................12
Decodificao das Instrues...........................................................................13
Exemplo de Fluxo de Instrues no Diagrama de Blocos......................16
Sobre o arquivo teste..........................................................................................17
Simuladores.....................................................................................................................18
Simulador da arquitetura 8086 Sem Pipeline.........................................18
Executando o programa.................................................................................18
Funcionamento..................................................................................................19
Clculo do CPI.....................................................................................................21
Simulador da arquitetura 8086 Com Pipeline.........................................22
O Pipeline.............................................................................................................22
Conflitos do Pipeline........................................................................................22
Hazards Estruturais..........................................................................................22
Hazards de Controle........................................................................................22
Hazards de Dados.............................................................................................23
Executando o programa.................................................................................24
Funcionamento..................................................................................................24
Clculo do CPI.....................................................................................................26
Sinais de Controle.............................................................................................27
Concluso........................................................................................................................29
Referncias Bibliogrficas...............................................................................................30

Introduo
O 8086 um dos mais antigos e conhecidos microprocessadores de 16 bits. Sua
popularidade se deve a ter sido escolhido como processador para a linha de
computadores pessoais da IBM. Na verdade, o IBM-PC tradicional usa uma verso
simplificada do 8086, o 8088. Novos membros da famlia IBM-PC (como o PC AT e o
PS/2) usam extenses (verses melhoradas e parcialmente compatveis) do 8086.

Arquitetura do microprocessador 8086

O microprocessador 8086 da Intel um microprocessador de 16 bits, de forma que
sua unidade lgica e aritmtica, os seus registradores internos, e a maior parte das suas
instrues foram projetados para trabalhar com palavras de 16 bits.
Alm disso, o 8086 tem um barramento de dados de 16 bits, ou seja, pode ler e
escrever na memria ou nos portos de E/S utilizando 16 bits de uma s vez. O
barramento de endereos de 20 bits, de forma que o 8086 pode enderear 1 MB (220)
posies de memria. Cada uma destas posies de memria ocupada por um Byte.
O processador est dividido em duas unidades funcionais que cooperam entre si:
A Unidade de Execuo ("Execution Unit" - EU): Esta unidade
responsvel exclusivamente pela execuo das instrues. Ela no se ocupa da
transferncia de informaes entre o microprocessador e os demais componentes
do sistema. Quando a execuo de uma instruo exige o acesso a algum
operando externo ao microprocessador, a EU gera uma solicitao BIU.
A Unidade de Interface com o Barramento ("Bus Interface Unit" - BIU):
Esta unidade se ocupa exclusivamente com a transferncia de informaes entre
o microprocessador e o restante do sistema, ou seja, responsvel pelo
endereamento do barramento de endereos, l instrues da memria, l e
escreve dados nas portas e na memria.

Figura 1.0: Diagrama de blocos da arquitetura interna de um processador 8086/88

A Figura 1.0 mostra a arquitetura interna dos microprocessadores 8086 e 8088.

Existem basicamente duas diferenas entre eles: a largura do barramento externo de
dados (8 bits no 8088, e 16 bits no 8086), e o tamanho do bloco "fila de instrues" (4
bytes no 8088 e 6 bytes no 8086).Nesta mesma figura podem ser visualizados os
principais blocos so da arquitetura, sendo eles abaixo descritos:
I. Unidade Aritmtica e Lgica (ALU ): unidade capaz de executar operaes sobre 8
ou 16 bits. Executa operaes lgicas e aritmticas, realiza a manuteno do estado
do microprocessador e das flags de controle, alm de manipular os registros de uso
geral e dos operandos das instrues.
II. Banco de Registradores, constitudo de:

Registradores de Uso Geral: AX, BX, CX, DX, SP, BP, SI e DI;
Registradores de Segmento: CS, DS, SS e ES;
Apontador de Instruo: IP;
Registrador de FLAGS.

Registradores de Uso Geral

So registradores de 16 bits, utilizados para armazenar qualquer informao durante
a execuo do programa.
Os registradores de uso geral so subdivididos em dois conjuntos de 4 registradores:

Registradores de Dados: AX, BX, CX e DX. Seus bytes superiores (AH, BH,
CH e DH) e inferiores (AL, BL, CL e DL) podem ser acessados de modo
independentes, ou seja, cada registrador pode ser usado como um registrador de
8 ou 16 bits. Evitando assim o uso de registradores de 16 bits quando se
realizam operaes de 8 bits. Eles podem ser utilizados sem restries na
maioria das operaes lgicas e aritmticas, mas algumas instrues utilizam
certos registradores de forma implcita, permitindo uma poderosa forma de
codificao.
Registradores Apontadores e de Indexao: SP, BP, SI e DI. O acesso a esses
registradores sempre feito em 16 bits.
Podem tambm participar da maioria das operaes lgicas e aritmticas.
Registrador AX (AH e AL):
tambm denominado Acumulador Primrio. Todas as operaes de I/O so
realizadas atravs deste registrador. As operaes que utilizam dados imediatos
necessitam de menos memria quando so feitas atravs de AX.
Geralmente utilizado como hospedeiro para valores retornados de sub-rotinas.
Registrador BX (BH e BL):
tambm denominado Registrador Base. Usado preferencialmente como apontador
da base de uma tabela de dados. Todas as referncias memria que usam esse
registrador no clculo do endereo usam o registrador DS como segmento padro.

Registrador CX (CH e CL):

tambm denominado Contador, sendo usado prioritariamente para contar o nmero
de interaes no interior de um loop e tambm na manipulao de strings. Ele
decrementado durante as operaes envolvendo loops e strings. Tambm utilizado na
rotao e deslocamento de vrios bits.
Registrador DX (DH e DL):
tambm chamado de registrador de dados ou endereador de I/O. usado para
guardar dados de 16 bits nas operaes com a ULA e controle indireto de I/O. Pode ser
usado por compiladores para retornar valores de subrotinas.
Registrador SP:
denominado Stack Pointer (Ponteiro de Pilha). Utilizado juntamente com BP para
acessar dados no segmento da pilha. Armazena o offset do endereo do topo da pilha.
Todas as referncias ao SP, por definio, utilizam juntamente o registrador de segmento
SS. Tambm pode ser usado como operando em operaes lgicas e aritmticas de 16
bits.
Registrador BP:
denominado Base Pointer (Ponteiro da Base). Permite acessar dados no segmento
da pilha. Tipicamente usado para acessar parmetros que foram passados pela pilha.
Tambm pode ser usado como operando em operaes lgicas e aritmticas de 16 bits.
Registradores de Indexao (SI e DI):
So denominados Source Index (ndice de Origem) e Destination Index (ndice de
Destino). So usados para acessar dados na memria de dados. So extensivamente
usados nas operaes com strings. Tambm podem ser usados como operando em
operaes lgicas e aritmticas de 16 bits.

Registradores de Segmento
A memria do 8086/88 dividida em segmentos lgicos de at 64 Kb. A CPU tem
acesso simultneo a at 4 segmentos, utilizando os registradores CS, DS, SS e ES como
seletores de endereo. Estes registradores esto localizados na BIU, sendo acessveis
para programas, podendo ser manipulados por vrias instrues. As principais funes
de cada um destes registradores:
Registrador CS:
denominado Code Segment (Segmento de Cdigo). utilizado para montar o
endereo de uma instru (code) a ser buscada (fetch) na memria. Este define o
endereo base (segmento) e deve ser somado ao registrador IP (tambm localizado na
BIU) para formar o endereo de 20 bits da instruo. Em outras palavras, aponta para o
segmento de cdigo de instruo em uso.
6

Registrador DS:
denominado Data Segment (Segmento de Dados). Aponta para os segmentos de
dados onde geralmente so armazenadas as variveis de programa. Em conjunto com IP
define o endereo efetivo do dado a ser lido ou escrito na memria.
Registrador SS:
denominado Stack Segment (Segmento de Pilha). Aponta para o segmento da pilha
em uso. Todos os acessos pilha utilizam os registradores SP e BP e utilizam como
referncia o registrador de segmento de pilha (SS).
Registrador ES:
denominado Extra Segment (Segmento Extra). uma opo extra para apontar a
base de um segmento de dados (strings). Por exemplo, ele utilizado juntamente com o
DI para formar o endereo da base de strings de dados.

Apontador de Instruo: IP
denominado Instruction Pointer (Ponteiro de Instrues). Este registrador
atualizado pela BIU e contm a distncia em bytes (offset) da prxima instruo em
relao ao incio do cdigo que est sendo executado, isto , ele aponta para a prxima
instruo. Os programadores no tm acesso direto a esse registrador.

Registrador de FLAGS
O microprocessador 8086 contm em seu interior um total de 9 sinalizadores,
tambm conhecidos como flags. Eles existem para indicar resultados obtidos sempre na
ltima operao lgica ou aritmtica executada, ou para definir o comportamento do
microprocessador na execuo de certas instrues. Estes 9 flags esto agrupados, para
facilidade de acesso, em um registrador de 16 bits, chamado de Registrador de Flags,
Registrador de Estado ou Palavra de Estado do Programa, sendo localizado na unidade
EU.
Como mostra a figura 2.0, ele utiliza bits para armazenar informaes de estado
(status) e de controle.
15 14 13 12 11 10 9 8
7
6
5 4
3 2
1 0
- OF DF IF TF SF ZF - AF - PF - CF
Figura 2.0 Registrador dos Flags.

Flags de Estado:
Os bits de estado refletem certas propriedades de resultados de operaes lgicas e
aritmticas realizadas na EU, a qual responsvel por setar estes bits no registrador.

AF - Flag de Carry Auxiliar: indica o transporte para fora do nibble menos

significativo - do bit 3 para o bit 4 - do resultado produzido pela ULA.
utilizado quando se manipula operandos representados em cdigo BCD ou
ASCII, ou seja, AF = 1 -> caso exista o "vai um" do bit 3 para o bit 4 de uma
adio caso no exista "emprstimo" do bit 4 para o bit 3 numa subtrao;
AF = 0 -> caso contrrio.
CF - Flag de Carry: CF = 1 -> aps instrues de soma que geram "vai um"
aps instrues de subtrao que no geram "emprstimo" ("empresta um");
CF = 0 -> caso contrrio.
OF - Flag de Overflow: OF = 1 -> qualquer operao que produza overflow;
OF = 0 -> caso contrrio.
SF - Flag de Sinal: utilizado para indicar se o nmero resultado positivo ou
negativo em termos da aritmtica em Complemento de 2 (se no ocorrer erro
de transbordamento - overflow). SF = 1 -> nmero negativo SF = 0 ->
nmero positivo.
ZF - Flag de Zero: ZF = 1 -> caso o resultado da ltima operao aritmtica
ou lgica seja igual a zero; ZF = 0 -> caso contrrio.
PF - Flag de paridade: Este sinalizador ativado, quando o nmero de 1s nos
8 bits menos significativos do resultado produzido pela ULA par, e
desativado caso contrrio, ou seja PF = 1 -> caso o byte inferior do resultado
de alguma operao aritmtica ou lgica apresentar um nmero par de "1's";
PF = 0 -> caso contrrio (nmero impar).
Flags de Controle
So os flags que podem ser setados pelos programas, alterando as operaes do
processador:

DF - Flag de Direo: H instrues que envolvem os registradores de ndice

na formao do endereo efetivo dos operandos. Algumas destas instrues
implicam na alterao do contedo do registrador de ndice. Dependendo do
contedo deste sinalizador, os registradores de ndice sero incrementados
ou decrementados automaticamente, quando tais instrues so executadas.
DF = 1 -> decremento do endereo de memria (DOWN); DF = 0 ->
incremento do endereo de memria (UP).
IF- Flag de Interrupo: este sinalizador determina, se o processador est
habilitado ou desabilitado a atender interrupes. IF = 1 -> habilita a
ocorrncia de interrupes;IF = 0 -> inibe interrupes tipo INT externas.
TF - Flag de Trap (armadilha): TF = 1 -> aps a execuo da prxima
instruo, ocorrer uma interrupo; a prpria interrupo faz TF = 0; TF = 0
-> caso contrrio.

Memria
Do ponto de vista do programador, a memria se comporta como um conjunto de
endereos onde possvel escrever e ler informaes. Cada locao, ou endereo
identificado por um nmero.
A memria pode ser vista como uma longa lista de endereos, ou como um
agrupamento de endereos em blocos denominados pginas. Os dgitos mais
significativos do endereo representam a pgina, e os dgitos menos significativos
identificam a posio dentro da pgina, como por exemplo, a pgina 10 compreender
os endereos de 1000 a 10FF.
Com 16 bits para endereamento possvel enderear 216 = 64K locaes. Para
aumentar essa faixa de endereos pode-se estender o tamanho de palavra de endereo,
ou utilizar tcnicas de gerenciamento de memria. Os microprocessadores 8086/88
utilizam o gerenciamento de memria por segmentos.
Durante a execuo de um programa no 8086, h 4 segmentos ativos:
segmento de cdigo: endereado por CS
segmento de dados:endereado por DS
segmento de pilha: endereado por SS (stack segment)
segmento extra: endereado por ES.
Gerenciamento de memria por segmentao:
O 8086 possui 20 bits para acessar posies de memria fsica o que corresponde a
220 = 1.048.576 bytes (1 Mbyte) de posies endereveis. Exemplos de endereos:
0000 0000 0000 0000 0000b -> 00000h
0000 0000 0000 0000 0001b -> 00001h
1111 1111 1111 1111 1111b -> FFFFFh
O 8086 opera internamente com 16 bits para gerar endereos com 20 bits ele utiliza a
idia de segmentao de memria.
Cada segmento de memria corresponde a um bloco de 64 Kbytes de posies de
memria consecutivas, identificado por um nmero de segmento.
Para acessar um byte ou palavra particular na memria, necessrio um offset, ou
seja, uma distncia em bytes do incio do segmento. O endereo real de memria de 20
bits o resultado da soma de um registrador de segmento (deslocado de 4 bits para a
esquerda) e um offset de 16 bits . O registrador de segmento e a fonte do offset
dependem do tipo de referncia memria desejado:

Tipo de Referncia
Memria
Busca de instruo
Pilha
Varivel

a Segmento
Default
CS
SS
DS

String fonte
String destino
BP como registrador base

DS
ES
SS

Segmento
Alternativo
nenhum
Nenhum
CS,ES,SS
CS,ES,SS
Nenhum
CS,ES,SS

Offset
IP
SP
Endereo
efetivo
SI
DI
Endereo
efetivo

Figura 3.0- Tipos de Referncia a memria.

O endereo efetivo mencionado na tabelada figura 3.0 corresponde ao resultado da

avaliao de um modo de endereamento. Nos casos em que um segmento alternativo
aparece na tabela, o segmento default pode ser substitudo usando-se um prefixo de
segmento.
A referncia a uma posio de memria dada por:
reg_segmento : reg_offset
Por exemplo: CS:IP, SS:SP, DS:SI, DS:DI

Modos de Endereamento
Os processadores 80x86 permitem acessar a memria de vrios modos diferentes. Os
modos de endereamento de memria do 80x86 oferecem flexibilidade no acesso
memria, permitindo acessar facilmente variveis, arrays, registros, ponteiros e outros
tipos de dados mais complexos.
Modo Registrador e Imediato
Registrador: os operandos fonte, destino ou ambos esto contidos em registradores.
Exemplo: MOV CX, BX
Imediato: os dados em 8 ou 16 bits podem ser especificados como parte da
instruo. Exemplo: MOV CX, 24h
Modo de Endereamento de Memria
Direto: O endereo efetivo do operando (offset) no correspondente segmento
obtido diretamente a partir de um determinado dado, sem envolver quaisquer
registradores. Exemplo:
.DATA
START DW 39FAH
...
MOV BX, START

10

Indireto registrador: O endereo efetivo de um operando na memria pode ser

obtido a partir de um dos registradores de base ou ndice. (BX, BP, SI,DI)
Baseado: O endereo efetivo calculado a partir de uma constante e dos
registradores de base BX ou BP. Quando no se excede pilha o endereo de 20 bits
calculado a partir de DS:BX. Quando se excede pilha esse endereo calculado a
partir de SS:BP.
Indexado: O endereo efetivo obtido a partir de uma constante e dos registradores
de ndice SI u DI.
Indexado baseado: O endereo efetivo calculado a partir de uma constante, dos
registradores de base (BX, BP) e dos registradores de indice (SI, DI).
De strings: utiliza-se o registrador SI para apontar para o primeiro byte ou word de
uma string origem e o registrador DI para apontar para o primeiro byte ou word do
destino, quando utilizada uma instruo para strings.

Linguagem Assembly
O processador x8086 possui um grande conjunto de instrues, que podem ser
divididas em: instrues de movimentao de dados, instrues aritmticas, instrues
lgicas, instrues de manipulao de strings, instrues de desvio e controle de fluxo.
Aqui somente sero descritas as instrues do subconjunto formado para
implementao nos simuladores.

11

Introduo ao Projeto dos Simuladores

O projeto visa aprendizagem da arquitetura x8086. A implementao dos simuladores
consiste em uma implementao simplificada da arquitetura do microprocessador 8086
com um subconjunto restrito de instrues assim como algumas funcionalidades bsicas
desta arquitetura.
Aps o estudo da arquitetura x8086 foi realizado um estudo do conjunto de
instrues do processador e a maneira como este as decodifica. Para tanto, definimos
apenas o subconjunto de instrues formado pelas instrues: MOVE (Im/Reg,
Reg/Reg, Mem/Reg, Mem/Acum), ADD e LOOP. Na decodificao documentada j
est apresentada tambm alguma relao com a programao dos simuladores.
O desenvolvimento do projeto foi divido em trs etapas de implementao, visando
facilitar a compreenso e organizao da estrutura do simulador. Na primeira etapa,
desenvolveu-se o simulador sem recurso de pipeline. Com base no funcionamento
descrito no datasheet do x8086, criou-se o projeto para simular as unidades bsicas de
funcionamento do microprocessador estudado, sendo estruturadas rotinas para simular a
unidade de memria (dividida em segmentos de dados, de cdigo e de registradores,
mas fisicamente uma unidade), a unidade de processamento lgico e aritmtico (ula), a
unidade de clculo de endereos (somador), o banco de instrues e unidade de
execuo (reconhecimento da instruo e busca de registradores ou informao da
memria). Rotinas auxiliares foram implementadas devido limitao da linguagem
escolhida para montagem do simulador, tais como rotina para converso de nmeros
hexadecimais para binrios e de nmeros binrios para decimais.
A figura 4.0 mostra o diagrama de blocos da arquitetura implementada nos
simuladores.

Figura 4.0 Diagrama de Blocos da Arquitetura Interna Implementada na Simulao da Arquitetura

8086.

12

A segunda etapa do projeto consiste em, dado que a implementao da seqncia

de rotinas para simular as etapas de processamento do x8086 para o conjunto de
instrues mov reg/reg, mov regacum/memria, mov reg/imediato, mov reg/memria,
add e loop estava correta, implementar as rotinas e controles que tornem possveis as
aplicaes do recurso de pipeline para o simulador.

Decodificao das Instrues

As instrues do processador x8086 no apresentam tamanho fixo (quantidade de
bits de cada uma das instrues), variando de acordo com cada uma delas, assim como o
nmero de bits que podemos considerar como opcode da instruo.
Na decodificao das instrues necessrio conhecer o significado de alguns bits
utilizados no formato da instruo. Segue abaixo a forma de decodificao:
MOVE
Im/Reg, Reg/Reg, Mem/Reg , Mem/Acum
Im/Reg: move um imediato para um registrador.
Formato da instruo:
7
0 7
0
7
0
1 0 1 1 w reg data (parte baixa) data se w=1 (arte alta)
Reg o cdigo do registrador destino da operao.
Se w=1 significa que o valor do imediato esta ocupando 16 bits, se w=0 o imediato
esta apenas ocupando a parte baixa do dados, isto , somente 8 bits (instruo operando
com word ou com byte).
O opcode da instruo move de imediato para registrador definido pelos bits de 7-4
= B em hexa.
Para decodificao desta instruo nos simuladores utilizamos a contagem dos bits
seqencialmente iniciando em 1, formando a seguinte tabela:
1
4
7
4
1011
B

5
8 9
3
0 7
w reg
Data
-

16 17
24
0 7
0
Data se w=1
-

As posies dos bits: 1-4 = opcode , 5 = w, 6-8= Reg, dependendo de w o imediato

pode estar de 9-16 ou 9-24,
Instruo de leitura da memria e escrita no banco de registradores.

13

Reg/Reg: move o contedo de um registrador para outro registrador.

Formato da instruo:
7
0 7
0
1 0 0 0 1 0 d w mod reg r/m
W identifica instruo operando com Word se w=1 ou com byte w= 0.
D defini a direo dos dados, no caso como a direo de registrador para registrador
este ser sempre igual a zero.
Como operamos com dois regs, mod ter o valor 11 implicando no campo r/m ser um
registrador.
Os bits de r/m simbolizam o registrador destino da operao sendo os bits de reg o
registrador fonte.
Logo a identificao da instruo poder ser feita por: 88 ou 89.
Para decodificao desta instruo nos simuladores utilizamos a contagem dos bits
seqencialmente iniciando em 1, formando a seguinte tabela:
1
4
7654
1000
8

5
8
3210
10dw
8, se w=0
9 se w =1

9
12
76
54
mod reg
11
xx

13
3
reg
x

16
210
r/m
xxx

As posies dos bits: 1-8 = opcode, 8 = w, 11-13 = Reg, 14-16 = R/m.

Instruo de leitura e escrita no do banco de registradores.
Mem/Reg : move um valor da memria para um registrador.
Formato da instruo:
7
0 7
0
1 0 0 0 1 0 d w mod reg r/m
W identifica instruo operando com word se w=1 ou com byte w= 0.
D defini a direo dos dados, no caso como a direo de memoria para registrador
este ser sempre igual a um.
Reg o registrador destino.
Logo a identificao da instruo poder ser feita por: 8A ou 8B (considerando os
bits 7-8).
Para decodificao desta instruo nos simuladores utilizamos a contagem dos bits
seqencialmente iniciando em 1, formando a seguinte tabela:
1
4 5
8
9
7654 3210
76
1000 10dw
Mod
8
B, se w=1
A, se w=0

12 13
54
3
Reg Reg

16
210
rm/m

As posies dos bits: 1-8 = opcode, 8 = w,11-13 = Reg

Instruo de Leitura da memria e escrita no banco de registradores.
14

Mem/Acum: move um valor contido na memria para o registrador acumulador de

16nits Ax, ou acumulador 8 bits AH.
Formato da Instruo:
7
0 7
0 7
0
1 0 1 0 0 0 0 w Addr-low Addr-high
W identifica instruo operando com Word se w=1 ou com byte w= 0.
Move da memria para o registrador Ax cumulador 16bits, ou AH acumulador 8bits.
A identificao da instruo poder ser feita por: A.
Para decodificao desta instruo nos simuladores utilizamos a contagem dos bits
seqencialmente iniciando em 1, formando a seguinte tabela:
1
4 5
8 9
16 17
24
7654 3210 76543210
76543210
1 0 1 0 0 0 0 w Addr_low
Addr_high
A
000
As posies dos bits: 1-4 = opcode, 8= w, endereo da memria =
Ax ou AL = 000 = Reg
Instruo de leitura da memria e escrita no banco de registradores
ADD
Reg/Reg: soma do contedo de dois registradores.
Formato da Instruo:
7
0 7
0
0 0 0 0 0 0 d w mod reg r/m
W identifica instruo operando com Word se w=1 ou com byte w= 0.
D defini a direo dos dados, no caso como a direo de registrador para
registrador este ser sempre igual a zero.
Como operamos com dois regs, mod ter o valor 11 implicando no campo r/m ser um
registrador.
Os bits de r/m simbolizam o registrador destino da operao sendo os bits de reg o
registrador fonte.
Logo a identificao da instruo poder ser feita por : 01 ou 00.
Para decodificao desta instruo nos simuladores utilizamos a contagem dos bits
seqencialmente iniciando em 1, formando a seguinte tabela:
1
4 5
8
9 10 11 13 14 16
7654 3210
76
543
210
0000 00dw
mod Reg
R/m
0
1, se w=1,
0, se w=0

15

As posies dos bits: 1-8 = opcode, 8 = w, 11-13 = Reg, 14-16 = R/m.

Instruo de leitura e escrita no do banco de registradores.
LOOP
A instruo um salto condicional, que testa o valor do registrador Cx, verificando
se este diferente de 0, se for executa o salto, caso contrrio, no realiza o salto.
Formato da instruo:
7
0 7
0
11100010
disp
Disp o deslocamento que deve ser subtrado do endereo do IP para achar o
endereo a partir do qual recomea o lao. Este valor est representado em
complemento de dois.
Logo a identificao da instruo poder ser feita por:E2.
Para decodificao desta instruo nos simuladores utilizamos a contagem dos bits
seqencialmente iniciando em 1, formando a seguinte tabela:
1
4
7654
1110
E

5
8 9
16
3210 76543210
0 0 1 0 disp
2

As posies dos bits: 1-8 = opcode, 9-16 = deslocamento.

Exemplo de Fluxo de Instrues no Diagrama de

Blocos
Para melhor compreenso do funcionamento da arquitetura, efetuamos o fluxo da
instruo ADD no diagrama de blocos, conforme mostra a figura 5.0.

16

Figura 5.0 Execuo da Instruo ADD

Inicialmente, a instruo ADD lida da memria pela Unidade de Interface de

Barramento (BIU). Em seguida, a Unidade de Execuo (EU) decodifica a instruo e
solicita a BIU os valores dos operandos. Por sua vez, a BIU retorna para a EU os
valores lidos nos registradores. Depois a EU novamente acionada para que a unidade
ULA processe a operao de soma. Em seguida, a BIU transfere o valor da sada da
ULA para o registrador destino. Durante esse processo a unidade sinais de controle est
sendo atualizada. Toda a execuo sincronizada pelo Controle de Tempo (clock).

Sobre o arquivo teste

Para testar o funcionamento dos simuladores foi implementado o programa (arquivo
programafunciona.asm), em linguagem de montagem para o processador x8086, que
executa a srie de Fibonacci para os dez primeiros nmeros da srie, apresentando o
valor do dcimo nmero da srie. No desenvolvimento do programa teste, foram
avaliadas as instrues que poderiam ser utilizadas para esse execuo, segundo o
critrio de opcode diferenciado o que facilitou a implementao das instrues mov
reg/reg, mov reg/imm, mov mem/reg, mov mem/acumulador, add e loop. O cdigo
objeto do arquivo assembler foi gerado no montador NASM em sistema operacional
Linux, conforme consta no cabealho dos fontes dos simuladores.

17

Simuladores
Simulador da arquitetura 8086 Sem Pipeline
Executando o programa
Aps iniciar a execuo do programa (duplo clique sobre o arquivo
SimuladorSPipeline.exe), abrir a tela do simulador conforme mostra a figura 6.0. No
campo Informe o caminho do arquivo (.lst), clique no boto de abrir, para que a janela
de busca de arquivos seja aberta. Selecione e abra arquivo com extenso .lst gerado a
partir de cdigo programado em assembly no montador NASM.
Para abrir o arquivo teste busque por:
Diretrio:\T1MarciaFederizzi_VanessaBorba\SimuladorSPipeline
programafunciona.lst

Figura 6.0 Simulador Sem Pipeline. Em destaque os botes de seleo de arquivo e execuo do
programa.

18

Observaes:
1 - Antes de abrir o arquivo .lst necessrio edit-lo linha a linha. A edio
referente ao caracter de quebra de linha, que no arquivo original no o caracter padro
para enter. Nesse caso, ao final de cada linha tecle enter para marcar o final de linha no
arquivo. Aps abrir o arquivo, clique em Executar Programa para iniciar a simulao
de processamento do x8086.
2 - O arquivo .lst dever ser gerado no nasm, no sistema operacional Linux, atravs
do comando: diretorio/nasm f elf l arquivo.lst arquivo.asm

Funcionamento
Inicialmente o sistema ir acessar o arquivo informado e carreg-lo, linha a linha,
para a lista Seqncia e instrues do programa. Ao gravar as linhas nessa lista, o
programa j est tratando e desconsiderando linhas em branco e possveis comentrios
contidos no arquivo, por meio da rotina ArmazenaLinha. A rotina LeArquivoLST
responsvel por gerenciar a leitura das linhas do arquivo e efetuar a chamada da rotina
ArmazenaLinha. Essa lista composta de duas colunas: ndice e instruo. Sua
montagem e exibio foram projetadas para facilitar o acompanhamento das instrues
que sero processadas pelo simulador. Para tanto, a coluna ndice que faz referncia a
cada linha de programa do arquivo, tambm ser exibida nas listas especificadas abaixo:
Posio de Memria/Instruo: contm o programa no formato de cdigo objeto
permitindo acompanhar como cada linha do cdigo em assembly foi montada para
execuo. O preenchimento dessa lista implementado pela rotina CarregaMemoria
que percorre o objeto Seqncia e instrues do programa e monta o que simularia o
modo como o 8086 trata a memria, isto , segmento de dados e segmento de cdigo
representados pela lista Posio de Memria/Instruo e a rea de registradores de uso
geral, representada pela lista Contedo dos registradores, mas que simbolizam serem
fisicamente uma nica memria. Despreza a coluna de instrues escritas em assembly,
montando apenas a coluna de ndices (referncia constante no simulador para a linha de
processamento).
Processamento das Instrues: exibe a sequncia de dados em cada registrador
durante a execuo do programa.
Contedo dos registradores: simula a rea de registradores de uso geral, tendo os
valores constantemente atualizados conforme seqncia do programa. Mostra o
contedo dos registradores aps o trmino do programa.
As rotinas de simulao da arquitetura 8086 comeam a serem executadas no instante
em que o programa j foi carregado na memria (no simulador, aps carregar a lista
Posio de Memria Instruo).
As linhas de programa so processadas em srie e somente aps o trmino dos
estgios de execuo de uma instruo, o simulador reinicia a rotina buscando nova
instruo. A busca realizada at que a rea de programa tenha sido executada por
completo.

19

A rotina ProcessaInstrucoes percorre a lista memria e gerencia o reconhecimento

de cada instruo. Aps identificar a instruo, por meio do opcode, o controle de
processamento passado para as rotinas de tratamento das instrues. Os mtodos
MovMemRe, MovRegReg, MovImedReg, MovMemAcum, Loop e Add implementam
as instrues mov memoria/registrador, mov registrador/registrador, mov
imediado/registrador, mov memoria/registrador acumulador, loop e add. Na
implementao de cada um dos mtodos citados, h a chamada para procedimentos que
simulam a unidade de controle que executa a instruo e determina, conforme
posicionamento das informaes na instruo, o prximo passo de execuo, isto ,
busca de dado no registrador, na memria ou clculo de endereos. Para essas trs
tarefas, a unidade lgica aritmtica acionada. Tal unidade est sendo representada no
sistema pelas rotinas:
IdentRegistrador: funo que recebe por parmetro o cdigo destinado para os
registradores concatenado com o valor de w e retorna o registrador utilizado na
instruo.
CalculaEndereco: responsvel por efetuar clculo do endereo de salto, a partir do
endereo atual e do endereo efetivo passados na decodificao da instruo.
RetornaIP: funo que retorna o IP calculado e informado na coluna de endereo da
lista Posio de Memria/Instruo.
LeRegistrador: funo que recebe o endereo do registrador e retorna o contedo
referenciado pelo mesmo.
LocalizaDado: funo que recebe um endereo da rea de dados e retorna o contedo
referenciado por esse endereo de memria.
ULA: funo que representa a unidade aritmtica, implementando as operaes de
soma e subtrao. A unidade lgica, para comparao de valores, implementada entre
as rotinas listadas acima, como a de reconhecimento do registrador na instruo
(IdentRegistrador).
Ao trmino da execuo da instruo, ainda no procedimento ProcessaInstrucoes, a
seqncia de processamento da instruo inclusa na lista Processamento de
Instrues.
Complementando as rotinas que representam as funcionalidades do processador, a
funo EscreveRegistrador, utilizada pelas instrues que buscam dados na memria
e armazenam em registradores. Seu funcionamento consiste em receber por parmetro o
endereo do registrador e o contedo (dado) e armazen-lo na posio de memria
referenciada pelo registrador.
As linhas de programa so processadas em srie e somente aps o trmino dos
estgios de execuo de uma instruo, o simulador reinicia a rotina buscando nova
instruo. A busca realizada at que a rea de programa tenha sido executada por
completo.
Devido a escolha por uma linguagem de programao que permitisse maiores
recursos grficos para a montagem do simulador, mas que no projetada para
manipular informaes em binrio e hexadecimal, foi necessrio implementar algumas
rotinas para simular unidades j existentes em linguagens prpria para programao de
processadores. Abaixo sero listadas essas rotinas com descrio de sua funcionalidade.
HexaBin: funo que recebe um caracter em hexadecimal e retorna seu valor em
binrio.

20

BinarioDecimal: funo que recebe como parmetro um valor binrio e retorna o

valor correpondente em decimal.
Expoente: funo para elevar um nmero a qualquer expoente.
Rotinas implementadas apenas para a parte visual do simulador:
LimpaCampos: limpa os objetos na tela do simulador antes de iniciar nova execuo
do programa.
RegistraProcesso: incluso das informaes processadas na lista de Processamento
das instrues.

Clculo do CPI
Para auxiliar a visualizao das vantagens do pipeline sobre a arquitetura, foi inclusa
a rotina de clculo de CPI (Ciclos por Instruo). Nesse simulador, em cada estgio da
instruo foi incluso um contador para simbolizar a quantidade de ciclos gastos por
instruo, j que na linguagem Delphi, no possvel ativar a rotina segundo um clock
definido. Ao trmino da execuo do simulador, contabilizado o nmero total de
instrues contidas no programa. O total de ciclos gastos dividido pelo total de
instrues executadas e resultado informado no campo CPI.

21

Simulador da arquitetura 8086 Com Pipeline

O Pipeline
uma tcnica de implementao de processadores que permite a sobreposio
temporal de diversas fases da execuo de instrues, sendo a base para implementao
de tcnicas que permitem aos processadores atuais, rodarem os programas mais
rapidamente.
valido ressaltar que o pipeline otimiza a performance do processador por meio do
aumento do throughput das instrues, ou seja, aumentando o nmero de instrues
executadas por unidade de tempo, e no por meio da diminuio do tempo de execuo
de cada instruo.

Conflitos do Pipeline
A dificuldade de implementar o pipeline est na possibilidade de termos
inconsistncias ao processar instrues durante a execuo de um programa,
dependendo da seqncia de instrues do cdigo. Tais conflitos, tambm chamados de
hazards, podem ser tratados com a incluso de unidades que permitam detectar
antecipadamente o conflito e que insiram um tratamento durante o processo de pipeline,
em meio execuo das instrues.
Os hazards so divididos em: estruturais, de controle e de dados.

Hazards Estruturais
Ocorrem quando o hardware no pode suportar a combinao de instrues que o
pipeline deseja executar no mesmo ciclo de clock. Exemplo: em uma arquitetura que
possui uma memria para instrues e dados, no seria possvel adiantar a leitura de
uma instruo se uma instruo de leitura de dados estivesse sendo executada no mesmo
ciclo de clock. No simulador x8086, a unidade de controle dever testar o tipo de
instruo antes de liberar sua execuo para o prximo estgio. Caso a instruo no
possa ser executada, a primeira tentativa de soluo seria o adiantamento do resultado,
caso esse tambm no fosse possvel, a soluo dada a incluso da instruo de No
Operante (NOP) para os estgios do pipeline, afim de que a instruo complete a parte
do ciclo conflitante, para dar segmento ao estgio.

Hazards de Controle
Origina-se da necessidade de se tomar uma deciso com base nos resultados de uma
instruo, enquanto outras esto sendo executadas. Exemplo: instrues com salto
condicional, loops. Para esses casos as solues propostas dividem-se:

22

Parada ou Bolha: insero de uma instruo NOP para que no haja progresso no
processamento da informao enquanto o resultado da instruo anterior no estiver
executado. Problema: essa soluo embora seja mais fcil de implementar implica em
perda da performance do processamento, pois o pipeline eficiente aps seu
preenchimento total. Com a parada, h perda de ciclos e perde-se mais tempo para
encher novamente o pipeline depois de interromper o progresso das instrues por
intermdio do pipeline. Esse recurso aplicvel no simulador proposto nesse trabalho,
pois embora no implemente instrues de desvio condicional, h seqncias de
instrues em que no ser possvel efetuar o adiantamento do resultado e para esses
casos, o uso da bolha impede o conflito de dados.
Predio: hardware para adivinhar qual a prxima instruo a ser executada em caso
de desvios condicionais (se salta para um dado endereo ou executa a instruo
seguinte). Em geral os processadores adotam a predio para tratar os desvios
condicionais executados em pipeline. Um esquema simples sempre predizer que os
desvios condicionais vo falhar. Estando certo, o pipeline prossegue na velocidade
mxima. Se errado, h a necessidade de atrasar o avano normal das instrues por meio
do pipeline e garantir que as instrues j executadas no iro interferir no resultado
correto. Esse recurso satisfaz o conflito que pode ocorrer com o uso da instruo loop.
Pretende-se implementar uma lista de predio dinmica em que os resultados das
quatro primeiras ocorrncias so armazenados e a mdia de ocorrncia determinar a
ao que dever ser assumida para a prxima execuo. Em caso de erro da predio,
incluso de bolhas para limpar o pipeline, caso o resultado processado afete a seqncia
do programa.

Hazards de Dados
Ocorrem quando a execuo de uma instruo depende do resultado de outra, que
ainda est no pipeline. Exemplo: processar uma soma em que um dos operadores ainda
no teve seu valor alterado pela instruo anterior, salvo no registrador.
Para solucionar esse conflito necessria a incluso de uma unidade que
constantemente verifica os contedos dos registradores e os compara, para verificar se
haver algum conflito de dado em algum estgio. Para que essa unidade possa efetuar os
testes, torna-se indispensvel um conjunto de sinais de controle que dever ser
constantemente atualizado durante processamento das instrues de cada estgio. Ao
efetuar comparaes entre a ao indicada pelos sinais de controle (exemplo
escrita/leitura da memria ou escrita/leitura de um registrador) e os endereos de
memria e os dados apontados por cada instrues, em cada estgio do pipeline,
possvel detectar que ocorrer um conflito. Nesse instante, realiza-se um teste para
verificar se possvel adiantar o resultado de algum estgio antes de ocorrer o
processamento da instruo em que ocorreria o conflito. Em caso positivo, a unidade de
adiantamento (Forwarding) ir buscar o resultado contido em um dos registradores (ou
o caminho para encontrar o registrador e o dado) para incluso como uma entrada para o
processamento da instruo seguinte. Dessa forma, no exemplo da soma, os operandos
seriam processados com os valores corretos antes mesmo do resultado da instruo
anterior ter sido gravado no registrador destino.
O simulador implementa esse conceito e o resultado adiantado salvo nos
registradores de estgio do pipeline para serem passados aos registradores manipulados
nas instrues.
23

Executando o programa
Aps iniciar a execuo do programa (duplo clique sobre o arquivo
SimuladorSPepiline.exe), abrir a tela do simulador conforme mostra a figura 1.0. No
campo Informe o caminho do arquivo (.lst), clique no boto de abrir, para que a janela
de busca de arquivos seja aberta. Selecione e abra arquivo com extenso .lst gerado a
partir de cdigo programado em assembly no montador NASM.
Para abrir o arquivo teste busque por:
Diretrio\T1MarciaFederizzi_VanessaBorba\SimuladorSPipeline\programafunciona.l
st
Observaes:
1 - Antes de abrir o arquivo .lst necessrio edit-lo linha a linha. A edio
referente ao caracter de quebra de linha, que no arquivo original no o caracter padro
para enter. Nesse caso, ao final de cada linha tecle enter para marcar o final de linha no
arquivo. Aps abrir o arquivo, clique em Executar Programa para iniciar a simulao de
processamento do x8086.
2 - O arquivo .lst dever ser gerado no nasm, no sistema operacional Linux, atravs
do comando: diretorio/nasm f elf l arquivo.lst arquivo.asm

Funcionamento
O simulador da arquitetura com pipeline possui uma interface parecida com a
interface do simulador sem pipeline, como podemos ver na figura 5.0. Foram
acrescentadas as listas Registradores do Pipeline e Estgios do Pipeline. As demais
listagens existentes na implementao anterior permanecem com as mesmas
funcionalidades, permitindo visualizar, ao final do programa, a seqncia de execuo e
os valores dos registradores nas listas Processamento das Instrues e Contedo dos
registradores, respectivamente, para verificao da execuo do programa fornecido
para a arquitetura do simulador. Tambm as rotinas expostas em Simulador Sem
Pipeline foram mantidas nesse projeto com Pipeline.
Para implementao do pipeline foi necessrio modificar a estrutura dos
procedimentos: MovMemRe, MovRegReg, MovImedReg, MovMemAcum, Loop e Add. A
alterao consiste em, para cada ciclo que a instruo em execuo for processada,
alguns dados de controle, tais como endereos de registradores, dado lido, endereo de
memria, etc, devem ser armazenadas em registradores de controle do pipeline
correspondente ao estgio de execuo da instruo. Como a linguagem escolhida para
desenvolver o simulador, no permite execuo simultnea de rotinas, no possvel
incluir, efetivamente, mais de uma instruo no mesmo ciclo de processamento. No
entanto, montamos a estrutura analisando como seria implementado em uma linguagem
sem essa restrio, conforme ser efetuado na segunda etapa do projeto, quando o
processador ser implementado em linguagem VHDL, que permite paralelismo na
execuo de rotinas. Dessa forma, o pipeline foi projetado para ser implementado em
cinco estgios, controlados por quatro registradores de pipeline IFID, IDEX, EXMEM,
MEMWB. A seguir sero especificados cada estgio e informaes passadas para cada
registrador de controle.

24

Busca da Instruo (IF): estgio que efetua a leitura da instruo na memria

usando para tanto o endereo armazenado em IP. A instruo e o IP incrementado so
armazenados no registrador de controle IFID.
Decodificao da Instruo e leitura dos registradores de uso geral (ID):
responsvel pela decodificao e leitura dos operandos, seja na memria ou no banco de
registradores. Da parte inicial desse estgio, a informao de qual(is) o(s) endereo(s)
do(s) registrador(es) utilizado(s) na instruo, j decodificado(s), armazenada ainda
no registrador IFID.
Execuo ou clculo de endereo (EX): processa a instruo (executa). So
guardados no registrador IDEX o endereo dos registradores origem e destino, se
houver, os sinais que indicam se escrita/leitura no banco de registrador, se
escrita/leitura na memria, o endereo do dado imediato no calculado e o IP
incrementado.
Acesso memria (ME): estgio reservado para escrita na memria. Armazena no
registrador de controle EXMEM o registrador destino, os sinais de: escrita/leitura no
banco de registrador, controle do desvio condicional, escrita/leitura da memria e o
endereo calculado na ULA.
Escrita no banco de registradores (WB): processo de escrita no banco de
registradores. Armazena no registrador MEMWB o registrador destino, os sinais de:
escrita/leitura no banco de registrador, escrita/leitura da memria e o dado localizado
que ser armazenado.
Com base nas informaes armazenadas nos registradores de estgios do pipeline,
durante cada ciclo de execuo das instrues, possvel testar esses valores e
identificar se haver conflitos de controle ou dados.
O procedimento AtualizaEstagios chamado a final da execuo de cada ciclo da
instruo para armazenar os dados conforme o estgio que a instruo est sendo
processada. As informaes armazenadas so visveis no simulador, sendo os
registradores de estgios representados pelas colunas da lista Registradores de
Estgios.
Durante a passagem do ciclo atual para o novo ciclo, alm da atualizao dos dados
nos registradores executada a chamada da rotina UnidadeDectHazard. Essa funo
implementa o funcionamento da unidade para detectao de hazards de dados e de
controle, por meio de testes com os valores dos sinais de controle e endereos de
registradores utilizados em cada instruo, informaes essas contidas nos registradores
de estgio do pipeline. Quando possvel tratar o hazard, a UnidadeDectHazard
efetua a chamada da rotina de adiantamento (forwarding).
Forwarding: funo que, conforme solicitao passada por parmetro pela unidade
de deteco de hazard, retorna o valor a ser adiantado para um registrador que ir
utilizar essa informao, no disponvel ainda pela instruo anterior, no estgio
seguinte.
Conforme mencionado anteriormente, no possvel executar essas funcionalidades
em paralelo. No entanto, para simular a progresso dos estgios conforme a entrada e
sada de instrues no pipeline, foi implementada a rotina ExecutaInstrucoesPipe. Esse
procedimento disparado assim que o arquivo contendo as instrues do programa
inteiramente processado. Nesse instante, a lista Registradores do Pipeline que contm
a seqncia de armazenamentos dos registradores do pipeline est completa. A partir
dessa lista, a rotina ExecutaInstrucoesPipe simula a execuo da entrada das instrues
por ciclo, o que resulta, aps o pipeline estar cheio, em cinco instrues sendo
executadas em paralelo. Como resultado, o simulador apresenta a progresso de estgios

25

na lista Estgios do Pipeline. Os estgios so simbolizados conforme sigla informada

acima, entre parnteses, para descrio dos estgios do pipeline. Quando a unidade de
deteco de hazard verificar que no possvel efetuar adiantamentos, a instruo NO
(No Operante) ser informada para o(s) estgio(s) at que a informao do estgio
anterior esteja disponvel para o estgio que no est operante.
A interface alterada com a incluso das novas listas para o simulador com pipeline
pode ser visualizada na figura 7.0.

Figura 7.0 Simulador Com Pipeline.

Clculo do CPI
possvel comparar o CPI do simulador sem pipeline com esse simulador em que o
recurso est implementado. Ao executar o programa exemplo no simulador sem pipeline
o tempo o CPI resultou em 3,97826086956522.
Executando o programa exemplo no simulador com pipeline esse valor foi reduzido
para 1,17857142857143.
Para contabilizar o nmero de ciclos gastos no programa executado, a contagem
passou a ser realizada ao final da rotina ExecutaInstrucoesPipe. Para tanto, o nmero
26

de estgios na ltima linha da lista de Estgios do Pipeline contado, e esse valor

dividido pelo total de instrues executadas. O resultado informado no campo CPI.
Analisando os valores obtidos possvel notar que a diferena entre os CPIs est
elevada, se considerarmos o nmero de instrues executadas no programa exemplo.
Mas vlido lembrar que para uma representao precisa dos CPIs seria necessrio um
clock no sistema, o que no possvel implementar (limitao da linguagem utilizada
para o simulador). Essa rotina foi implementada, com base nas rotinas que simulariam
os ciclos, apenas para dar noo da diferena entre processadores com tcnicas
diferentes para execuo de instrues.

Sinais de Controle
Para gerenciar as informaes sobre as unidades utilizadas durante a execuo de
uma instruo, bem como a ao executada, se haver leitura ou escrita no banco de
dados ou registradores, por exemplo, foi implementada a unidade de controle
representada pela rotina AtualizaSinaisControle. O princpio de funcionamento dessa
rotina consiste em inicializar os sinais de controle para gerenciamento de hazard, leitura
e escrita de dados em registradores ou endereos de memria. A tabela 1.0 mostra a
configurao de sinais passada para a unidade de controle conforme o estgio do
pipeline e instruo executada.
Tabela 1.0 - Contedo dos registradores do pipeline.

Registrador
do Pipeline

Instruo

Contedo (Sinais nos registradores)

IDEX

Geral

RegDest1+RegDest2

mov memreg
mov regreg
mov imedreg
mov memacum
mov add
loop

reg1vazio+reg2+rw=1(escreve)+rm='0'
reg1+reg2+rw=1(escreve)+rm=' '(inoperante)
reg1vazio+reg2+rw=1(escreve)+rm=' '(inoperante)
reg1vazio+reg2+rw=1(escreve)+rm='0'
reg1+reg2+rw=1(escreve)+rm=' '(inoperante)
reg1vazio+reg2+rw=1+rm=' '(inoperante)

Geral

RegDestEM+RWmem+RWReg+ DvC;

mov memreg
mov regreg
mov imedreg
mov memacum
mov add
loop

reg2+rw=1(escreve)+rm='0'+'0'(sem desvio)
reg2+rw=1(escreve)+rm=' '(inoperante)+ '0'(sem desvio)
reg2+rw=1(escreve)+rm=' '(inoperante)+'0'(sem desvio)
reg2+rw=1(escreve)+rm='0'+'0'(sem desvio)
reg2+rw=1(escreve)+rm=' '(inoperante)+ '0'(sem desvio)
reg2+rw=1+rm=' '(inoperante)+ '1'(com desvio)

Geral

RegDestMW+RW+ MemULaReg;

mov memreg
mov regreg
mov imedreg
mov memacum
mov add
loop

reg2+rw
reg2+rw
reg2+rw
reg2+rw
reg2+rw
reg2+rw

EXMEM

MEMWB

=
=
=
=
=
=

1(escreve)+rm='0'
1(escreve)+rm=' '(inoperante)
1(escreve)+rm=' '(inoperante)
1(escreve)+rm='0'
1(escreve)+rm=' '(inoperante)
1+rm=' '(inoperante)

27

Abaixo sero especificados os sinais utilizados pela unidade de controle, com

respectiva ordenao de preenchimento e nmero de posies ocupadas (caracteres) por
cada sinal:
SinaisIFID: um vetor contendo o conjunto de posies que representam os
registradores origem (RegDest1 3 posies) e destino (RegDest2 3 posies) da
instruo, armazenados em ordem da esquerda para a direita.
SinaisIFID[RegDest1+RegDest2]
SinaisIDEX: do estgio ID em diante faz necessrio controlar as aes que a
instruo, j identificada ir executar na seqncia do pipeline. Para tanto, esse vetor
contm os sinais em seqncia, da esquerda para a direita, que identificam o registrador
origem (RegDestIE 3 posies), registrador destinto (RegDestIE2 3 posies), sinal
de que comanda a leitura/escrita no banco de registradores - RWReg (0 - Ler/1
Escrever; 1 posio) e por fim, o registrador que comanda leitura/escrita na memria RwMem(0 - Ler/1 Escreve; 1 posio).
SinaisIDEX[RegDestIE+RegDestIE2+RWReg+RwMem]
SinaisEXMEM: vetor composto pelos sinais de registrador destinto (RegDestEM 3
posies), controle se executa desvio condicional (0 sem desvio/ 1 com desvio, 1
posio), sinal de que comanda a leitura/escrita no banco de registradores - RWReg (0 Ler/1 Escrever; 1 posio) e o registrador que comanda leitura/escrita na memria RwMem(0 - Ler/1 Escreve; 1 posio).
SinaisEXMEM[RegDestEM+DvC+RWmem+RWReg]
SinaisMEMWB: vetor composto dos sinais de registrador destinto (RegDestMW 3
posies), de controle para verificar se o dado fornecido a partir da sada da ULA ou
da memria de dados - MemULaReg (0 Dado da memria/1 Dado da ULA 1
posio) e o sinal de que comanda se escrita no banco de registradores ou na memria
- RW(0 Escreve na memria/ 1 - Escreve no banco de registradores).
SinaisMEMWB:= RegDestMW+MemULaReg+RW;

28

Concluso
Com o projeto dos simuladores da arquitetura do processador x8086 podemos
adquirir um conhecimento mais amplo sobre seu funcionamento o que implica numa
maior facilidade de desenvolv-lo em uma linguagem que atenda as necessidades de
simultaneidade para implementao da arquitetura, principalmente com o uso da tcnica
de implementao Pipeline. No projeto dos simuladores no foi implementada uma
arquitetura completa, mas apenas as suas unidades bsicas e necessrias para a execuo
do subconjunto de instrues definido. No entanto, foi o suficiente para que
consegussemos identificar as principais diferenas, vantagens e desvantagens, entre
arquiteturas que implementam e que no implementam a tcnica de pipeline.
Para a segunda parte do trabalho, com implementao em linguagem VHDL, sero
necessrias modificaes, pois o cdigo ser adaptado de uma execuo no paralela
para uma execuo paralela. Isso implica, entre outras modificaes, em alterar a forma
de representao das unidades da arquitetura, pois no simulador, foram utilizados
recursos prprios da linguagem Delphi para representar as estruturas fsicas da
arquitetura de forma simplificada. Para a nova implementao do projeto, que visa o
desenvolvimento em uma linguagem prpria para descrio de hardware, VHDL, temse a viso de que, os resultados sero mais satisfatrios do que a realizada em uma
linguagem mais limitada referente simulao de funcionamento de um hardware.

29

Referncias Bibliogrficas

http://www.ee.pucrs.br/~dbarros/d2005_1/Microproc/Grupo_5/t1microprocessadores.pdf
http://www.dee.ufcg.edu.br/~scaico/facisa/oac/8086-8088_(slides).pdf
http://pessoal.utfpr.edu.br/gustavo/asm8086.pdf
htttp://pessoal.utfpr.edu.br/gustavo/modos%20de%20enderecamento.doc
http://www.dee.ufcg.edu.br/~scaico/facisa/
http://infobase.2it.com.br/upload/y9ydu2mbh5_obclm_ee_cap3.pdf
http://www.ppgia.pucpr.br/~santin/cc/2007/1/arquitetura.html
http://www.ppgia.pucpr.br/~santin/cc/
Organizao e Projetos de Computadores: A Interface Hardware/Software John L.
Henessy, David A. Patterson, James R. Larus 2 Editora LTC, Rio de Janeiro, cap.6
Pipeline.

30