O slideshow foi denunciado.
Utilizamos seu perfil e dados de atividades no LinkedIn para personalizar e exibir anúncios mais relevantes. Altere suas preferências de anúncios quando desejar.

Simulador Funcional

1.079 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
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

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

×