1. Macroarquitetura 2. Emulador do MIC-1 3. O Nível ISA: IJVM. Bibliografia. Teresina Pilhas 3.2. Conjunto de Instruções IJVM

Transcrição

1 Universidade Federal do Piauí Centro de Tecnologia Departamento de Engenharia Elétrica Macroarquitetura - Linguagem de Máquina - Prof. Marcos Zurita zurita@ufpi.edu.br Teresina Macroarquitetura 2. Emulador do MIC-1 3. O Nível ISA: IJVM 3.1. Pilhas 3.2. Conjunto de Instruções IJVM Bibliografia 2

2 1. Macroarquitetura 3 Notação das Microinstruções do MIC-1 Conforme visto anteriormente, cada microinstrução do MIC-1 é composta de 36 bits organizados em 6 campos: NEXT_ADDRESS JAM ULA C Mem B 9 bits 3 bits 8 bits 9 bits 3 bits A descrição de todo o microprograma armazenado na memória de controle pode ser feita diretamente em binário ou hexadecimal. Entretanto, é conveniente definir uma linguagem simbólica que permita a abstração de detalhes desnecessários, mantendo, ao mesmo, a capacidade de controle da máquina ciclo-a-ciclo. 4 bits 4

3 A Linguagem MAL MAL (Micro Assembly Language) Linguagem de montagem de microinstruções; Características: Sintaxe intuitiva; Abstração do endereço da próxima microinstrução; Através de rótulos em caso de desvio; Através de inferência automática se não houver desvio. Permite que uma atribuição ou operação incida em mais de um registrador no mesmo ciclo; Inferência automática do valor dos campos não explicitados na linha da instrução (valor 0 inferido). 5 Cada instrução MAL pode conter os seguintes campos: Fuba1: H=MDR >> 1; fetch; goto(mbr) //isto é um comentário 1. Rótulo (Label); 2. Atribuição e eventual operação; 3. Deslocamento; 4. Operação de acesso à memória; 5. Desvio; 6. Comentário. Uma instrução pode não conter nenhum campo. Neste caso a máquina gastará um ciclo sem fazer nada. Com exceção do Rótulo e do Deslocamento, todos os demais campos devem ser separados por ;. 6

4 Comentários Podem ser inseridos através de //, colocando como comentário tudo que estiver à sua direita na linha. Rótulos (Labels) MAR = 0; // isto aqui é um comentário Quando utilizado, deve ser o primeiro campo a ser escrito e deve ser separado dos demais campos por :. Um Rótulo pode conter qualquer caractere alfanumérico, exceto espaços em branco. Inicio: OPC = PC-1; // esta linha tem como rótulo Inicio H = MDR; // esta linha não possui nenhum rótulo Eita 1: H = TOS; // este rótulo é inválido pois possui // um espaço em branco 7 Atribuição e Eventual Operação Pode envolver qualquer registrador como operando ou destino, observando-se as características do MIC-1: MBR não pode ser destino de operação ou atribuição; MAR não pode ser operando, apenas destino. REGISTRADOR DESTINO FONTE OU OPERANDO CPP X X H X X LV X X MAR X MBR X MBRU X MDR X X OPC X X PC X X SP X X TOS X X 8

5 A tabela abaixo lista todas as operações e atribuições possíveis pela MAL do MIC-1: N OPERAÇÃO EXEMPLO 1 DEST = H TOS = H; 2 DEST = FONTE OPC = PC; 3 DEST = H LV = not(h); 4 DEST = FONTE SP = not(mdr); 5 DEST = H + FONTE CPP = H + TOS; 6 DEST = H + FONTE +1 CPP = H + TOS + 1; 7 DEST = H + 1 LV = H + 1; 8 DEST = FONTE + 1 PC = PC + 1; 9 DEST = FONTE - H MDR = TOS - H; 10 DEST = FONTE - 1 PC = OPC - 1; 11 DEST = -H H = -H; 12 DEST = H AND FONTE OPC = H AND MBRU; 13 DEST = H OR FONTE SP = H OR TOS; 14 DEST = 0 PC = 0; 15 DEST = 1 H = 1; 16 DEST = -1 MDR = -1; 9 Deve-se notar também que o Destino especificado na tabela anterior pode conter mais de um registrador. Ex.: H=OPC=TOS=CPP=LV=SP=PC = MDR + H + 1; A linguagem adotada suporta ainda a comutatividade de operandos nas operações de soma e lógica binária. Ex.: MDR = SP + H; // equivale a MDR = H + SP CPP = TOS + H + 1; // equivale a CPP = H + TOS + 1 LV = 1 + H; // equivale a LV = H + 1 H = MBR OR H; // equivale a H = H OR MBR TOS = MDR AND H; // equivale a TOS = H AND MDR Em todos os exemplos acima, a microinstrução gerada será a mesma do código equivalente, pois no MIC-1 o registrador H é sempre o operador esquerdo da ULA. 10

6 Por outro lado, algumas operações simples são ilegais nesta linguagem, devido à limitações impostas pela microarquitetura do MIC-1. Ex.: MDR = SP + MDR; // operação ilegal, pois exige a leitura // dos registradores SP e MDR via // barramento B no mesmo ciclo H = H MDR; // operação ilegal, pois a única fonte // possível para o subtraendo (valor a ser // subtraído) deve estar no registrador H Solução aos exemplos: H = SP; // copia o valor de SP para MDR MDR = H + MDR; // efetua a soma de MDR com a cópia de SP H = MDR - H; // efetua a subtração inversa H = -H; // desinverte o sinal gerando H = H - MDR 11 Deslocamento Quando empregados, devem vir após uma atribuição ou operação, sem o separador ;. Dois tipos de deslocamento são possíveis: Deslocamento de 8 bits à esquerda (<< 8); Deslocamento de 1 bit à direita (>> 1). Os deslocamentos possíveis estão listados na tabela abaixo. N DESLOCAMENTO EXEMPLO 1 DEST = OPERAÇÃO << 8; H = 1 << 8; 2 DEST = OPERAÇÃO >> 1; TOS = MBR + 1 >> 1; Deve-se salientar que por Operação entende-se qualquer uma das listadas na tabela do slide 9. 12

7 Desvio Três operações de desvio são possíveis: Desvio incondicional; Desvio condicional; Desvio multidirecional. Desvio Incondicional pode ser feito através da notação goto Rótulo. Por exemplo: Main1: PC = PC+1; // linha de rótulo Main1 H = MBR; // linha sem rótulo TOS = 0; goto Main1 // zera TOS e vai para Main1 13 Desvio Condicional - pode ser feito através da notação: if(x) goto L1; else goto L2 Onde X pode ser o registrador Z ou N, L1 e L2 dois labels pertencentes as 256 primeiras linhas de instrução. Por exemplo: H = 1 << 8; // faz H = 256 Denovo: H = H-1; if(z) goto Zerou; else goto Denovo Zerou: MDR = MDR+1; Como um desvio condicional baseia-se no valor de N ou Z, a linguagem exige que ela seja utilizada juntamente com uma atribuição ou operação. R1: if(n) goto R1; else goto R2 // este desvio é ilegal // pois não está associado a uma operação R2: H=H+1; // ou atribuição, como há nesta linha 14

8 Eventualmente, pode-se desejar testar um determinado registrador, sem se alterar seu conteúdo. Uma alternativa para isto seria fazê-lo passar pela ULA e armazena-lo de volta (auto-atribuição). Ex.: R1: MDR = MDR; if(z) goto R2; else goto R1 // testa MDR R2: TOS = TOS-1; Entretanto, para tornar isto mais visível, a MAL é capaz de aceitar atribuições diretas a N ou Z, gerando implicitamente uma auto-atribuição do registrador. R1: Z = MDR; if(z) goto R2; else goto R1 // testa MDR R2: TOS = TOS-1; A microinstrução gerada neste caso é exatamente igual a do exemplo anterior. 15 Desvio Multidirecional - é desvio cujo destino depende do conteúdo do registrador MBR. Pode ser feito através da notação: goto (MBR or valor_de_9_bits) Se o valor_de_9_bits for nulo, basta escrever: goto (MBR) bola7: PC = PC+1; // linha de rótulo bola7 H = MBR; // copia o opcode para H TOS = 0; goto(mbr) // zera TOS e executa o opcode Este é o tipo de desvio utilizado para se executar instruções cujo opcode foi buscado na memória. 16

9 Operação de Acesso à Memória Três operações de acesso à memória são possíveis: Leitura de um dado de 32 bits via MAR/MDR (rd); MAR = SP-1; rd // ajusta MAR e ordena leitura Escrita de um dado de 32 bits via MAR/MDR (wr); TOS = TOS+1; wr // ajusta TOS e ordena escrita Busca de um opcode de 8 bits via PC/MBR (fetch). PC = PC+1; fetch // ajusta PC e ordena busca A busca de um opcode pode ocorrer simultaneamente (mesmo ciclo) que uma leitura ou escrita na memória. PC = PC+1; fetch; wr // ajusta PC e ordena busca/escrita 17 Ao fazer uso de operações de acesso à memória, devese ter em mente a latência imposta por ela, isto é: 1. Operações de leitura e busca (rd/fetch) só atualizam seus respectivos registradores (MDR/MBR) no final do ciclo seguinte, ou seja: O resultado de uma leitura ou busca em memória só pode ser utilizado em atribuições ou operações 2 ciclos após ordenada a leitura ou busca. MAR = SP = SP-1; rd // ajusta MAR e SP e ordena leitura // aguarda a leitura do valor em MDR TOS = MDR; // copia o valor lido para TOS PC = PC+1; fetch; // ajusta PC e ordena busca/escrita LV = LV+1; // incrementa LV e aguarda a busca MDR = MBR; // copia o opcode lido para MDR 18

10 2. Outra consequência da observação feita em 1 é: MDR não pode ser modificado no ciclo seguinte a uma ordem de leitura pois a memória também irá escrever nele, gerando um conflito. MAR = SP; rd // ajusta MAR e ordena leitura MDR = H; // a memória também irá escrever em MDR neste // mesmo ciclo! O valor em MDR é indefinido. 3. Apesar da escrita do opcode buscado na memória só ocorrer no final do ciclo seguinte ao da ordem, o cálculo do novo MPC só será feito após essa escrita, ou seja: MBR pode ser utilizado em instruções de desvio no ciclo imediatamente seguinte ao da ordem de busca. PC = PC+1; fetch // ajusta PC e ordena busca goto(mbr) // o novo MBR já pode ser usado para desvio Operações de escrita (wr) só utilizam os registradores MAR e MDR no ciclo corrente, isto é: MAR e MDR podem ser modificados no ciclo seguinte a uma ordem de escrita sem penalidade na gravação do valor antigo na memória. MDR = H << 8; // ajusta MDR MAR = MBRU+H; wr // ajusta MAR e ordena escrita MDR = TOS; // altera MDR sem atrapalhar a escrita 20

11 2. Emulador do MIC-1 21 Emulador do MIC-1 emumic - desenvolvido por estudantes da UNICT (Università degli Studi di Catania), sob orientação do Prof. Franco Barbanera, na Itália. Características: Licença GPL; Feito em Java (roda na maior parte dos computadores); Emula completamente a microarquitetura do MIC-1; Capaz de executar as microinstruções subciclo-a-subciclo; Possui um micromontador MAL integrado, permitindo a escrita das microinstruções na linguagem MAL; Disponível em: /SIMULATORS/emuMIC/index.html 22

12 23 3. O Nível ISA: IJVM 24

13 Pilhas O Modelo de Memória do IJVM Conjunto de Instruções IJVM Compilação JAVA Pilhas 26

14 Pilhas Quase todas as linguagens de programação suportam o conceito de sub-rotinas, que por sua vez possuem suas próprias variáveis, as chamadas variáveis locais. Variáveis locais Variáveis visíveis apenas pela sub-rotina que as criou. São criadas no momento que sub-rotina é chamada e destruídas ao seu término, liberando a memória por elas ocupada. Variáveis globais São variáveis visíveis em todo o programa. Criadas na execução do programa e destruídas no seu encerramento. 27 Ex.: Variáveis globais e locais em C #include <stdio.h> #include "interface.h" // biblioteca externa int t_ref = 273; // variável global void print_temp() // sub-rotina { int t_kelvin; // variável local t_kelvin = leporta1() + t_ref; // t_ref é visível aqui printf("temperatura = %i Kelvin", t_kelvin); void main() // rotina principal { int j=0; // variável local while (1) { // laço infinito if (j==100) { print_temp(); j=0; else { j++ 28

15 Reservar um espaço na memória para variáveis globais não constitui, a princípio, um problema: Pode-se fazê-lo simplesmente fixando um endereço na memória para cada variável e referenciando-se tais endereços de qualquer ponto do programa para acessá-las Por outro lado, como proceder com as variáveis locais? A solução sugerida para variáveis globais não funciona pois uma sub-rotina pode chamar a si mesma (recursividade), o que sobrescreveria as varáveis da primeira execução. Ex.: void procura_obst(int v) { // sub-rotina int k; // variável local k = leporta2() + v; if (k > 127) { printf("obstáculo encontrado!"); else { procura_obst(k); // Recursão: a sub-rotina // chama a si mesma 29 A solução para a alocação de variáveis locais na memória é a adoção do conceito de pilha (stack). Pilha É uma área da memória reservada para o armazenamento de variáveis locais; Nela, variáveis são empilhadas, umas sobre as outras, de modo que o topo da SP pilha contém sempre as variáveis mais recentemente criadas; Sua implementação requer dois LV apontadores: 1 : Apontador para a base da pilha ( LV) 2 : Apontador para o topo da pilha ( SP) var_5 var_4 var_3 var_2 var_1 P I L H A 30

16 Neste conceito as variáveis locais não referenciadas por seu endereço absoluto na memória e sim por sua posição relativa à base da pilha (LV). Sempre que uma sub-rotina é chamada, o apontador da base da pilha (LV) é ajustado para apontar o endereço base das variáveis locais da sub-rotina corrente. Da mesma forma, o apontador de topo da pilha (SP) também deve ser ajustado para indicar o endereço absoluto da última variável local da sub-rotina corrente. No MIC-1, a quantidade de memória consumida pelas varáveis locais de uma sub-rotina pode ser calculada (após sua alocação) através da fórmula: Mem SUB 4SPLV 1 (Eq. 3.1) 31 Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 1. main1() é executada; 2. main1() chama a subrotina suba(); 32

17 Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 3. suba() cria as variáveis locais a1, a2 e a3; Admitindo que a pilha comece no endereço 100, e que cada variável ocupe 4 bytes, temos: LV = 100 (endereço absoluto); SP = 108 (endereço absoluto); a1 endereço relativo = 0; a2 endereço relativo = 4; a3 endereço relativo = 8. SP a3 108 a2 104 LV a1 100 Quadro de variáveis locais de suba() 33 Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 4. suba() chama subb(); 5. subb() cria as variáveis locais b1, b2, b3 e b4: LV = 112 (endereço absoluto); SP = 124 (endereço absoluto); b1 endereço relativo = 0; b4 endereço relativo = 12; SP b4 124 b3 120 b2 116 LV b1 112 SP a3 108 a2 104 LV a1 100 Quadro de variáveis locais de subb() 34

18 Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 6. subb() chama subc(); 7. subc() cria as variáveis locais c1 e c2: LV = 128; SP = 132. SP c2 132 LV c1 128 SP b4 124 b3 120 b2 116 LV b1 112 a3 108 a2 104 a Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 8. subc() termina, restaurando os valores anteriores de SP e LV, liberando a memória ocupada por c1 e c2: LV = 112; SP = 124. SP c2 132 LV c1 128 SP b4 124 b3 120 b2 116 LV b1 112 a3 108 a2 104 a

19 Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 9. subc() devolve a execução para subb(); 10. subb() termina, restaurando SP e LV, liberando a memória de b1, b2, b3 e b4: LV = 100; SP = 108. SP b4 124 b3 120 b2 116 LV b1 112 SP a3 108 a2 104 LV a Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 11. subb() devolve a execução para suba(); 12. suba() chama subd(); SP a3 108 a2 104 LV a

20 Ex.: Alocação de variáveis locais em C void subd() { long d[5]; void subc() { long c1, c2; // instruções... void subb() { long b1, b2, b3, b4; subc(); // instruções... void suba() { long a1, a2, a3; subb(); subd(); void main() { suba(); 13. subd() cria as variáveis locais d[0] à d[4]: LV = 112; SP = 128. As variáveis de subd() ocupam o mesmo espaço anteriormente ocupado pelas variáveis de subb() e parte das de subc(). SP d[4] 128 d[3] 124 d[2] 120 d[1] 116 LV d[0] 112 a3 108 a2 104 a Pilha de Operandos São regiões da pilha (ou mesmo pilhas dedicadas) voltadas ao armazenamento de operandos durante o cálculo de uma expressão aritmética Seu tamanho pode variar durante a operação. Ex.: Suponha que a sub-rotina suba(), antes de chamar subb(), precise calcular a1 = a2 + a3; Suponha que esta soma seja feita por uma instrução no nível ISA, chamada IADD que retira os dois últimos registros da pilha, soma-os e devolve o resultado para o topo da pilha. 40

21 A execução dessa linha de código (a1=a2+a3) pode ser resumida pelos seguintes passos: 1. O operando a2 é copiado para o topo da pilha; 2. O operando a3 é copiado para o topo da pilha; 3. A instrução IADD é chamada; 4. IADD retira os operandos da pilha e soma-os; 5. IADD coloca o resultado da soma no topo da pilha; 6. O resultado é movido para a1 e SP ajustado. IADD SP a2 112 a3 108 a2 104 LV a1 100 SP a3 116 a2 112 a3 108 a2 104 LV a1 100 SP a2+a3 112 a3 108 a2 104 LV a1 100 SP a3 108 a2 104 LV a2+a O Modelo de Memória do IJVM 42

22 Partes da Memória IJVM A Memória do IJVM é dividida em 4 partes: Área do Procedimento Quadro de Variáveis Locais Pilha de Operandos Pool de Constantes SP Pool de Constantes CPP Pilha 3 Operandos Correntes Quadro 3 Variáveis Locais Correntes Quadro 2 Variáveis Locais Quadro 1 Variáveis Locais LV Área do Procedimento (Método) PC 43 O Pool de Constantes Não pode ser escrita pelos programas IJVM; Contém constantes, strings e ponteiros para endereços de memória; O registrador CPP (Constant Pool Pointer) aponta para a primeira palavra do pool de constantes. O Quadro de Variáveis Locais No início guarda valores dos parâmetros (argumentos) do procedimento (método) chamado; O registrador LV (Local Vars) contém o endereço da primeira posição do quadro de variáveis locais. 44

23 A Pilha de Operandos Fica imediatamente acima do quadro de variáveis locais; Seu tamanho não pode ultrapassar um determinado limite pré-determinado pelo compilador JAVA; Registrador SP (Stack Pointer): Armazena o endereço do topo da pilha; Muda de valor durante a execução do procedimento. A Área do Procedimento Região de memória que armazena o programa; O registrador PC (Program Counter) aponta para o endereço da próxima instrução a ser buscada Conjunto de Instruções IJVM 46

24 O Conjunto de Instruções da IJVM Hexa Mnemônico Significado 0x10 BIPUSH byte Carregue um byte na pilha 0x59 DUP Copia a palavra do topo da pilha e passe-a para a pilha 0xA7 GOTO offset Desvio incondicional 0x60 IADD Retire duas palavras da pilha; carregue sua soma 0x7E IAND Retire duas palavras da pilha; carregue AND booleano 0x99 IFEQ offset Retire uma palavra da pilha e desvie se for zero 0x9B IFLT offset Retire uma palavra da pilha e desvie se for menor que zero 0x9F IF _ICMPEO offset Retire duas palavras da pilha e desvie se elas forem iguais 0x84 IINC varnum const Some uma constante a uma variável local 0x15 ILOAD varnum Coloque uma variável local no topo da pilha 0xB6 INVOKEVIRTUAL disp Chame uma sub-rotina (método) 0x80 IOR Retire duas palavras da pilha; carregue OR booleano 0xAC IRETURN Retorne da sub-rotina (método) com um valor inteiro 0x36 ISTORE varnum Retira a palavra da pilha e armazene-a numa variável local 0x64 ISUB Retire duas palavras da pilha; carregue sua diferença 0x13 LDC_W index Carregue constante do conjunto de constantes para a pilha 0x00 NOP Não faz nada 0x57 POP Retire a palavra do topo da pilha 0x5F SWAP Troca as duas palavras do topo da pilha uma pela outra 0xC4 WIDE Prefixo de instrução; a próxima instrução tem índice de 16 bits 47 Código de Máquina das Instruções IJVM As instruções IJVM implementadas no MIC-1 podem ocupar 8, 16, 24 ou 32 bits de espaço na memória. 8 bits OPCODE 8 bits 8 bits OPCODE ARG_1 8 bits 8 bits 8 bits OPCODE ARG_1 ARG_2 8 bits 8 bits 16 bits WIDE OPCODE ARGUMENTO 48

25 Instruções de 8 bits São instruções que não requerem argumentos ou que não possuem argumentos explícitos: DUP IADD ISUB IAND IOR IRETURN NOP POP SWAP WIDE* * Trata-se, na verdade, de um prefixo de instrução. 49 Instruções de 16 bits São instruções recebem um argumento explícito de 8 bits como parâmetro: BIPUSH IINC* ILOAD* ISTORE * Podem receber também argumentos de 16 bits, neste caso passam a ser instruções de 32 bits. 50

26 Instruções de 24 bits São instruções recebem um argumento explícito de 16 bits como parâmetro ou dois argumentos de 8 bits: GOTO IFEQ IFLT IF_ICMPEQ INVOKEVIRTUAL LDC_W 51 Instruções de 32 bits As instruções ILOAD e ISTORE, em suas versões de 16 bits, recebem como parâmetro variáveis locais cujo endereço relativo não ultrapassa 255, utilizando com isso apenas argumentos de 8 bits. Caso o endereço relativo da variável local seja superior a 255, é necessário um argumento de 16 bits como parâmetro. Naturalmente, a implementação das versões estendidas dessas instruções (com parâmetros de 16 bits) difere da implementação com parâmetros de 8 bits. Consequentemente, um novo microcódigo deverá ser criado para implementar as versões estendidas de ILOAD e ISTORE. 52

27 Isto pode ser obtido basicamente de 2 formas: 1. criando um novo opcode para cada versão estendida: limita o novo opcode a ocupar um dos espaços vazios entre as instruções nos primeiros 256 endereços da memória de controle; 2. criando uma instrução especial capaz de redirecionar o opcode seguinte para um endereço na parte alta da memória de controle, onde se encontra a implementação da versão estendida da instrução em questão. O mecanismo adotado pelo IJVM é a segunda solução. A instrução especial criada para esta finalidade é o prefixo WIDE, consumindo 8 bits. Os demais 24 bits ficam no opcode da instrução que se segue (8 bits) e no seu argumento (16 bits). 53 Implementação das Instruções IJVM em MAL Todas as instruções IJVM devem garantir em sua implementação a execução da instrução seguinte. Por essa razão, a instrução interna Main1 é chamada ao final da implementação de cada instrução IJVM: Main1 é responsável por 3 operações: Main1: PC=PC+1; fetch; goto(mbr) 1. Incremento do PC, fazendo com que ele aponte para o primeiro byte após o opcode que será executado; 2. Início da busca do próximo byte e armazenamento dele no MBR (que ocorrerá no final do ciclo seguinte); 3. Desvio para o endereço apontado pelo valor corrente de MBR, isto é, execução da instrução cujo opcode foi armazenado no MBR pela instrução chamadora de Main1. 54

28 A Instrução NOP NOP 0x00 Código IJVM: Não faz nada durante um ciclo. Esta instrução é propositalmente localizada no endereço 0x00, sendo portanto a primeira instrução a ser executada quando a máquina MIC-1 é inicializada (MPC=0x000 no reset). Implementação em Microcódigo MAL 0x00 nop1: goto Main1 55 IADD IADD 0x60 Código IJVM: Retira duas palavras do topo da pilha de operandos, soma as duas e coloca o resultado no topo. Implementação em Microcódigo MAL 0x60 iadd1: MAR=SP=SP-1; rd iadd2: H=TOS iadd3: MDR=TOS=MDR+H; wr; goto Main1 56

29 ISUB ISUB 0x64 Código IJVM: Retira duas palavras do topo da pilha de operandos, subtrai as duas e coloca o resultado no topo. Implementação em Microcódigo MAL 0x64 isub1: MAR=SP=SP-1; rd isub2: H=TOS isub3: MDR=TOS=MDR-H; wr; goto Main1 57 BIPUSH Código IJVM: 0x10 valor Coloca o BYTE especificado como parâmetro no topo da pilha de operandos. Implementação em Microcódigo MAL 0x10 BIPUSH byte bipush1: SP=MAR=SP+1 bipush2: PC=PC+1; fetch bipush3: MDR=TOS=MBR; wr; goto Main1 58

30 ILOAD Código IJVM: 0x15 variável Copia o conteúdo da variável local especificada como parâmetro no topo da pilha de operandos. Implementação em Microcódigo MAL 0x15 ILOAD varnum iload1: H=LV; iload2: MAR=MBRU+H; rd iload3: MAR=SP=SP+1 iload4: PC=PC+1; fetch; wr iload5: TOS=MDR; goto Main1 59 ISTORE Código IJVM: 0x36 variável Retira a palavra que está no topo da pilha de operandos e a armazena na variável local especificada. Implementação em Microcódigo MAL 0x36 ISTORE varnum istore1: H=LV; istore2: MAR=MBRU+H istore3: MDR=TOS; wr istore4: SP=MAR=PC-1; rd istore5: PC=PC+1; fetch istore6: TOS=MDR; goto Main1 60

31 IINC IINC varnum const 0x84 variável constante Código IJVM: Soma um valor constante a uma variável local passada como parâmetro. Implementação em Microcódigo MAL 0x84 iinc1: H=LV; iinc2: MAR=MBRU+H; rd iinc3: PC=PC+1; fetch iinc4: H=MDR iinc5: PC=PC+1; fetch iinc6: MDR=MBR+H; wr; goto Main1 61 GOTO GOTO Código IJVM: 0xA7 offset[15..8] offset[7..0] Desvia incondicionalmente a execução do programa para o endereço relativo especificado. Implementação em Microcódigo MAL 0xA7 goto1: OPC=PC-1 goto2: PC=PC+1; fetch goto3: H=MBR << 8 goto4: H=MBRU OR H goto5: PC=OPC+H; fetch goto6: goto Main1 offset 62

32 IF_ICMPEQ IF_ICMPEQ Código IJVM: 0x9F offset[15..8] offset[7..0] Retira 2 palavras do topo da pilha, se elas forem iguais, desvia a execução para o endereço relativo especificado. Implementação em Microcódigo MAL 0x9F if_icmpeq1: MAR=SP=SP-1; rd if_icmpeq2: MAR=SP=SP-1 if_icmpeq3: H=MDR; rd if_icmpeq4: OPC=TOS if_icmpeq5: TOS=MDR if_icmpeq6: Z=OPC-H; if(z) goto T; else goto F T: OPC=OPC-1; fetch; goto goto2 F: PC=PC+1 F2: PC=PC+1; fetch F3: goto Main1 offset 63 WIDE WIDE 0xC4 Código IJVM: Não é propriamente uma instrução e sim um prefixo de instrução, indicando que a próxima instrução tem um parâmetro de 16 bits. O byte que se segue ao prefixo deve conter o opcode da instrução a ser executada na parte alta da memória de controle (parte cujo endereço é superior a 0x100), para isso o opcode será somado a 0x100 e executado. Implementação em Microcódigo MAL 0xC4 wide1: PC=PC+1; fetch; goto (MBR or 0x100) 64

33 WIDE_ILOAD ILOAD varnum 0xC4 0x15 variável[15..8] variável[7..0] Código IJVM: Versão estendida da instrução ILOAD, capaz de operar com variáveis cujo endereço relativo é superior a 255; Seu microcódigo encontra-se na parte alta da memória de controle (ADDR 0x100), sendo executado através do prefixo WIDE. Implementação em Microcódigo MAL 0x115 wide_iload1: PC=PC+1; fetch wide_iload2: H=MBRU << 8 wide_iload3: H=MBRU OR H wide_iload4: MAR=LV+H; rd; goto iload3 65 WIDE_ISTORE ISTORE Código IJVM: 0xC4 0x36 variável[15..8] variável[7..0] Versão estendida da instrução ISTORE, capaz de operar com variáveis cujo endereço relativo é superior a 255; Seu microcódigo encontra-se na parte alta da memória de controle (ADDR 0x100), sendo executado através do prefixo WIDE. Implementação em Microcódigo MAL 0x136 wide_istore1: PC=PC+1; fetch wide_istore2: H=MBRU << 8 wide_istore3: H=MBRU OR H wide_istore4: MAR=LV+H; goto istore3 varnum 66

34 3.4. Inicialização do MIC-1 67 Processo de Inicialização do MIC-1 Ciclo 0: A máquina é inicializada. Todos os registradores são zerados, inclusive o apontador de microprograma (MPC=0x000). 1 ciclo : Como a instrução NOP está estrategicamente localizada no endereço 0x000 da memória de controle, será ela a primeira instrução a ser executada, desviando a execução para Main1. 2 ciclo : Main1 incrementa PC e inicia a busca da instrução no endereço apontado por ele (PC=1). Como MBR ainda é igual a zero, a execução é desviada novamente para NOP. 68

35 3 ciclo : NOP consome um ciclo sem fazer nada enquanto a primeira instrução cuja busca iniciou no ciclo anterior é transferida da memória para MBR. A execução é novamente desviada para Main1. 4 ciclo: Main1 é executada novamente, incrementando PC para 2 e iniciando a busca do próximo byte (que poderá ser o opcode da próxima instrução ou um argumento da instrução corrente). MBR contém agora o opcode da primeira instrução IJVM da memória (armazenada no endereço 0x01). Com isso, goto (MBR) agora desviará a execução para o endereço da memória de controle correspondente à instrução IJVM apontada por MBR ciclo em diante: A execução continuará por um ou mais ciclos, conforme a duração da instrução IJVM chamada. Ao final do microprograma, a execução será desviada novamente para Main1. Neste ponto, o próximo opcode já deverá ter sido carregado em MBR, fazendo com que Main1 inicie a busca seguinte e execute a próxima instrução IJVM. O processo se repete dando prosseguimento a execução do programa armazenado na memória até que alguém desligue a máquina. 70

36 3.5. Compilação JAVA 71 Compilação JAVA para IJVM Considere o fragmento de código JAVA abaixo: O equivalente IJVM obtido por compilação seria: 1 i = j + k; 2 if (i == 3) 3 k = 0; 4 else JAVA 5 j = j - 1; IJVM 1 ILOAD j 2 ILOAD k 3 IADD 4 ISTORE i 5 ILOAD i 6 BIPUSH 3 7 IF_ICMPEQ L1 8 ILOAD j 9 BIPUSH 1 10 ISUB 11 ISTORE j 12 GOTO L2 13 L1: BIPUSH 0 14 ISTORE k 15 L2: 72

37 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 0 k j i 73 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: j Variáveis locais: 1 k j i 74

38 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: k j 2 Variáveis locais: k j i 75 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: j + k Variáveis locais: 3 k j i 76

39 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 4 k j i 77 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: i Variáveis locais: 5 k j i 78

40 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: 3 i 6 Variáveis locais: k j i 79 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 7 k j i 80

41 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: j Variáveis locais: 8 k j i 81 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: 1 j 9 Variáveis locais: k j i 82

42 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: j-1 Variáveis locais: 10 k j i 83 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 11 k j i 84

43 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 12 k j i 85 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: 0 Variáveis locais: 13 k j i 86

44 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 14 k j i 87 Execução do um fragmento de código IJVM 1 ILOAD j // copia a variável j para o topo da pilha 2 ILOAD k // copia a variável k para o topo da pilha 3 IADD // coloca no topo da pilha a soma j+k 4 ISTORE i // retira resultado do topo e coloca em i 5 ILOAD i // copia a variável i para o topo da pilha 6 BIPUSH 3 // coloca o valor 3 no topo da pilha 7 IF_ICMPEQ L1 // desvia para L1 se i=3 8 ILOAD j // copia a variável j para o topo da pilha 9 BIPUSH 1 // coloca o valor 1 no topo da pilha 10 ISUB // coloca no topo da pilha a subtração j-1 11 ISTORE j // retira resultado do topo e coloca em j 12 GOTO L2 // desvio incondicional para L2 13 L1: BIPUSH 0 // coloca o valor 0 no topo da pilha 14 ISTORE k // retira o valor 0 do topo e coloca em k 15 L2: // não faz nada por um ciclo Estado da pilha de operandos: Variáveis locais: 15 k j i 88

45 Código hexadecimal gerado para cada instrução IJVM pelo programa montador Linha Instrução IJVM Código Hexa Gerado Opcode Arg Arg 1 ILOAD j 0x15 0x02 2 ILOAD k 0x15 0x03 3 IADD 0x60 4 ISTORE i 0x36 0x01 5 ILOAD i 0x15 0x01 6 BIPUSH 3 0x10 0x03 7 IF_ICMPEQ L1 0x9F 0x00 0x0D 8 ILOAD j 0x15 0x02 9 BIPUSH 1 0x10 0x01 10 ISUB 0x64 11 ISTORE j 0x36 0x02 12 GOTO L2 0xA7 0x00 0x07 13 L1: BIPUSH 0 0x10 0x00 14 ISTORE k 0x36 0x03 15 L2: 0x00 Variáveis locais: k j i 89 Andrew S. Tanenbaum, Organização Estruturada de Computadores, 5a Ed., Pearson, J. L. Hennessy & D. A. Patterson, Arquitetura de Computadores - Uma Abordagem Quantitativa, Editora Campus, Willians Stallings, Arquitetura e Organização de Computadores, 5ª Edição, Pearson, Albert Paul Malvino, Microcomputadores e Microprocessadores, McGraw-Hill, Herbert Taub, Circuitos Digitais e Microprocessadores, Mcgranw-Hill,