Simulador do IAS escrito em linguagem de montagem ARM

Um simulador de um computador "hóspede" é um programa escrito para um computador "hospedeiro" capaz de ler, carregar e executar programas escritos para o computador "hóspede" sobre o "hospedeiro". O simulador pode ser considerado uma forma de máquina virtual.

O problema da simulação está na velocidade de execução dos programas do "hóspede". Dependendo da abordagem utilizada, o programa "hóspede" pode executar até 500 vezes menos instruções por segundo do que se estivesse executando em uma máquina real de mesmo poder computacional.

Neste trabalho, você irá praticar a implementação de um simulador de computador implementando um simulador do IAS escrito completamente em linguagem de montagem ARM.

Para ajudá-lo no início, o laço principal de seu simulador será fornecido. Você deverá implementar as funções que atendem às chamadas do laço principal. O simulador deve ler comandos do usuário e tomar uma ação em resposta ao comando. A tabela a seguir os apresenta.

Os comandos

Comando	Exemplo de Uso	Descrição
si (step instruction)	si	Executa uma instrução
sn # (step n instructions)	sn 7	Executa N instruções, onde N é um número decimal
c (continue)	c	Continua a execução até o fim
stw <end> <dado> (store word)	stw 008 1122334455	Armazena um dado na memória da máquina virtual IAS. Todos os números devem usar a notação hexadecimal.
ldw <end> (load word)	ldw 008	Carrega um dado da memória da máquina virtual IAS e a imprime na saída padrão. O número correspondente ao endereço deve usar a notação hexadecimal.
pr	pr	Imprime os registradores da máquina virtual IAS

Um comando sempre é finalizado por <newline> (apertar enter na entrada padrão). Uma linha de comando pode ser considerada reconhecida se as iniciais são iguais às iniciais de qualquer comando apresentado acima. Apenas os comandos acima devem ser esperados na entrada, isto é, mensagens de erro não serão avaliadas.

O simulador deve suspender a interpretação sempre que encontrar uma instrução não identificada e imprimir a mensagem:

Instrução à esquerda não identificada no endereço <end>

ou

Instrução à direita não identificada no endereço <end>

Em que <end> é um número hexadecimal que sempre terá 3 algarismos, mesmo quando houver casas à esquerda com o valor zero.

A finalização

O simulador deve encerrar a execução assim que a entrada padrão indicar fim de arquivo (EOF) - isto acontece quando o arquivo de entrada não possui mais comandos ou, se a entrada padrão estiver ligada a um teclado, quando se pressiona CTRL+D.

O formato de saída dos comandos

a) O formado de saída do comando ldw deve ser:

<end> : <dado>

Em que <end> é um número hexadecimal que sempre terá 3 algarismos, mesmo quando houve casas à esquerda com o valor zero. <dado> é um número hexadecimal que sempre terá 10 algarismos, da mesma forma.

b) O formato de saída do comando pr deve ser:

AC: 0x[10 dígitos hexadecimais]
MQ: 0x[10 dígitos hexadecimais]
      

Exemplo:

AC: 0x00A0B17810
MQ: 0x0000000006
      

Descrição das funções a serem implementadas

Conforme mencionado anteriormente, parte do código com o laço principal é fornecido. A tarefa deste código é aguardar um comando digitado pelo usuário e despachar a execução do comando para funções implementadas por você. As funções são:

• interp_instr: Os comandos step instruction, step N instructions e continue invocam o interpretador de instruções IAS, definido pela função interp_instr. O comando si invoca a função interp_instr uma vez, o comando sn invoca a função # vezes (ou até a função interp_instr retornar falso, o que acontecer primeiro). O comando c invoca a função interp_instr até ela retornar falso, que indica que a instrução a ser interpretada é uma instrução não identificada. Assim sendo, a função interp_instr interpreta a próxima instrução. Ela não toma argumentos como entrada e retorna falso se a próxima instrução a ser executada não for uma instrução válida.
• store_word: Grava uma palavra de 40 bits na memória do computador IAS. O endereço, de 0 a 1023 é fornecido no registrador R0 do ARM, e o dado é fornecido nos pares de registradores R2:R1, sendo que R1 contém os bytes menos significativos e R2 possui o byte mais significativo.
• load_word: Lê uma palavra de 40 bits da memória. O endereço, de 0 a 1023 é fornecido no registrador R0 do ARM. O dado é retornado nos pares de registradores R1:R0, sendo que R0 contém os bytes menos significativos e R1 possui o byte mais significativo.
• print_register: imprime os registradores AC e MQ na saída padrão. Não possui parâmetros de entrada ou saída.
• get_cmd: esta função lê da entrada padrão um comando do usuário e retorna em R0 o tipo do comando:

  Código	Comando
  0	Comando não identificado
  1	EOF (a entrada padrão atingiu fim de arquivo, não há mais comandos para ler)
  2	Erro ao tentar ler comando
  3	step instruction
  4	step n instructions
  5	continue
  6	load word
  7	store word
  8	print registers

A memória da máquina hóspede e sugestões

a) A memória do IAS será representada por um vetor com 1024 * 5 bytes com o rótulo ias_mem no arquivo ias-mem.s (a ser fornecido). Este arquivo deve conter apenas este vetor.

b) Sugestões:

1. Implemente a função ahtoi40 que converte números hexadecimais representados por uma cadeia de caracteres (ascii hexadecimal) para binários de 40 bits.
   Entrada: R0: apontador para cadeia de caracteres (terminada em 0)
   Saída: Número de 40 bits representado em R1:R0.
2. Implemente a função adtoi32 que converte números decimais representados por uma cadeia de caracteres (ascii decimal) para binários de 40 bits.
   Entrada: R0: apontador para cadeia de caracteres (terminada em 0)
   Saída: Número de 32 bits representado em R1:R0.
3. Implemente a função i40toah que converte um número binários de 40 bits para uma cadeia de caractéres na representação hexadecimal.
   Entrada: R0: apontador para um buffer com pelo menos 11 bytes (1 para cada dígito e um para o `\0`. R2:R1 com o valor de 40 bits.

Arquivos fornecidos

• t2-1s12.tar.bz2: pacote com os arquivos iniciais para o trabalho. O pacote pode ser descomprimido com o comando:

    tar xjvf t2-1s12.tar.bz2
  

O pacote contém um Makefile já pronto. Entretanto, esse Makefile produz um executável para rodar no simulador ARM. Caso você vá rodar diretamente na plataforma Linux-ARM do IC, você precisa compilar usando o compilador nativo da placa (chamando pelos comandos 'as', 'ld'). No momento de ligar, não use o sys.o fornecido nem use a flag -Ttext=0 do linker.