Este trabalho consiste na criação de um simulador funcional onde cada instrução executada demora quatro ciclos para completar. Estes ciclos são denominados: IF, ID, EX/MEM e WB.

1. Simulador Funcional
Johnnatan Messias P. Afonso 1
, Jeferson Lopes Dias Moreli2
1
Departamento de Computac¸˜ao - Instituto de Ciˆencias Exatas e Biol´ogicas
Universidade Federal de Ouro Preto (UFOP) CEP: 35400-000 – Ouro Preto – MG – Brasil
johnnatan20@gmail.com, jefersonvni@hotmail.com
Resumo. Este trabalho consiste na criac¸˜ao de um simulador funcional onde
cada instruc¸˜ao executada demora quatro ciclos para completar. Estes ciclos
s˜ao denominados: IF, ID, EX/MEM e WB.
• IF (instruction fetch): a pr´oxima instruc¸˜ao a ser executada ´e buscada
na mem´oria e armazenada no registrador de instruc¸˜oes (IR);
• ID (instruction decode): a instruc¸˜ao sendo executada ´e decodificada e
os operandos s˜ao buscados no banco de registradores;
• EX/MEM (execute and memory): a instruc¸˜ao ´e executada e as condic¸˜oes
dos resultados s˜ao ”setados” (condition codes) para operac¸˜oes de ALU.
Loads, stores, o c´alculo do enderec¸o efetivo e a resoluc¸˜ao de branches
s˜ao feitos tamb´em nesse ciclo;
• WB (write back): os resultados s˜ao escritos no banco de registradores.
Considere que o termino do load acontece neste passo.
O processador tem 8 registradores de uso geral de 16 bits de largura. Considere
as letras A, B,C, ..., H. A mem´oria ´e divida em dois vetores. Um contem os
dados, o outro o c´odigo de instruc¸˜oes de acesso `a mem´oria que salvam e buscam
os dados na mem´oria de dados (memDados)
Uma descric¸˜ao funcional divide o processador nos blocos que existir˜ao em uma
implementac¸˜ao real. Portanto, o processador dever´a conter quatro rotinas prin-
cipais, uma para cada etapa do ciclo a ser executado em cada instruc¸˜ao.
Instruc¸˜oes
Figure 1. Instruc¸ ˜oes
Considere que em LABEL se encontra o n´umero linha da mem´oria de c´odigo.

2. 1. Decis˜oes de implementac¸˜ao
Para a implementac¸˜ao desse trabalho foram tomadas v´arias decis˜oes para obter maior
clareza do c´odigo como, por exemplo, a func¸˜ao posicao. Atrav´es dessa func¸˜ao obtemos
a posic¸˜ao do vetor do banco de registradores que queremos acessar. Ainda, na estrutura
TInstucao utilizamos uma flag para que possamos saber em qual registrador armazenar
o resultado de sa´ıda. Os Define’s no arquivo STDAFX.h facilitou a implementac¸˜ao
do trabalho, uma vez que os label’s ficaram mais pr´oximos do objetivo. Com relac¸˜ao
`a alocac¸˜ao da mem´oria de c´odigo fizemos em O(n). Na sec¸˜ao 7.6 isto ´e explicado e
ilustrado.
2. Tutorial de como usar o simulador
Para este simulador deve-se criar um arquivo instrucao.txt contendo as instruc¸˜oes a
serem executadas pelo programa, vale lembrar que o simulador cont´em 8 registradores
e 8 posic¸˜oes na mem´oria de dados. Ap´os o termino das instruc¸˜oes o usu´ario dever´a in-
cluir a instruc¸˜ao HALT para que o simulador encerre a execuc¸˜ao.
Caso haja algum erro nas etapas das instruc¸˜oes o usu´ario ser´a alertado com uma
mensagem na tela.
O resultado ser´a gerado e impresso na tela do usu´ario e ainda gravado no arquivo
saida.txt.
Todas as instruc¸˜oes que o simulador executa est´a na Figura 1.
Requisitor: Como esse simulador foi desenvolvido no Microsoft Visual Studio
2010 Ultimate pode ser que o usu´ario tenha que ter o .NetFramework − 4 para executar
o programa.
Para exemplo de entrada de instruc¸˜ao vide Figura 2
Figure 2. Exemplo de Entrada de Instruc¸ ˜oes
3. Desenho esquem´atico da implementac¸˜ao
Para esse simulador vide datapath na figura 3

3. Figure 3. Datapath
4. Estruturas utilizadas para representac¸˜ao do hardware
• Mem´oria: para a representac¸˜ao das mem´orias de c´odigo e dados utilizamos a es-
trutura TMem. Vide Figura 4

4. Figure 4. Representac¸ ˜ao da Mem´oria
• Processador: a representac¸˜ao do processador utilizamos a estrutura TInstrucao.
Vide Figura 5
Figure 5. Representac¸ ˜ao do Processador
5. Descric¸˜ao dos m´odulos utilizados
S˜ao eles:
• Banco de Registradores: Representado com um vetor de inteiro com 8 posic¸˜oes,
isto ´e, registradores de A,B,...H.
• opCode: Necess´ario para saber qual o tipo da instruc¸˜ao a ser eexecutada, ex.:
SOMA, SUB, CARR, ARMA, etc.
• flag: Vari´avel utilizada para saber a posic¸˜ao registrador principal ou da mem´oria de
dados, ou seja, em qual registrador ou mem´oria de dados o dado ser´a armazenado.

5. • offSet: Utilizada para as instruc¸˜oes ARMA e SALV, no c´alculo do enderec¸o da
mem´oria de dados.
Vide Figura 6
Figure 6. M´odulos
6. Testes
Os testes gerados teve como base a identificac¸˜ao de erro que cada func¸˜ao poderia gerar.
• SOMA: Vide Figuras 9, 10
• SUB: Vide Figuras 9, 10
• SLT: Vide Figuras 7, 8
• CARR: Vide Figuras 7, 8
• SALV: Vide Figuras 7, 8
• DSIG: Vide Figuras 7, 8
• SALT: Vide Figuras 7, 8, 10
• ARMA: Vide Figuras 7, 8, 9, 10
• HALT: Vide Figuras 7, 8, 9, 10
• Outros Testes: Para a realizac¸˜ao de testes mais complexos criamos um conjunto
de instruc¸˜oes que utiliza as func¸˜oes acima:
Figure 7. Teste 1

6. Figure 8. Teste 2
Figure 9. Teste 3

7. Figure 10. Teste 4
Testes de programas fornecidos na especificac¸˜ao do trabalho:
• Teste a: Teste=2*aux Figura 11
Figure 11. Teste a

8. • Teste b: while(i==0) i++ Figura 12
Figure 12. Teste b
• Teste c: if(j¡0) m=j-i Figura 13
Figure 13. Teste c

9. • Teste d: O programa de busca compara em SLT o elemento do registrador H com
o elemento do registrador F, verificando se o conte´udo de F ´e menor que o de H,
caso isso seja verdade, o registrador A recebe 0, para uma futura comparac¸˜ao em
DSIG, com o registrador G que esta com o valor 1, como essa comparac¸˜ao n˜ao ´e
verdadeira, ele executa SALV que salva o valor de F, na memDados no enderec¸o
(OFFSet, que nesse caso ´e 0, + G). Figura 14
Figure 14. Teste d
7. Listagem do c´odigo fonte do simulador
Vide abaixo o c´odigo fonte do programa bem como um resumo de cada func¸˜ao:
7.1. STDAFX.h
Todas as bibliotecas e os DEFINE utilizados para a confecc¸˜ao do trabalho encontram-se
no arquivo STDAFX.h
# include <s t d i o . h>
# include <t c h a r . h>
# include ” TInstrucao . h”
5 # include <s t d l i b . h>
# include <s t r i n g . h>
# define l i n h a 100
# define coluna 30
10
# define TRUE 1
# define FALSE 0
# define IF 0
15 # define ID 1
# define EX 2
# define WB 3
# define FIM 4
20 # define opSOMA 0

10. # define opSUB 1
# define opSLT 2
# define opCARR 3
# define opSALV 4
25 # define opDSIG 5
# define opSALT 6
# define opARMA 7
# define opHALT 8
30 # define SAIR −2
# define posA 0
# define posB 1
# define posC 2
35 # define posD 3
# define posE 4
# define posF 5
# define posG 6
# define posH 7
40
# define TipoR 0
# define TipoIncon 1
# define TipoCond 2
# define TipoLW 3
45 # define TipoSW 4
# define TipoHALT 5
Listing 1. STDAFX.h
7.2. Assinaturas e Estrutura
Para este trabalho pr´atico utilizei duas estruturas:
• TInstrucao que contem as vari´aveis opCode das instruc¸˜oes, o registrador Reg[8],
offSet e uma flag para saber em qual registrador dever´a ser armazenada o dado.
• TMem: Estrutura da mem´oria do simulador, cont´em a Mem´oria de Dados
memDados e a Mem´oria de C´odigo memCod.
No c´odigo 2 as estruturas e as assinaturas das func¸˜oes:
# include ” s t d a f x . h”
typedef s t r u c t {
5 i n t opCode ;
i n t o f f S e t ;
i n t Reg [ 8 ] ;
i n t f l a g ;
10 } T I n s t r u c a o ;
typedef s t r u c t {
i n t ∗ memDados ;
char ∗∗ memCod ;
15 }TMem;

11. i n t posicao ( char∗ tok ) ;
i n t startMem (TMem∗ mem) ;
20
void s t a r t V a r i a v e i s ( T I n s t r u c a o ∗ i n s t ) ;
i n t geraMemCod (TMem∗ mem) ;
25 void b u s c a I n s t r u c a o ( char ∗∗ memCod , char∗ RI , i n t ∗ PC) ;
i n t d e c o d i f i c a I n s t r u c a o ( T I n s t r u c a o ∗ i n s t , char∗ RI , i n t ∗ temp ) ;
i n t e x e c u t a I n s t r u c a o ( i n t ∗ temp , i n t ∗ opCode , i n t ∗ s a i d a ) ;
30
i n t f i n a l I n s t r u c a o ( T I n s t r u c a o ∗ i n s t , i n t ∗ saida , i n t ∗ PC , i n t ∗ memDados
) ;
void imprimir ( i n t ∗ Reg , i n t ∗ memDados , i n t ∗ aux , char∗ RI , FILE∗ arqS ) ;
Listing 2. TInstrucao.h
7.3. Func¸˜ao Posicao
Essa func¸˜ao ´e respons´avel por retornar o valor em inteiro da posic¸˜ao de um registrador.
Obs.: Recebe um caractere e retorna a posic¸˜ao. Ex.: Para acessar o registrador A a posic¸˜ao
do vetor de registradores a ser acessada ser´a Reg[posic¸˜ao(’A’)] .
i n t posicao ( char∗ tok ) {
i n t pos ;
switch (∗ tok ) {
5 case ’A ’ :
pos = posA ;
break ;
case ’B ’ :
pos = posB ;
10 break ;
case ’C’ :
pos = posC ;
break ;
case ’D’ :
15 pos = posD ;
break ;
case ’E ’ :
pos = posE ;
break ;
20 case ’F ’ :
pos = posF ;
break ;
case ’G’ :
pos = posG ;
25 break ;
case ’H’ :
pos = posH ;
break ;
}

12. 30 return pos ;
}
Listing 3. Func¸ ˜ao Posicao
7.4. Func¸˜ao startMem
Func¸˜ao respons´avel por alocar a estrutura de mem´oria.
Obs.: Para melhorar, mesmo que pouco, o desempenho do c´odigo aloquei a mem-
Cod com ordem de complexidade O (n)
i n t startMem (TMem∗ mem) {
i n t i ;
/ / n de l i n h a s
mem−>memCod = ( char ∗∗) c a l l o c ( linha , s i z e o f ( char ∗) ) ;
5
i f (mem−>memCod == NULL) {
p r i n t f ( ”Erro ao alocar a memCodn” ) ;
return FALSE ;
}
10 / / n l i n h a s ∗ n colunas
mem−>memCod[ 0 ] = ( char ∗) c a l l o c ( l i n h a ∗ coluna , s i z e o f ( char ) ) ;
i f (mem−>memCod[ 0 ] == NULL) {
p r i n t f ( ”Erro ao alocar a memCodn” ) ;
15 return FALSE ;
}
/ / Redireciona os p o n t e i r o s
for ( i =1; i<l i n h a ; i ++){
mem−>memCod[ i ] = &(mem−>memCod [ 0 ] [ i ∗ coluna ] ) ;
20 }
mem−>memDados = ( i n t ∗) c a l l o c (8 , s i z e o f ( i n t ) ) ;
i f (mem−>memDados == NULL) {
25 p r i n t f ( ”Erro ao alocar a memDadosn” ) ;
return FALSE ;
}
return TRUE;
}
Listing 4. Func¸ ˜ao startMem
A figura 15 ilustra como os ponteiros da memCod foram organizados:

13. Figure 15. Alocac¸ ˜ao Matriz
7.5. Func¸˜ao startVariaveis
Respons´avel por inicializar as vari´aveis da estrutura TInstrucao
void s t a r t V a r i a v e i s ( T I n s t r u c a o ∗ i n s t ) {
i n t i ;
i n s t −>o f f S e t = −1;
i n s t −>opCode = −1;
5 for ( i =0; i <8; i ++)
i n s t −>Reg [ i ] = 0;
i n s t −>f l a g = −1;
}
Listing 5. Func¸ ˜ao startVariaveis
7.6. Func¸˜ao geraMemCod
Esta func¸˜ao inicializa a memCod, armazenando em cada posic¸˜ao uma instruc¸˜ao obtida
atrav´es da leitura do arquivo instrucao.txt
i n t geraMemCod (TMem∗ mem) {
FILE ∗ arqE = fopen ( ” i n s t r u c a o . t x t ” ,”r” ) ;
char ∗ tok , ∗ buf ;
i n t tam = 0;
5 buf = ( char ∗) malloc (31∗ s i z e o f ( char ) ) ;
i f ( arqE == NULL) {
p r i n t f ( ”Erro ao a b r i r o arquivo de entrada n” ) ;
return FALSE ;
}
10 e l s e {
i f ( ! startMem (mem) ) {
p r i n t f ( ”Erro ao i n i c i a r a memn” ) ;

14. return FALSE ;
15 }
while ( ! f e o f ( arqE ) ) {
buf = f g e t s ( buf , BUFSIZ , arqE ) ;
i f ( buf == NULL)
20 continue ;
s t r c p y (mem−>memCod[ tam ++] , buf ) ;
}
}
f r e e ( buf ) ;
25 f c l o s e ( arqE ) ;
return tam ;
}
Listing 6. Func¸ ˜ao geraMemCod
7.7. Func¸˜ao buscaInstrucao
Busca a pr´oxima instruc¸˜ao, incrementando o PC em uma unidade.
void b u s c a I n s t r u c a o ( char ∗∗ memCod , char∗ RI , i n t ∗ PC) {
s t r c p y ( RI , memCod[ ( ∗ PC) ] ) ;
(∗PC) ++;
}
Listing 7. Func¸ ˜ao buscaInstrucao
7.8. Func¸˜ao decodificaInstrucao
Uma das principais func¸˜ao deste projeto ´e a func¸˜ao de decodificac¸˜ao, que identifica a
instruc¸˜ao executada, buscando os respectivos operandos no banco de registradores.
Vide c´odigo 8:
i n t d e c o d i f i c a I n s t r u c a o ( T I n s t r u c a o ∗ i n s t , char∗ RI , i n t ∗ temp ) {
char∗ tok , ∗RIAux ;
i n t tipo , ∗aux , i ;
RIAux = ( char ∗) malloc ( coluna ∗ s i z e o f ( char ) ) ;
5 s t r c p y ( RIAux , RI ) ;
i n s t −>opCode = −1;
i n s t −>f l a g = −1;
tok = s t r t o k ( RIAux , ” ” ) ;
i f ( strcmp ( tok , ”SOMA” ) ==0){
10 i n s t −>opCode = opSOMA;
t i p o = TipoR ;
}
e l s e i f ( strcmp ( tok , ”SUB” ) ==0){
i n s t −>opCode = opSUB ;
15 t i p o = TipoR ;
}
e l s e i f ( strcmp ( tok , ”SLT” ) ==0){
i n s t −>opCode = opSLT ;
t i p o = TipoR ;
20 }
e l s e i f ( strcmp ( tok , ”CARR” ) ==0){
i n s t −>opCode = opCARR;

15. t i p o = TipoLW ;
}
25 e l s e i f ( strcmp ( tok , ”SALV” ) ==0){
i n s t −>opCode = opSALV ;
t i p o = TipoSW ;
}
e l s e i f ( strcmp ( tok , ”DSIG” ) ==0){
30 i n s t −>opCode = opDSIG ;
t i p o = TipoCond ;
}
e l s e i f ( strcmp ( tok , ”SALT” ) ==0){
i n s t −>opCode = opSALT ;
35 t i p o = TipoIncon ;
}
e l s e i f ( strcmp ( tok , ”ARMA” ) ==0){
i n s t −>opCode = opARMA;
t i p o = TipoLW ;
40 }
e l s e i f ( s t r s t r ( tok , ”HALT” ) ) {
i n s t −>opCode = opHALT ;
t i p o = TipoHALT ;
}
45 e l s e {
p r i n t f ( ”Erro : opCode nao encontrado nn” ) ;
return FALSE ;
}
switch ( t i p o ) {
50 case TipoR :
{
tok = s t r t o k (NULL, ” ,” ) ;
i n s t −>f l a g = posicao (& tok [ 0 ] ) ; / / R1
tok = s t r t o k (NULL, ” ,” ) ;
55 temp [ 0 ] = i n s t −>Reg [ posicao (& tok [ 0 ] ) ] ; / / R2
tok = s t r t o k (NULL, ” ,” ) ;
temp [ 1 ] = i n s t −>Reg [ posicao (& tok [ 0 ] ) ] ; / / R3
break ;
}
60 case TipoIncon :
{
tok = s t r t o k (NULL, ” ,” ) ;
temp [ 0 ] = a t o i ( tok ) ; / / LABEL
break ;
65 }
case TipoCond :
{
tok = s t r t o k (NULL, ” ,” ) ;
temp [ 0 ] = i n s t −>Reg [ posicao (& tok [ 0 ] ) ] ; / / R1
70 tok = s t r t o k (NULL, ” ,” ) ;
temp [ 1 ] = i n s t −>Reg [ posicao (& tok [ 0 ] ) ] ; / / R2
tok = s t r t o k (NULL, ” ,” ) ;
temp [ 2 ] = a t o i ( tok ) ; / / LABEL
break ;
75 }
case TipoLW :
{
i f ( i n s t −>opCode == opARMA) {

16. tok = s t r t o k (NULL, ” ,” ) ;
80 i n s t −>f l a g = posicao (& tok [ 0 ] ) ; / / R1
tok = s t r t o k (NULL, ” ,” ) ;
temp [ 0 ] = a t o i ( tok ) ; / /NUMBER
}
e l s e {
85 / / CARR
tok = s t r t o k (NULL, ” ,” ) ;
i n s t −>f l a g = posicao (& tok [ 0 ] ) ; / / R1
tok = s t r t o k (NULL, ” ( ” ) ;
temp [ 0 ] = a t o i ( tok ) ; / / OFFSET
90 tok = s t r t o k (NULL, ” ) ” ) ;
temp [ 1 ] = i n s t −>Reg [ posicao (& tok [ 0 ] ) ] ; / / R2
}
break ;
}
95 case TipoSW :
{
/ / memDados[OFFSET + R2] = R1
tok = s t r t o k (NULL, ” ,” ) ;
i n s t −>f l a g = posicao (& tok [ 0 ] ) ; / / Posic¸ ˜ao do R1
100 tok = s t r t o k (NULL, ” ( ” ) ;
temp [ 0 ] = a t o i ( tok ) ; / / OFFSET
tok = s t r t o k (NULL, ” ) ” ) ;
temp [ 1 ] = i n s t −>Reg [ posicao (& tok [ 0 ] ) ] ; / / R2
break ;
105 }
case TipoHALT :
{
temp [ 0 ] = SAIR ;
break ;
110 }
default :
p r i n t f ( ”Erro na d e c o d i f i c a c a o n” ) ;
return FALSE ;
break ;
115 }
f r e e ( RIAux ) ;
return TRUE;
}
Listing 8. Func¸ ˜ao decodificaInstrucao
7.9. Func¸˜ao executaInstrucao
Essa func¸˜ao recebe as vari´aveis tempor´arias e o opCode e executa a instruc¸˜ao, retornando
o resultado na vari´avel sa´ıda.
i n t e x e c u t a I n s t r u c a o ( i n t ∗ temp , i n t ∗ opCode , i n t ∗ s a i d a ) {
∗ s a i d a = −1;
switch (∗ opCode ) {
case opSOMA:
5 {
∗ s a i d a = temp [ 0 ] + temp [ 1 ] ;
break ;
}

17. case opSUB :
10 {
∗ s a i d a = temp [ 0 ] − temp [ 1 ] ;
break ;
}
case opSLT :
15 {
i f ( temp [0] < temp [ 1 ] )
∗ s a i d a = 0;
e l s e
∗ s a i d a = 1;
20 break ;
}
case opCARR:
{
∗ s a i d a = temp [ 0 ] + temp [ 1 ] ;
25 break ;
}
case opSALV :
{
∗ s a i d a = temp [ 0 ] + temp [ 1 ] ;
30 break ;
}
case opDSIG :
{
i f ( temp [ 0 ] == temp [ 1 ] )
35 ∗ s a i d a = temp [ 2 ] ;
e l s e
∗ s a i d a = −1;
break ;
}
40 case opSALT :
{
∗ s a i d a = temp [ 0 ] ;
break ;
}
45 case opARMA:
{
∗ s a i d a = temp [ 0 ] ;
break ;
}
50 case opHALT :
{
∗ s a i d a = temp [ 0 ] ; / / −2 = s a i r do programa
break ;
}
55 default :
{
p r i n t f ( ”Erro ao Executar n” ) ;
return FALSE ;
}
60 }
return TRUE;
}
Listing 9. Func¸ ˜ao executaInstrucao

18. 7.10. Func¸˜ao finalInstrucao
Ap´os obter a pr´oxima instruc¸˜ao, identific´a-la e execut´a-la, nos resta escrever no banco de
registradores o resultado obtido das etapas anteriores.
i n t f i n a l I n s t r u c a o ( T I n s t r u c a o ∗ i n s t , i n t ∗ saida , i n t ∗ PC , i n t ∗ memDados
) {
switch ( i n s t −>opCode ) {
case opSOMA:
5 {
i n s t −>Reg [ i n s t −>f l a g ] = ∗ s a i d a ;
break ;
}
case opSUB :
10 {
i n s t −>Reg [ i n s t −>f l a g ] = ∗ s a i d a ;
break ;
}
case opSLT :
15 {
i n s t −>Reg [ i n s t −>f l a g ] = ∗ s a i d a ;
break ;
}
case opDSIG :
20 {
i f (∗ s a i d a != −1)
∗PC = ∗ s a i d a ;
break ;
}
25 case opARMA:
{
i n s t −>Reg [ i n s t −>f l a g ] = ∗ s a i d a ;
break ;
}
30 case opSALT :
{
∗PC = ∗ s a i d a ;
break ;
}
35 case opSALV :
{
memDados[∗ s a i d a ] = i n s t −>Reg [ i n s t −>f l a g ] ; / / memDados[OFFSET + R2
] = R1
break ;
}
40 case opCARR:
{
i n s t −>Reg [ i n s t −>f l a g ] = memDados[∗ s a i d a ] ; / / R1 = memDados[OFFSET
+ R2]
break ;
}
45 case opHALT :
{
return FALSE ;
}
}

19. 50 return TRUE;
}
Listing 10. Func¸ ˜ao finalInstrucao
7.11. Func¸˜ao imprimir
A func¸˜ao imprimir imprime na tela e salva no arquivo.txt os status de cada etapa do
simulador.
void imprimir ( i n t ∗ Reg , i n t ∗ memDados , i n t ∗ aux , char∗ RI , FILE∗ arqS ) {
i n t i ;
char∗ tok , ∗RIAux ;
RIAux = ( char ∗) malloc ( coluna ∗ s i z e o f ( char ) ) ;
5 s t r c p y ( RIAux , RI ) ;
tok = s t r t o k ( RIAux , ” ” ) ;
switch ( aux [ 0 ] ) {
case IF :
p r i n t f ( ” Ciclo IFnn” ) ;
10 p r i n t f ( ”REGISTRADORES Flags nn” ) ;
p r i n t f ( ”A= %dn” , Reg [ posA ] ) ;
p r i n t f ( ”B= %dn” , Reg [ posB ] ) ;
p r i n t f ( ”C= %dn” , Reg [ posC ] ) ;
p r i n t f ( ”D= %dn” , Reg [ posD ] ) ;
15 p r i n t f ( ”E= %dn” , Reg [ posE ] ) ;
p r i n t f ( ”F= %dn” , Reg [ posF ] ) ;
p r i n t f ( ”G= %dn” , Reg [ posG ] ) ;
p r i n t f ( ”H= %dnn” , Reg [ posH ] ) ;
20 p r i n t f ( ”PC= %dn” , aux [ 1 ] ) ;
p r i n t f ( ”IR = %s n” , RI ) ;
p r i n t f ( ” I n s t r u c a o i d e n t i f i c a d a = ?n” ) ;
p r i n t f ( ” I n s t r u c a o executada = ?n” ) ;
25
p r i n t f ( ”−−−−−−−−−−−−−−−−−−nnn” ) ;
f p r i n t f ( arqS , ” Ciclo IFnn” ) ;
f p r i n t f ( arqS , ”REGISTRADORES Flags nn” ) ;
30 f p r i n t f ( arqS , ”A= %dn” , Reg [ posA ] ) ;
f p r i n t f ( arqS , ”B= %dn” , Reg [ posB ] ) ;
f p r i n t f ( arqS , ”C= %dn” , Reg [ posC ] ) ;
f p r i n t f ( arqS , ”D= %dn” , Reg [ posD ] ) ;
f p r i n t f ( arqS , ”E= %dn” , Reg [ posE ] ) ;
35 f p r i n t f ( arqS , ”F= %dn” , Reg [ posF ] ) ;
f p r i n t f ( arqS , ”G= %dn” , Reg [ posG ] ) ;
f p r i n t f ( arqS , ”H= %dnn” , Reg [ posH ] ) ;
f p r i n t f ( arqS , ”PC= %dn” , aux [ 1 ] ) ;
40
f p r i n t f ( arqS , ”IR = %s n” , RI ) ;
f p r i n t f ( arqS , ” I n s t r u c a o i d e n t i f i c a d a = ?n” ) ;
f p r i n t f ( arqS , ” I n s t r u c a o executada = ?n” ) ;
45 f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−nnn” ) ;
break ;

20. case ID :
p r i n t f ( ” Ciclo IDnn” ) ;
p r i n t f ( ”REGISTRADORES Flags nn” ) ;
50 p r i n t f ( ”A= %dn” , Reg [ posA ] ) ;
p r i n t f ( ”B= %dn” , Reg [ posB ] ) ;
p r i n t f ( ”C= %dn” , Reg [ posC ] ) ;
p r i n t f ( ”D= %dn” , Reg [ posD ] ) ;
p r i n t f ( ”E= %dn” , Reg [ posE ] ) ;
55 p r i n t f ( ”F= %dn” , Reg [ posF ] ) ;
p r i n t f ( ”G= %dn” , Reg [ posG ] ) ;
p r i n t f ( ”H= %dnn” , Reg [ posH ] ) ;
p r i n t f ( ”PC= %dn” , aux [ 1 ] ) ;
60
p r i n t f ( ”IR = %s n” , RI ) ;
p r i n t f ( ” I n s t r u c a o i d e n t i f i c a d a = %s n” , tok ) ;
p r i n t f ( ” I n s t r u c a o executada = ?n” ) ;
65 p r i n t f ( ”−−−−−−−−−−−−−−−−−−nnn” ) ;
f p r i n t f ( arqS , ” Ciclo IDnn” ) ;
f p r i n t f ( arqS , ”REGISTRADORES Flags nn” ) ;
f p r i n t f ( arqS , ”A= %dn” , Reg [ posA ] ) ;
70 f p r i n t f ( arqS , ”B= %dn” , Reg [ posB ] ) ;
f p r i n t f ( arqS , ”C= %dn” , Reg [ posC ] ) ;
f p r i n t f ( arqS , ”D= %dn” , Reg [ posD ] ) ;
f p r i n t f ( arqS , ”E= %dn” , Reg [ posE ] ) ;
f p r i n t f ( arqS , ”F= %dn” , Reg [ posF ] ) ;
75 f p r i n t f ( arqS , ”G= %dn” , Reg [ posG ] ) ;
f p r i n t f ( arqS , ”H= %dnn” , Reg [ posH ] ) ;
f p r i n t f ( arqS , ”PC= %dn” , aux [ 1 ] ) ;
80 f p r i n t f ( arqS , ”IR = %s n” , RI ) ;
f p r i n t f ( arqS , ” I n s t r u c a o i d e n t i f i c a d a = %s n” , tok ) ;
f p r i n t f ( arqS , ” I n s t r u c a o executada = ?n” ) ;
f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−nnn” ) ;
85 break ;
case EX:
p r i n t f ( ” Ciclo EXnn” ) ;
p r i n t f ( ”REGISTRADORES Flags nn” ) ;
p r i n t f ( ”A= %dn” , Reg [ posA ] ) ;
90 p r i n t f ( ”B= %dn” , Reg [ posB ] ) ;
p r i n t f ( ”C= %dn” , Reg [ posC ] ) ;
p r i n t f ( ”D= %dn” , Reg [ posD ] ) ;
p r i n t f ( ”E= %dn” , Reg [ posE ] ) ;
p r i n t f ( ”F= %dn” , Reg [ posF ] ) ;
95 p r i n t f ( ”G= %dn” , Reg [ posG ] ) ;
p r i n t f ( ”H= %dnn” , Reg [ posH ] ) ;
p r i n t f ( ”PC= %dn” , aux [ 1 ] ) ;
100 p r i n t f ( ”IR = %s n” , RI ) ;
p r i n t f ( ” I n s t r u c a o i d e n t i f i c a d a = %s n” , tok ) ;
p r i n t f ( ” I n s t r u c a o executada = %s n” , tok ) ;

21. p r i n t f ( ”−−−−−−−−−−−−−−−−−−nnn” ) ;
105
f p r i n t f ( arqS , ” Ciclo EXnn” ) ;
f p r i n t f ( arqS , ”REGISTRADORES Flags nn” ) ;
f p r i n t f ( arqS , ”A= %dn” , Reg [ posA ] ) ;
f p r i n t f ( arqS , ”B= %dn” , Reg [ posB ] ) ;
110 f p r i n t f ( arqS , ”C= %dn” , Reg [ posC ] ) ;
f p r i n t f ( arqS , ”D= %dn” , Reg [ posD ] ) ;
f p r i n t f ( arqS , ”E= %dn” , Reg [ posE ] ) ;
f p r i n t f ( arqS , ”F= %dn” , Reg [ posF ] ) ;
f p r i n t f ( arqS , ”G= %dn” , Reg [ posG ] ) ;
115 f p r i n t f ( arqS , ”H= %dnn” , Reg [ posH ] ) ;
f p r i n t f ( arqS , ”PC= %dn” , aux [ 1 ] ) ;
f p r i n t f ( arqS , ”IR = %s n” , RI ) ;
120 f p r i n t f ( arqS , ” I n s t r u c a o i d e n t i f i c a d a = %s n” , tok ) ;
f p r i n t f ( arqS , ” I n s t r u c a o executada = %s n” , tok ) ;
f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−nnn” ) ;
break ;
125 case WB:
p r i n t f ( ” Ciclo WBnn” ) ;
p r i n t f ( ”REGISTRADORES Flags nn” ) ;
p r i n t f ( ”A= %dn” , Reg [ posA ] ) ;
p r i n t f ( ”B= %dn” , Reg [ posB ] ) ;
130 p r i n t f ( ”C= %dn” , Reg [ posC ] ) ;
p r i n t f ( ”D= %dn” , Reg [ posD ] ) ;
p r i n t f ( ”E= %dn” , Reg [ posE ] ) ;
p r i n t f ( ”F= %dn” , Reg [ posF ] ) ;
p r i n t f ( ”G= %dn” , Reg [ posG ] ) ;
135 p r i n t f ( ”H= %dnn” , Reg [ posH ] ) ;
p r i n t f ( ”PC= %dn” , aux [ 1 ] ) ;
p r i n t f ( ”IR = %s” , RI ) ;
140 p r i n t f ( ” I n s t r u c a o i d e n t i f i c a d a = %s n” , tok ) ;
p r i n t f ( ” I n s t r u c a o executada = %s n” , tok ) ;
p r i n t f ( ”−−−−−−−−−−−−−−−−−−nnn” ) ;
145 f p r i n t f ( arqS , ” Ciclo WBnn” ) ;
f p r i n t f ( arqS , ”REGISTRADORES Flags nn” ) ;
f p r i n t f ( arqS , ”A= %dn” , Reg [ posA ] ) ;
f p r i n t f ( arqS , ”B= %dn” , Reg [ posB ] ) ;
f p r i n t f ( arqS , ”C= %dn” , Reg [ posC ] ) ;
150 f p r i n t f ( arqS , ”D= %dn” , Reg [ posD ] ) ;
f p r i n t f ( arqS , ”E= %dn” , Reg [ posE ] ) ;
f p r i n t f ( arqS , ”F= %dn” , Reg [ posF ] ) ;
f p r i n t f ( arqS , ”G= %dn” , Reg [ posG ] ) ;
f p r i n t f ( arqS , ”H= %dnn” , Reg [ posH ] ) ;
155
f p r i n t f ( arqS , ”PC= %dn” , aux [ 1 ] ) ;
f p r i n t f ( arqS , ”IR = %s” , RI ) ;

22. f p r i n t f ( arqS , ” I n s t r u c a o i d e n t i f i c a d a = %s n” , tok ) ;
160 f p r i n t f ( arqS , ” I n s t r u c a o executada = %s n” , tok ) ;
f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−nnn” ) ;
break ;
case FIM :
165 p r i n t f ( ”FINAL DA EXECUCAO DA INSTRUCAO . CONTEUDO DA MEMORIA
DE DADOS: nn” ) ;
f p r i n t f ( arqS , ”FINAL DA EXECUCAO DA INSTRUCAO . CONTEUDO DA MEMORIA
DE DADOS: nn” ) ;
for ( i =0; i <8; i ++){
p r i n t f ( ”MEMDADOS[%d]= %dn” , i , memDados [ i ] ) ;
f p r i n t f ( arqS , ”MEMDADOS[%d]= %dn” , i , memDados [ i ] ) ;
170 }
p r i n t f ( ”−−−−−−−−−−−−−−−−−−nnn” ) ;
f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−nnn” ) ;
break ;
}
175 f r e e ( RIAux ) ;
}
Listing 11. Func¸ ˜ao imprimir
7.12. Func¸˜ao main
Func¸˜ao principal respos´avel por chamar as demais func¸˜oes para a execuc¸˜ao do programa.
# include ” s t d a f x . h”
i n t tmain ( i n t argc , TCHAR∗ argv [ ] )
{
TMem mem;
5 T I n s t r u c a o i n s t ;
char∗ RI ;
i n t tam , PC = 0 , ∗aux , ∗Reg , ∗temp , saida , f i n a l i z a r ; / / aux [0] = f l a g
da i n s t r u c¸ ˜a o
/ / aux [1] = PC
temp = ( i n t ∗) malloc (3∗ s i z e o f ( i n t ) ) ;
10 FILE ∗ arqS ;
arqS = fopen ( ” saida . t x t ” ,”w” ) ;
aux = ( i n t ∗) c a l l o c (3 , s i z e o f ( i n t ) ) ;
Reg = ( i n t ∗) c a l l o c (8 , s i z e o f ( i n t ) ) ;
RI = ( char ∗) c a l l o c ( coluna , s i z e o f ( char ) ) ;
15 temp = ( i n t ∗) malloc (3∗ s i z e o f ( i n t ) ) ;
f i n a l i z a r = 1;
s t a r t V a r i a v e i s (& i n s t ) ;
tam = geraMemCod(&mem) ;
while ( 1 ) {
20 b u s c a I n s t r u c a o (mem. memCod , RI ,&PC) ;
aux [ 0 ] = IF ; aux [ 1 ] = PC ;
imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
i f ( d e c o d i f i c a I n s t r u c a o (& i n s t , RI , temp ) ) {
aux [ 0 ] = ID ;
25 imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
}
e l s e
break ;

23. i f ( e x e c u t a I n s t r u c a o ( temp ,& i n s t . opCode ,& s a i d a ) ) {
30 aux [ 0 ] = EX;
imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
}
e l s e
break ;
35 i f ( ! f i n a l I n s t r u c a o (& i n s t ,& saida ,&PC ,mem. memDados ) ) {
aux [ 0 ] = WB;
imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
aux [ 0 ] = FIM ;
imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
40 break ;
}
e l s e {
aux [ 0 ] = WB;
imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
45 aux [ 0 ] = FIM ;
imprimir ( i n s t . Reg ,mem. memDados , aux , RI , arqS ) ;
}
}
p r i n t f ( ”%dn” , tam ) ;
50 f r e e ( temp ) ;
f r e e ( aux ) ;
f r e e ( Reg ) ;
f r e e ( RI ) ;
f c l o s e ( arqS ) ;
55 system ( ”pause” ) ;
return 0;
}
Listing 12. Func¸ ˜ao main