23
Simulador Funcional Johnnatan Messias P. Afonso 1 , Jeferson Lopes Dias Moreli 2 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 [email protected], [email protected] Resumo. Este trabalho consiste na criac ¸˜ ao de um simulador funcional onde cada instruc ¸˜ ao executada demora quatro ciclos para completar. Estes ciclos 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 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.

Simulador Funcional

Embed Size (px)

Citation preview

Page 1: Simulador Funcional

Simulador FuncionalJohnnatan Messias P. Afonso 1, Jeferson Lopes Dias Moreli2

1Departamento de Computacao - Instituto de Ciencias Exatas e BiologicasUniversidade Federal de Ouro Preto (UFOP) CEP: 35400-000 – Ouro Preto – MG – Brasil

[email protected], [email protected]

Resumo. Este trabalho consiste na criacao de um simulador funcional ondecada instrucao executada demora quatro ciclos para completar. Estes ciclossao denominados: IF, ID, EX/MEM e WB.

• IF (instruction fetch): a proxima instrucao a ser executada e buscadana memoria e armazenada no registrador de instrucoes (IR);• ID (instruction decode): a instrucao sendo executada e decodificada e

os operandos sao buscados no banco de registradores;• EX/MEM (execute and memory): a instrucao e executada e as condicoes

dos resultados sao ”setados” (condition codes) para operacoes de ALU.Loads, stores, o calculo do endereco efetivo e a resolucao de branchessao feitos tambem nesse ciclo;• WB (write back): os resultados sao 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. Considereas letras A, B,C, ..., H. A memoria e divida em dois vetores. Um contem osdados, o outro o codigo de instrucoes de acesso a memoria que salvam e buscamos dados na memoria de dados (memDados)Uma descricao funcional divide o processador nos blocos que existirao em umaimplementacao real. Portanto, o processador devera conter quatro rotinas prin-cipais, uma para cada etapa do ciclo a ser executado em cada instrucao.

Instrucoes

Figure 1. Instrucoes

Considere que em LABEL se encontra o numero linha da memoria de codigo.

Page 2: Simulador Funcional

1. Decisoes de implementacaoPara a implementacao desse trabalho foram tomadas varias decisoes para obter maiorclareza do codigo como, por exemplo, a funcao posicao. Atraves dessa funcao obtemosa posicao do vetor do banco de registradores que queremos acessar. Ainda, na estruturaTInstucao utilizamos uma flag para que possamos saber em qual registrador armazenaro resultado de saıda. Os Define’s no arquivo STDAFX.h facilitou a implementacaodo trabalho, uma vez que os label’s ficaram mais proximos do objetivo. Com relacaoa alocacao da memoria de codigo fizemos em O(n). Na secao 7.6 isto e explicado eilustrado.

2. Tutorial de como usar o simuladorPara este simulador deve-se criar um arquivo instrucao.txt contendo as instrucoes aserem executadas pelo programa, vale lembrar que o simulador contem 8 registradorese 8 posicoes na memoria de dados. Apos o termino das instrucoes o usuario devera in-cluir a instrucao HALT para que o simulador encerre a execucao.

Caso haja algum erro nas etapas das instrucoes o usuario sera alertado com umamensagem na tela.

O resultado sera gerado e impresso na tela do usuario e ainda gravado no arquivosaida.txt.

Todas as instrucoes que o simulador executa esta na Figura 1.

Requisitor: Como esse simulador foi desenvolvido no Microsoft Visual Studio2010 Ultimate pode ser que o usuario tenha que ter o .NetFramework− 4 para executaro programa.

Para exemplo de entrada de instrucao vide Figura 2

Figure 2. Exemplo de Entrada de Instrucoes

3. Desenho esquematico da implementacaoPara esse simulador vide datapath na figura 3

Page 3: Simulador Funcional

Figure 3. Datapath

4. Estruturas utilizadas para representacao do hardware• Memoria: para a representacao das memorias de codigo e dados utilizamos a es-

trutura TMem. Vide Figura 4

Page 4: Simulador Funcional

Figure 4. Representacao da Memoria

• Processador: a representacao do processador utilizamos a estrutura TInstrucao.Vide Figura 5

Figure 5. Representacao do Processador

5. Descricao dos modulos utilizadosSao eles:

• Banco de Registradores: Representado com um vetor de inteiro com 8 posicoes,isto e, registradores de A,B,...H.• opCode: Necessario para saber qual o tipo da instrucao a ser eexecutada, ex.:

SOMA, SUB, CARR, ARMA, etc.• flag: Variavel utilizada para saber a posicao registrador principal ou da memoria de

dados, ou seja, em qual registrador ou memoria de dados o dado sera armazenado.

Page 5: Simulador Funcional

• offSet: Utilizada para as instrucoes ARMA e SALV, no calculo do endereco damemoria de dados.

Vide Figura 6

Figure 6. Modulos

6. TestesOs testes gerados teve como base a identificacao de erro que cada funcao 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 realizacao de testes mais complexos criamos um conjunto

de instrucoes que utiliza as funcoes acima:

Figure 7. Teste 1

Page 6: Simulador Funcional

Figure 8. Teste 2

Figure 9. Teste 3

Page 7: Simulador Funcional

Figure 10. Teste 4

Testes de programas fornecidos na especificacao do trabalho:

• Teste a: Teste=2*aux Figura 11

Figure 11. Teste a

Page 8: Simulador Funcional

• 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

Page 9: Simulador Funcional

• Teste d: O programa de busca compara em SLT o elemento do registrador H como elemento do registrador F, verificando se o conteudo de F e menor que o de H,caso isso seja verdade, o registrador A recebe 0, para uma futura comparacao emDSIG, com o registrador G que esta com o valor 1, como essa comparacao nao everdadeira, ele executa SALV que salva o valor de F, na memDados no endereco(OFFSet, que nesse caso e 0, + G). Figura 14

Figure 14. Teste d

7. Listagem do codigo fonte do simuladorVide abaixo o codigo fonte do programa bem como um resumo de cada funcao:

7.1. STDAFX.h

Todas as bibliotecas e os DEFINE utilizados para a confeccao do trabalho encontram-seno arquivo STDAFX.h

# i n c l u d e <s t d i o . h># i n c l u d e < t c h a r . h># i n c l u d e ” T I n s t r u c a o . h”

5 # i n c l u d e < s t d l i b . h># i n c l u d e < s t r i n g . h>

# d e f i n e l i n h a 100# d e f i n e c o l u n a 30

10

# d e f i n e TRUE 1# d e f i n e FALSE 0

# d e f i n e IF 015 # d e f i n e ID 1

# d e f i n e EX 2# d e f i n e WB 3# d e f i n e FIM 4

20 # d e f i n e opSOMA 0

Page 10: Simulador Funcional

# d e f i n e opSUB 1# d e f i n e opSLT 2# d e f i n e opCARR 3# d e f i n e opSALV 4

25 # d e f i n e opDSIG 5# d e f i n e opSALT 6# d e f i n e opARMA 7# d e f i n e opHALT 8

30 # d e f i n e SAIR −2

# d e f i n e posA 0# d e f i n e posB 1# d e f i n e posC 2

35 # d e f i n e posD 3# d e f i n e posE 4# d e f i n e posF 5# d e f i n e posG 6# d e f i n e posH 7

40

# d e f i n e TipoR 0# d e f i n e Tipo Incon 1# d e f i n e TipoCond 2# d e f i n e TipoLW 3

45 # d e f i n e TipoSW 4# d e f i n e TipoHALT 5

Listing 1. STDAFX.h

7.2. Assinaturas e Estrutura

Para este trabalho pratico utilizei duas estruturas:

• TInstrucao que contem as variaveis opCode das instrucoes, o registrador Reg[8],offSet e uma flag para saber em qual registrador devera ser armazenada o dado.• TMem: Estrutura da memoria do simulador, contem a Memoria de DadosmemDados e a Memoria de Codigo memCod.

No codigo 2 as estruturas e as assinaturas das funcoes:

# i n c l u d e ” s t d a f x . h”

t y p e d e f 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 ;

t y p e d e f s t r u c t {i n t ∗ memDados ;char ∗∗ memCod ;

15 }TMem;

Page 11: Simulador Funcional

i n t p o s i c a o ( char∗ t o k ) ;

i n t s tar tMem (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 ∗ s a i d a , i n t ∗ PC , i n t ∗ memDados) ;

void i m p r i m i r ( i n t ∗ Reg , i n t ∗ memDados , i n t ∗ aux , char∗ RI , FILE∗ arqS ) ;

Listing 2. TInstrucao.h

7.3. Funcao Posicao

Essa funcao e responsavel por retornar o valor em inteiro da posicao de um registrador.Obs.: Recebe um caractere e retorna a posicao. Ex.: Para acessar o registrador A a posicaodo vetor de registradores a ser acessada sera Reg[posicao(’A’)] .

i n t p o s i c a o ( char∗ t o k ) {i n t pos ;sw i t ch (∗ t o k ) {

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 ;

}

Page 12: Simulador Funcional

30 re turn pos ;}

Listing 3. Funcao Posicao

7.4. Funcao startMem

Funcao responsavel por alocar a estrutura de memoria.

Obs.: Para melhorar, mesmo que pouco, o desempenho do codigo aloquei a mem-Cod com ordem de complexidade O (n)

i n t s tar tMem (TMem∗ mem) {i n t i ;/ / n de l i n h a s

mem−>memCod = ( char ∗∗ ) c a l l o c ( l i n h a , s i z e o f ( char ∗ ) ) ;5

i f (mem−>memCod == NULL) {p r i n t f ( ”Erro ao a l o c a r a memCod\n” ) ;re turn FALSE ;

}10 / / n l i n h a s ∗ n c o l u n a s

mem−>memCod [ 0 ] = ( char ∗ ) c a l l o c ( l i n h a ∗ co luna , s i z e o f ( char ) ) ;

i f (mem−>memCod [ 0 ] == NULL) {p r i n t f ( ”Erro ao a l o c a r a memCod\n” ) ;

15 re turn FALSE ;}/ / R e d i r e c i o n a os p o n t e i r o sf o r ( i =1 ; i<l i n h a ; i ++){

mem−>memCod[ i ] = &(mem−>memCod [ 0 ] [ i ∗ c o l u n a ] ) ;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 a l o c a r a memDados\n” ) ;

re turn FALSE ;}re turn TRUE;

}

Listing 4. Funcao startMem

A figura 15 ilustra como os ponteiros da memCod foram organizados:

Page 13: Simulador Funcional

Figure 15. Alocacao Matriz

7.5. Funcao startVariaveis

Responsavel por inicializar as variaveis 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 f o r ( i =0 ; i <8; i ++)i n s t−>Reg [ i ] = 0 ;

i n s t−>f l a g = −1;}

Listing 5. Funcao startVariaveis

7.6. Funcao geraMemCod

Esta funcao inicializa a memCod, armazenando em cada posicao uma instrucao obtidaatraves 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 ∗ ) ma l lo c (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 a r q u i v o de e n t r a d a \n” ) ;re turn FALSE ;

}10 e l s e {

i f ( ! s ta r tMem (mem) ) {p r i n t f ( ”Erro ao i n i c i a r a mem\n” ) ;

Page 14: Simulador Funcional

re turn FALSE ;15 }

whi le ( ! f e o f ( arqE ) ) {

buf = f g e t s ( buf , BUFSIZ , arqE ) ;i f ( buf == NULL)

20 c o n t in u e ;s t r c p y (mem−>memCod[ tam ++] , buf ) ;

}}f r e e ( buf ) ;

25 f c l o s e ( arqE ) ;re turn tam ;

}

Listing 6. Funcao geraMemCod

7.7. Funcao buscaInstrucao

Busca a proxima instrucao, 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. Funcao buscaInstrucao

7.8. Funcao decodificaInstrucao

Uma das principais funcao deste projeto e a funcao de decodificacao, que identifica ainstrucao executada, buscando os respectivos operandos no banco de registradores.

Vide codigo 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 t i p o , ∗aux , i ;RIAux = ( char ∗ ) ma l lo c ( c o l u n a ∗ 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;t o k = s t r t o k ( RIAux , ” ” ) ;i f ( s t r c mp ( tok , ”SOMA” ) ==0){

10 i n s t−>opCode = opSOMA;t i p o = TipoR ;

}e l s e i f ( s t r c mp ( tok , ”SUB” ) ==0){

i n s t−>opCode = opSUB ;15 t i p o = TipoR ;

}e l s e i f ( s t r c mp ( tok , ”SLT” ) ==0){

i n s t−>opCode = opSLT ;t i p o = TipoR ;

20 }e l s e i f ( s t r c mp ( tok , ”CARR” ) ==0){

i n s t−>opCode = opCARR ;

Page 15: Simulador Funcional

t i p o = TipoLW ;}

25 e l s e i f ( s t r c mp ( tok , ”SALV” ) ==0){i n s t−>opCode = opSALV ;t i p o = TipoSW ;

}e l s e i f ( s t r c mp ( tok , ”DSIG” ) ==0){

30 i n s t−>opCode = opDSIG ;t i p o = TipoCond ;

}e l s e i f ( s t r c mp ( tok , ”SALT” ) ==0){

i n s t−>opCode = opSALT ;35 t i p o = Tipo Incon ;

}e l s e i f ( s t r c mp ( 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 e n c o n t r a d o \n\n” ) ;re turn FALSE ;

}sw i t ch ( t i p o ) {

50 case TipoR :{

t o k = s t r t o k (NULL, ” , ” ) ;i n s t−>f l a g = p o s i c a o (& t o k [ 0 ] ) ; / / R1t o k = s t r t o k (NULL, ” , ” ) ;

55 temp [ 0 ] = i n s t−>Reg [ p o s i c a o (& t o k [ 0 ] ) ] ; / / R2t o k = s t r t o k (NULL, ” , ” ) ;temp [ 1 ] = i n s t−>Reg [ p o s i c a o (& t o k [ 0 ] ) ] ; / / R3

break ;}

60 case Tipo Incon :{

t o k = s t r t o k (NULL, ” , ” ) ;temp [ 0 ] = a t o i ( t o k ) ; / / LABELbreak ;

65 }case TipoCond :{

t o k = s t r t o k (NULL, ” , ” ) ;temp [ 0 ] = i n s t−>Reg [ p o s i c a o (& t o k [ 0 ] ) ] ; / / R1

70 t o k = s t r t o k (NULL, ” , ” ) ;temp [ 1 ] = i n s t−>Reg [ p o s i c a o (& t o k [ 0 ] ) ] ; / / R2t o k = s t r t o k (NULL, ” , ” ) ;temp [ 2 ] = a t o i ( t o k ) ; / / LABELbreak ;

75 }case TipoLW :{

i f ( i n s t−>opCode == opARMA) {

Page 16: Simulador Funcional

t o k = s t r t o k (NULL, ” , ” ) ;80 i n s t−>f l a g = p o s i c a o (& t o k [ 0 ] ) ; / / R1

t o k = s t r t o k (NULL, ” , ” ) ;temp [ 0 ] = a t o i ( t o k ) ; / / NUMBER

}e l s e {

85 / / CARRt o k = s t r t o k (NULL, ” , ” ) ;i n s t−>f l a g = p o s i c a o (& t o k [ 0 ] ) ; / / R1t o k = s t r t o k (NULL, ” ( ” ) ;temp [ 0 ] = a t o i ( t o k ) ; / / OFFSET

90 t o k = s t r t o k (NULL, ” ) ” ) ;temp [ 1 ] = i n s t−>Reg [ p o s i c a o (& t o k [ 0 ] ) ] ; / / R2

}break ;

}95 case TipoSW :

{/ / memDados [OFFSET + R2 ] = R1t o k = s t r t o k (NULL, ” , ” ) ;i n s t−>f l a g = p o s i c a o (& t o k [ 0 ] ) ; / / Pos i c a o do R1

100 t o k = s t r t o k (NULL, ” ( ” ) ;temp [ 0 ] = a t o i ( t o k ) ; / / OFFSETt o k = s t r t o k (NULL, ” ) ” ) ;temp [ 1 ] = i n s t−>Reg [ p o s i c a o (& t o k [ 0 ] ) ] ; / / R2break ;

105 }case TipoHALT :{

temp [ 0 ] = SAIR ;break ;

110 }d e f a u l t :

p r i n t f ( ”Erro na d e c o d i f i c a c a o \n” ) ;re turn FALSE ;break ;

115 }f r e e ( RIAux ) ;re turn TRUE;

}

Listing 8. Funcao decodificaInstrucao

7.9. Funcao executaInstrucao

Essa funcao recebe as variaveis temporarias e o opCode e executa a instrucao, retornandoo resultado na variavel 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;sw i t ch (∗ opCode ) {

case opSOMA:5 {

∗ s a i d a = temp [ 0 ] + temp [ 1 ] ;break ;

}

Page 17: Simulador Funcional

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 programabreak ;

}55 d e f a u l t :

{p r i n t f ( ”Erro ao E x e c u t a r \n” ) ;re turn FALSE ;

}60 }

re turn TRUE;}

Listing 9. Funcao executaInstrucao

Page 18: Simulador Funcional

7.10. Funcao finalInstrucaoApos obter a proxima instrucao, identifica-la e executa-la, nos resta escrever no banco deregistradores 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 ∗ s a i d a , i n t ∗ PC , i n t ∗ memDados) {

sw i t ch ( 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

] = R1break ;

}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 :

{re turn FALSE ;

}}

Page 19: Simulador Funcional

50 re turn TRUE;}

Listing 10. Funcao finalInstrucao

7.11. Funcao imprimir

A funcao imprimir imprime na tela e salva no arquivo.txt os status de cada etapa dosimulador.

void i m p r i m i r ( 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 ∗ ) ma l l oc ( c o l u n a ∗ s i z e o f ( char ) ) ;

5 s t r c p y ( RIAux , RI ) ;t o k = s t r t o k ( RIAux , ” ” ) ;sw i t ch ( aux [ 0 ] ) {

case IF :p r i n t f ( ” C i c l o IF\n\n” ) ;

10 p r i n t f ( ”REGISTRADORES Flags \n\n” ) ;p r i n t f ( ”A= %d\n” , Reg [ posA ] ) ;p r i n t f ( ”B= %d\n” , Reg [ posB ] ) ;p r i n t f ( ”C= %d\n” , Reg [ posC ] ) ;p r i n t f ( ”D= %d\n” , Reg [ posD ] ) ;

15 p r i n t f ( ”E= %d\n” , Reg [ posE ] ) ;p r i n t f ( ”F= %d\n” , Reg [ posF ] ) ;p r i n t f ( ”G= %d\n” , Reg [ posG ] ) ;p r i n t f ( ”H= %d\n\n” , Reg [ posH ] ) ;

20 p r i n t f ( ”PC= %d\n” , 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 e x e c u t a d a = ?\n” ) ;

25

p r i n t f ( ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;

f p r i n t f ( arqS , ” C i c l o IF\n\n” ) ;f p r i n t f ( arqS , ”REGISTRADORES Flags \n\n” ) ;

30 f p r i n t f ( arqS , ”A= %d\n” , Reg [ posA ] ) ;f p r i n t f ( arqS , ”B= %d\n” , Reg [ posB ] ) ;f p r i n t f ( arqS , ”C= %d\n” , Reg [ posC ] ) ;f p r i n t f ( arqS , ”D= %d\n” , Reg [ posD ] ) ;f p r i n t f ( arqS , ”E= %d\n” , Reg [ posE ] ) ;

35 f p r i n t f ( arqS , ”F= %d\n” , Reg [ posF ] ) ;f p r i n t f ( arqS , ”G= %d\n” , Reg [ posG ] ) ;f p r i n t f ( arqS , ”H= %d\n\n” , Reg [ posH ] ) ;

f p r i n t f ( arqS , ”PC= %d\n” , 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 e x e c u t a d a = ?\n” ) ;

45 f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;break ;

Page 20: Simulador Funcional

case ID :p r i n t f ( ” C i c l o ID\n\n” ) ;p r i n t f ( ”REGISTRADORES Flags \n\n” ) ;

50 p r i n t f ( ”A= %d\n” , Reg [ posA ] ) ;p r i n t f ( ”B= %d\n” , Reg [ posB ] ) ;p r i n t f ( ”C= %d\n” , Reg [ posC ] ) ;p r i n t f ( ”D= %d\n” , Reg [ posD ] ) ;p r i n t f ( ”E= %d\n” , Reg [ posE ] ) ;

55 p r i n t f ( ”F= %d\n” , Reg [ posF ] ) ;p r i n t f ( ”G= %d\n” , Reg [ posG ] ) ;p r i n t f ( ”H= %d\n\n” , Reg [ posH ] ) ;

p r i n t f ( ”PC= %d\n” , 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” , t o k ) ;p r i n t f ( ” I n s t r u c a o e x e c u t a d a = ?\n” ) ;

65 p r i n t f ( ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;

f p r i n t f ( arqS , ” C i c l o ID\n\n” ) ;f p r i n t f ( arqS , ”REGISTRADORES Flags \n\n” ) ;f p r i n t f ( arqS , ”A= %d\n” , Reg [ posA ] ) ;

70 f p r i n t f ( arqS , ”B= %d\n” , Reg [ posB ] ) ;f p r i n t f ( arqS , ”C= %d\n” , Reg [ posC ] ) ;f p r i n t f ( arqS , ”D= %d\n” , Reg [ posD ] ) ;f p r i n t f ( arqS , ”E= %d\n” , Reg [ posE ] ) ;f p r i n t f ( arqS , ”F= %d\n” , Reg [ posF ] ) ;

75 f p r i n t f ( arqS , ”G= %d\n” , Reg [ posG ] ) ;f p r i n t f ( arqS , ”H= %d\n\n” , Reg [ posH ] ) ;

f p r i n t f ( arqS , ”PC= %d\n” , 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” , t o k ) ;f p r i n t f ( arqS , ” I n s t r u c a o e x e c u t a d a = ?\n” ) ;

f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;85 break ;

case EX:p r i n t f ( ” C i c l o EX\n\n” ) ;p r i n t f ( ”REGISTRADORES Flags \n\n” ) ;p r i n t f ( ”A= %d\n” , Reg [ posA ] ) ;

90 p r i n t f ( ”B= %d\n” , Reg [ posB ] ) ;p r i n t f ( ”C= %d\n” , Reg [ posC ] ) ;p r i n t f ( ”D= %d\n” , Reg [ posD ] ) ;p r i n t f ( ”E= %d\n” , Reg [ posE ] ) ;p r i n t f ( ”F= %d\n” , Reg [ posF ] ) ;

95 p r i n t f ( ”G= %d\n” , Reg [ posG ] ) ;p r i n t f ( ”H= %d\n\n” , Reg [ posH ] ) ;

p r i n t f ( ”PC= %d\n” , 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” , t o k ) ;p r i n t f ( ” I n s t r u c a o e x e c u t a d a = %s \n” , t o k ) ;

Page 21: Simulador Funcional

p r i n t f ( ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;105

f p r i n t f ( arqS , ” C i c l o EX\n\n” ) ;f p r i n t f ( arqS , ”REGISTRADORES Flags \n\n” ) ;f p r i n t f ( arqS , ”A= %d\n” , Reg [ posA ] ) ;f p r i n t f ( arqS , ”B= %d\n” , Reg [ posB ] ) ;

110 f p r i n t f ( arqS , ”C= %d\n” , Reg [ posC ] ) ;f p r i n t f ( arqS , ”D= %d\n” , Reg [ posD ] ) ;f p r i n t f ( arqS , ”E= %d\n” , Reg [ posE ] ) ;f p r i n t f ( arqS , ”F= %d\n” , Reg [ posF ] ) ;f p r i n t f ( arqS , ”G= %d\n” , Reg [ posG ] ) ;

115 f p r i n t f ( arqS , ”H= %d\n\n” , Reg [ posH ] ) ;

f p r i n t f ( arqS , ”PC= %d\n” , 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” , t o k ) ;

f p r i n t f ( arqS , ” I n s t r u c a o e x e c u t a d a = %s \n” , t o k ) ;

f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;break ;

125 case WB:p r i n t f ( ” C i c l o WB\n\n” ) ;p r i n t f ( ”REGISTRADORES Flags \n\n” ) ;p r i n t f ( ”A= %d\n” , Reg [ posA ] ) ;p r i n t f ( ”B= %d\n” , Reg [ posB ] ) ;

130 p r i n t f ( ”C= %d\n” , Reg [ posC ] ) ;p r i n t f ( ”D= %d\n” , Reg [ posD ] ) ;p r i n t f ( ”E= %d\n” , Reg [ posE ] ) ;p r i n t f ( ”F= %d\n” , Reg [ posF ] ) ;p r i n t f ( ”G= %d\n” , Reg [ posG ] ) ;

135 p r i n t f ( ”H= %d\n\n” , Reg [ posH ] ) ;

p r i n t f ( ”PC= %d\n” , 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” , t o k ) ;

p r i n t f ( ” I n s t r u c a o e x e c u t a d a = %s \n” , t o k ) ;

p r i n t f ( ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;

145 f p r i n t f ( arqS , ” C i c l o WB\n\n” ) ;f p r i n t f ( arqS , ”REGISTRADORES Flags \n\n” ) ;f p r i n t f ( arqS , ”A= %d\n” , Reg [ posA ] ) ;f p r i n t f ( arqS , ”B= %d\n” , Reg [ posB ] ) ;f p r i n t f ( arqS , ”C= %d\n” , Reg [ posC ] ) ;

150 f p r i n t f ( arqS , ”D= %d\n” , Reg [ posD ] ) ;f p r i n t f ( arqS , ”E= %d\n” , Reg [ posE ] ) ;f p r i n t f ( arqS , ”F= %d\n” , Reg [ posF ] ) ;f p r i n t f ( arqS , ”G= %d\n” , Reg [ posG ] ) ;f p r i n t f ( arqS , ”H= %d\n\n” , Reg [ posH ] ) ;

155

f p r i n t f ( arqS , ”PC= %d\n” , aux [ 1 ] ) ;

f p r i n t f ( arqS , ”IR = %s ” , RI ) ;

Page 22: Simulador Funcional

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” , t o k ) ;160 f p r i n t f ( arqS , ” I n s t r u c a o e x e c u t a d a = %s \n” , t o k ) ;

f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;break ;

case FIM :165 p r i n t f ( ”FINAL DA EXECUCAO DA INSTRUCAO . CONTEUDO DA MEMORIA

DE DADOS:\ n\n” ) ;f p r i n t f ( arqS , ”FINAL DA EXECUCAO DA INSTRUCAO . CONTEUDO DA MEMORIA

DE DADOS:\ n\n” ) ;f o r ( i =0 ; i <8; i ++){

p r i n t f ( ”MEMDADOS[%d]= %d\n” , i , memDados [ i ] ) ;f p r i n t f ( arqS , ”MEMDADOS[%d]= %d\n” , i , memDados [ i ] ) ;

170 }p r i n t f ( ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;f p r i n t f ( arqS , ”−−−−−−−−−−−−−−−−−−\n\n\n” ) ;break ;

}175 f r e e ( RIAux ) ;}

Listing 11. Funcao imprimir

7.12. Funcao main

Funcao principal resposavel por chamar as demais funcoes para a execucao do programa.

# i n c l u d e ” s t d a f x . h”i n t t m a i n ( i n t argc , TCHAR∗ a rgv [ ] ){

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 , s a i d a , 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 ∗ ) ma l lo c (3∗ s i z e o f ( i n t ) ) ;10 FILE ∗ arqS ;

a rqS = fopen ( ” s a i d a . 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 ( co luna , s i z e o f ( char ) ) ;

15 temp = ( i n t ∗ ) ma l lo c (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) ;whi le ( 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 ;i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;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 i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;

}e l s e

break ;

Page 23: Simulador Funcional

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;

i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;}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 ,& s a i d a ,&PC ,mem. memDados ) ) {

aux [ 0 ] = WB;i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;aux [ 0 ] = FIM ;i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;

40 break ;}e l s e {

aux [ 0 ] = WB;i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;

45 aux [ 0 ] = FIM ;i m p r i m i r ( i n s t . Reg ,mem. memDados , aux , RI , a rqS ) ;

}}p r i n t f ( ”%d\n” , 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 ( a rqS ) ;

55 sys tem ( ” pause ” ) ;re turn 0 ;

}

Listing 12. Funcao main