Simulador Funcional

1.061 visualizações

Publicada em

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.

Publicada em: Educação
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
1.061
No SlideShare
0
A partir de incorporações
0
Número de incorporações
2
Ações
Compartilhamentos
0
Downloads
13
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Simulador Funcional

  1. 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. 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. 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. 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. 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. 6. Figure 8. Teste 2 Figure 9. Teste 3
  7. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

×