int main (int argc, char *argv[])
{
int PCnew = 0, IRnew, MDRnew, Anew, Bnew, ALUOUTnew;
// Registradores auxiliares usados para a escrita dentro de um ciclo.
// Guardam temporariamente o resultado durante um ciclo. Os resultados aqui armazenados estarao
// disponiveis para leitura no final do ciclo atual (para que o mesmo esteja disponivel apenas no
// incio do ciclo seguinte).
// Em um ciclo sempre e lido o conteudo de um registrador atualizado no ciclo anterior.
int PC = 0, IR=-1, MDR, A, B, ALUOUT;
// Registradores especiais usados para a leitura em um ciclo.
// Guardam os resultados que poderao ser utilizados ja neste ciclo, pois foram atualizados no final
// do ciclo anterior.
// Ex.: em um ciclo, o resultado da ULA e inserido inicialmente em ALUOUTnew. Apenas no final
// do ciclo esse conteudo podera ser atribuido para ALUOUT, para que o mesmo possa ser
// usado no ciclo seguinte.
// Em um ciclo sempre e lido o conteudo de um registrador atualizado no ciclo anterior.
int sc = 0; // Sinais de Controle
// cada bit determina um dos sinais de controle que saem da UC.
// A posicao de cada sinal dentro do int esta especificada no enunciado
char ula_op = 0; // Sinais de Controle de entrada para a ULA
// sao usados apenas os 4 bits menos significativos dos 8 disponiveis.
int nr_ciclos = 0; // contador do numero de ciclos executados
/*
As variaveis zero e overflow nao precisam definidas na main.
Serao argumentos de retorno da ula e devem ser definidas localmente nas
rotinas adequadas.
char zero, overflow; // Sinais de Controle de saida da UL: bit zero e bit para indicar overflow
*/
memoria[0] = 0x8c480000; // 1000 1100 01007 1000 0000 0000 0000 0000 lw $t0, 0($v0) 5
memoria[1] = 0x010c182a; // 0000 0001 0000 1100 0001 1000 0010 1010 slt $v1, $t0, $t4 4
memoria[2] = 0x106d0004; // 0001 0000 0110 1101 0000 0000 0000 0100 beq $v1, $t5, fim(4 palavras abaixo de PC+4) 3
memoria[3] = 0x01084020; // 0000 0001 0000 1000 0100 0000 0010 0000 add $t0, $t0, $t0 4
memoria[4] = 0xac480000; // 1010 1100 0100 1000 0000 0000 0000 0000 sw $t0, 0($v0) 4
memoria[5] = 0x004b1020; // 0000 0000 0100 1011 0001 0000 0010 0000 add $v0, $t3, $v0 4
memoria[6] = 0x08000000; // 0000 1000 0000 0000 0000 0000 0000 0000 j inicio (palavra 0) 3
memoria[7] = 0; // fim (criterio de parada do programa) (27*6)+(5+4+3)+1
memoria[8] = 0;
memoria[9] = 0;
// Dados
memoria[20] = 10;
memoria[21] = 12;
memoria[22] = 14;
memoria[23] = 16;
memoria[24] = 18;
memoria[25] = 20;
memoria[26] = -1;
reg[2] = 80; // $v0
reg[11] = 4; // $t3
reg[12] = 0; // $t4
reg[13] = 1; // $t5
while(loop){
// aqui comeca um novo ciclo
// abaixo estao as unidades funcionais que executarao em todos os ciclos
// os sinais de controle em sc impedirao/permitirao que a execucao seja, de fato, efetivada
UnidadeControle(IR, &sc);
Busca_Instrucao(sc, PC, ALUOUT, IR, A, B, &PCnew, &IRnew, &MDRnew);
Decodifica_BuscaRegistrador(sc, IR, PC, A, B, &Anew, &Bnew, &ALUOUTnew);
Execucao_CalcEnd_Desvio(sc, A, B, IR, PC, ALUOUT, &ALUOUTnew, &PCnew);
EscreveTipoR_AcessaMemoria(sc, B, IR, ALUOUT, PC, &MDRnew, &IRnew);
EscreveRefMem(sc, IR, MDR, ALUOUT);
// contador que determina quantos ciclos foram executados
nr_ciclos++;
// atualizando os registradores temporarios necessarios ao proximo ciclo.
PC = PCnew;
IR = IRnew;
MDR = MDRnew;
A = Anew;
B = Bnew;
ALUOUT = ALUOUTnew;
// aqui termina um ciclo
} // fim do while(loop)
// impressao da memoria para verificar se a implementacao esta correta
{
int ii;
for (ii = 20; ii < 27; ii++) {
printf("memoria[%d]=%d \n", ii, memoria[ii]);
}
printf("Nr de ciclos executados =%d \n", nr_ciclos);
}
exit(0);
}
int main (int argc, char *argv[])
{
int PCnew = 0, IRnew, MDRnew, Anew, Bnew, ALUOUTnew;
int PC = 0, IR=-1, MDR, A, B, ALUOUT;
short int sc = 0;
int nr_ciclos = 0;
// ## fat(n) iterativo
memoria[0] = 0x8db00000; // 1000 1101 1011 0000 0000 0000 0000 0000 lw $s0, 0($t5) # carrega n da memoria
memoria[1] = 0x11300005; // 0001 0001 0011 0000 0000 0000 0000 0101 loop: beq $t1, $s0, fim # se der a cond. sai do loop
memoria[2] = 0x01025020; // 0000 0001 0000 0010 0101 0000 0010 0000 add $t2, $t0, $v0 # t2 = t0 + v0)
memoria[3] = 0x00404025; // 0000 0000 0100 0000 0100 0000 0010 0101 or $t0, $v0, $zero # t0 = v0
memoria[4] = 0x01431024; // 0000 0001 0100 0011 0001 0000 0010 0100 and $v0, $t2, $v1 # v0 = t2
memoria[5] = 0x012b4820; // 0000 0001 0010 1011 0100 1000 0010 0000 add $t1, $t1, $t3 # t1 = t1 + 1
memoria[6] = 0x08000001; // 0000 1000 0000 0000 0000 0000 0000 0001 j loop (palavra 1) # volta pro loop
memoria[7] = 0xad820000; // 1010 1101 1000 0010 0000 0000 0000 0000 fim: sw $v0, 0($t4) # salva o resultado na memoria
memoria[8] = 0; // criterio de parada do programa ciclos: 1+5+(22*(n-1))+3+4+1
memoria[9] = 0;
// Dados
memoria[20] = 10; // Fibonacci que se deseja calcular
// memoria[21] ira receber o resultado
reg[0] = 0; // $zero
reg[2] = 0; // $v0
reg[3] = -1; // $v1
reg[8] = 1; // $t0
reg[9] = 1; // $t1
reg[11] = 1; // $t3
reg[12] = 84; // $t4
reg[13] = 80; // $t5
while(loop)
{
// aqui comeca um novo ciclo
// abaixo estao as unidades funcionais que executarao em todos os ciclos
// os sinais de controle em sc impedirao/permitirao que a execucao seja, de fato, efetivada
UnidadeControle(IR, &sc);
Busca_Instrucao(sc, PC, ALUOUT, IR, &PCnew, &IRnew, &MDRnew);
Decodifica_BuscaRegistrador(sc, IR, PC, A, B, &Anew, &Bnew, &ALUOUTnew);
Execucao_CalcEnd_Desvio(sc, A, B, IR, PC, ALUOUT, &ALUOUTnew, &PCnew);
EscreveTipoR_AcessaMemoria(sc, B, IR, ALUOUT, PC, &MDRnew, &IRnew);
EscreveRefMem(sc, IR, MDR, ALUOUT);
// contador que determina quantos ciclos foram executados
nr_ciclos++;
// atualizando os registradores temporarios necessarios ao proximo ciclo.
PC = PCnew;
IR = IRnew;
MDR = MDRnew;
A = Anew;
B = Bnew;
ALUOUT = ALUOUTnew;
// aqui termina um ciclo
} // fim do while(loop)
// impressao da memoria para verificar se a implementacao esta correta
{
int ii;
for (ii = 20; ii < 22; ii++) {
printf("memoria[%d]=%ld \n", ii, memoria[ii]);
}
printf("Nr de ciclos executados =%d \n", nr_ciclos);
}
exit(0);
} // fim de main
