Descrio Geral

Voc dever implementar um emulador da microarquitetura MIC-1 e um montador para a

linguagem assembly MAC-1, executvel em MIC-1 atravs de traduo realizada pelo
microprograma microprog.rom disponibilizado.

PARTE 1 Emulador MIC-1

A microarquitetura MIC-1 uma arquitetura de microprocessador baseado em microprograma de

controle proposta por Tanembaum em seu livro Organizao Estruturada de Computadores (a partir
da quarta edio. O autor tambm prope em seu livro um microprograma que torna MIC-1 capaz
de executar um conjunto de instrues de uma mquina semelhante Mquina Virtual Java (JVM),
qual ele d o nome de MAC-1.

Na primeira parte do seu trabalho, voc deve implementar o emulador de MIC-1 seguindo sua
especificao detalhada no captulo 4 do livro (seo 4.1). Para testar seu emulador, considere os
seguintes arquivos:

- microprog.rom : microprograma de controle binrio que executa em MIC-1 qualquer arquivo

binrio executvel gerado a partir da montagem de programa escrito em linguagem assembly de
MAC-1. Tal microprograma est gravado como um array de 512 posies de 64 bits (unsigned
long int). Portanto, essa a especificao do seu armazenamento de controle

- prog.exe : programa binrio para executar em MAC-1. Como o microprograma de MIC-1 simula
MAC-1, MIC-1 capaz de executar tal programa quando carregado na memria principal.

- prog.asm : cdigo assembly do programa prog.exe.

Se o seu emulador estiver funcionando adequadamente, ao carregar microprog.rom no

armazenamento de controle (simulado como um array de unsigned long int) e prog.exe na
memria principal (simulada como um array de bytes), o programa deve ser executado
corretamente. Acompanhe o funcionamento estudando a lgica de prog.asm.
PARTE 2 Assembler MAC-1

A linguagem assembly de MAC-1 definida no captulo 4, seo 4.2. Voc dever implementar
um montador que gera o cdigo binrio (bytecode) de um programa escrito com tal conjunto de
instrues, seguindo cuidadosamente sua especificao. Assim, voc poder escrever um programa
em assembly MAC-1, montar e executar em seu emulador MIC-1.

As instrues MAC-1 (especificadas na tabela 4.11, pg.205 da sexta edio) fazem referncias a
endereos do armazenamento de controle que contm o primeiro microcdigo do microprograma
que implementa a respectiva instruo MAC-1. Estes so os bytes (ou seja, os endereos) de cada
instruo disponvel (bytes diferentes dos expostos pelo livro por convenincia de implementao):

Instruo Assembly MAC-1 byte

nop 0x01
iadd 0x02
isub 0x05
iand 0x08
ior 0x0B
dup 0x0E
pop 0x10
swap 0x13
bipush 0x19
iload 0x1C
istore 0x22
wide 0x28
ldc_w 0x32
iinc 0x36
goto 0x3C
iflt 0x43
ifeq 0x47
if_icmpeq 0x4B
invokevirtual 0x55
ireturn 0x6B

* Instrues em vermelho ainda no foram testadas. Logo, erros podem existir nos respectivos
trechos que as implementam no microprograma de controle. No aconselho testar seu montador
com programas assembly que utilizem tais instrues. Voc mesmo pode fazer o teste dessas outras
instrues quando tiver certeza que seu montador est funcionando corretamente.

Existe um trecho do microprograma de controle responsvel por fazer a inicializao de MIC-1,

colocando os valores adequados nos registradores que controlam a pilha teoricamente controlada
por MAC-1, isto CPP, LV, PC e SP. O primeiro microcdigo do trecho do microprograma que
realiza tal processo est no byte 0x73 do armazenamento de controle. Assim, todo arquivo
executvel de MAC-1 deve conter, antes do programa propriamente dito, um trecho de programa
padro para chamar essa inicializao, sendo o byte 1 contendo o valor 0x73 (endereo do trecho
de microprograma que faz a inicializao) e as palavras 1, 2, 3 e 4 (bytes 4 a 7, 8 a 11, 12 a 15 e 16
a 19, respectivamente) contendo os valores iniciais de CPP, PC, LV e SP. Os bytes do programa
propriamente dito comeariam, portanto, no byte 20. Em C, a escrita desse trecho de inicializao
na memria ficaria:

memory[1] = 0x73; //init

memory[4] = 0x0006; //(CPP inicia com o valor 0x0006 guardado na palavra 1 bytes 4 a 7.)

word tmp = 0x1001; //LV

memcpy(&(memory[8]), &tmp, 4); //(LV inicia com o valor de tmp guardado na palavra 2 bytes
8 a 11)

tmp = 0x0400; //PC

memcpy(&(memory[12]), &tmp, 4); //(PC inicia com o valor de tmp guardado na palavra 3 bytes
12 a 15)

tmp = 0x1001 + num_of_vars; //SP

//SP (Stack Pointer) o ponteiro para o topo da pilha.

//A base da pilha LV e ela j comea com algumas variveis empilhadas (dependendo do
programa).

//Cada varivel gasta uma palavra de memria. Por isso a soma de LV com num_of_vars.

memcpy(&(memory[16]), &tmp, 4); //(SP inicia com o valor de tmp guardado na palavra 4 bytes
16 a 19)

Perceba que, embora o programa a ser gravado pelo montador no arquivo comece no byte 20, no
momento de abrir e ser lido para a memria do emulador para ser executado, ele deve ser colocado
a partir do byte 0x0401, ou seja, a partir de PC+1 (o microprograma sempre comea incrementando
PC antes de puxar o endereo de microprograma da memria principal; pelo mesmo motivo a
instruo init fica no byte 1 e no no byte 0 da memria principal). O trecho de inicializao fica
nas posies originais normalmente.

Alm disso, antes da memria propriamente dita, o arquivo executvel gerado pelo montador
possui um valor Q de 4 bytes (um unsigned int) indicando o tamanho completo do programa a ser
carregado (inicializao + programa propriamente dito). Assim, se o programa propriamente dito
tem P bytes de tamanho, Q = (20 + P). Isso permite uma cpia em lote de toda uma sequncia de
bytes, evitando, na hora de abrir, de ter que copiar o arquivo em um lao byte a byte at eof.

Resumindo o formato do arquivo executvel:

Q (4 bytes) Inicializao (20 Programa (P bytes)
bytes)

Os 20 bytes de inicializao devem ficar nas 20 primeiras posies de memria do emulador. Os P

bytes do programa devem ser jogados para as P posies de memria a partir da posio indicada
pelo valor de PC determinado nos bytes 12 a 15 da inicializao (embora estejam em sequncia no
arquivo).

Como no existe instruo de declarao de variveis, uma primeira lida no cdigo assembly deve
ser feita para determinar quantas variveis diferentes existem. Seus endereos sero determinados
em sequncia a partir de LV e o microprograma j faz esse controle relativo. Assim, se as variveis
que aparecem so i, j e k, nessa ordem, seus endereos quando montadas sero 0x00, 0x01 e 0x02,
respectivamente. O microprograma faz o trabalho de somar esses valores a LV quando alguma
instruo de referncia a varivel chamado (istore ou iload).

* Caso tenha curiosidade em ver como feita a montagem do microprograma de controle, aqui est
o cdigo fonte do programa que gera o arquivo microprog.rom: microassembler.cpp .

PARTE 3 Programando para sua mquina

Crie outros pequenos programas em assembly MAC-1, monte com o seu assembler e execute com
o seu emulador de MIC-1.