Introdução a Organização de Computadores e Linguagens de Montagem Ricardo Anido Draft date 15 de Agosto de 2013
Capítulo 3 O processador Faíska Neste capítulo iniciaremos o estudo mais detalhado do repertório de instruções do processador Faíska, ilustrando com exemplos de trechos de programas o uso das diversas instruções. As instruções serão apresentadas usando um descritor no formato de uma tabela, como o mostrado na Figura 3, contendo o mnemônico da instrução em destaque em uma aba (MNE na figura), o nome, a sintaxe do comando correspondente em linguagem de montagem, a operação descrita de forma sucinta, e a codificação. O descritor inclui também um campo Flags, cujo significado será introduzido mais adiante, na Seção 3.2.1. MNE Nome da instrução Sintaxe Operação Flags Codificação Figura 3.1: Formato do descritor de instruções As instruções serão apresentadas em grupos: transferência de dados, operações aritméticas, instruções para controle de fluxo e operações lógicas. 3.1 Transferência de dados Instruções de transferência de dados são as que permitem a transferência de dados entre dois registradores do processador ou entre a memória e um registrador. Um exemplo de 1
2 CAPÍTULO 3. O PROCESSADOR FAÍSKA instrução de transferência de dados é a instrução carrega registrador com valor imediato, que já foi introduzida no capítulo anterior. Nesta seção iremos estudar as outras instruções para transferência de dados do repertório de instruções do Faíska. 3.1.1 Transferência entre registradores Os operandos para instruções de transferência entre registradores são sempre dois registradores: o registrador destino (operando mais à esquerda) e o registrador fonte (operando mais à direita). A operação executada é muito simples: o valor do registrador fonte é copiado para o registrador destino. MOV Carrega registrador com registrador Sintaxe Operação Flags Codificação mov r dest, r fonte r dest r fonte 00 r dest r fonte Qualquer dos registradores de propósito geral do Faíska (r0 a r15) pode ser usado como registrador destino ou fonte. Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplo de instrução de carga de registrador 2 ; com valor constante (endereçamento imediato) 3 4 00001000 [00 00 01 05] mov r1,r5 ; instrução é codificada em 5 ; uma palavra r1 ff ff ff ff 00104h r1 11 11 11 11 00104h r5 11 11 11 11 00 00 01 05 00100h r5 11 11 11 11 00 00 01 05 00100h 00 00 01 00 000fch 00 00 01 04 000fch Antes Depois
3.1. TRANSFERÊNCIA DE DADOS 3 No exemplo acima são mostrados o estado antes e após a execução do trecho de programa em linguagem de montagem, tanto do processador como da memória. Em todos os exemplos seguintes o mesmo esquema será utilizado. No processador são mostrados apenas os registradores importantes para entender a execução do trecho de programa; os registradores e posições de memória que tiveram seus valores alterados são mostrados em tom cinza após a execução. 3.1.2 Transferência da para um registrador O Faíska possui diferentes instruções para transferência de valores da memória para um registrador, cada uma com modos de endereçamento distintos. As instruções de transferência da memória para registrador no Faíska utilizam três modos de endereçamento: endereçamento imediato, endereçamento direto e endereçamento indireto por registrador. Carrega registrador com endereçamento imediato No endereçamento imediato, o valor do operando faz parte do próprio código da instrução. Na instrução carrega registrador com endereçamento imediato o registrador destino é carregado com o valor do operando. E como o valor do operando é codificado na própria instrução, o valor carregado no registrador é sempre o mesmo. Em outras palavras, sempre que uma particular instrução desse to for executada, o registrador destino será carregado sempre com o mesmo valor. Dessa forma, essa instrução é utilizada para carregar um valor constante no registrador destino. Compare o efeito dessa instrução com a instrução carrega registrador com endereçamento direto, introduzida no capítulo anterior. No endereçamento direto, o valor carregado no registrador é o valor corrente de uma posição de memória. Como esse valor pode ser alterado pelo programa, uma mesma instrução carrega registrador com endereçamento direto pode carregar diferentes valores no registrador destino a cada vez que é executada.
4 CAPÍTULO 3. O PROCESSADOR FAÍSKA SET Carrega registrador com endereçamento imediato Sintaxe Operação Flags Codificação set r dest, expr 8 r dest ext(imd 8 ) 01 imd 8 r dest set r dest, expr 32 r dest imd 32 02 r dest imd 32 O Faíska possui duas instruções de carga de registrador com endereçamento imediato: uma em que a constante é codificada em apenas um byte e uma em que a constante é codificada em 32 bits. No caso em que a constante é codificada em 32 bits, a instrução ocupa duas palavras. Para constantes que podem ser representadas em 8 bits, a instrução utiliza o campo imd8 para armazenar a constante como um inteiro com sinal em complemento de dois. Assim, esta forma só permite carregar constantes entre 128 e 127. Como veremos, na programação em linguagem de montagem muitas vezes utilizamos constantes dentro desse intervalo, o que nos permite utilizar a forma mais econômica com bastante frequência. É importante notar que todos os 32 bits do registrador destino são carregados pela instrução set, mesmo na sua forma mais curta. Nesse caso, quando um valor imd8 positivo é carregado em um registrador, os 24 bits mais significativos do registrador são zerados. Quando o campo imd8 tem um valor negativo, os 24 bits mais significativos do registrador destino recebem o valor 1, de forma a fazer com que o registrador tenha o valor negativo correto. Ou seja, o bit de sinal do operando imd8 é estendido para os bits mais significativos do registrador destino. O fato de que o bit de sinal de imd8 é estendido para compor o valor de 32 bits é mostrado no campo operação do descritor pela expressão ext(imd 8 ). Note que na descrição da sintaxe do comando em linguagem de montagem aparece o termo expr 8, que representa uma expressão inteira, que quando avaliada deve resultar em um inteiro de 8 bits com sinal. Exemplo
3.1. TRANSFERÊNCIA DE DADOS 5 Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplo de instrução de carga de registrador 2 ; com valor constante (endereçamento imediato) 3 4 00001000 [01 ff 03 00] set r3,-1 ; instrução é codificada em 5 ; uma palavra 6 r3 22 22 22 22 01004h r3 ff ff ff ff 01004h 00 00 10 00 01 ff 03 00 01000h 00 00 10 04 01 ff 03 00 01000h Antes Depois Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; outros exemplos de instrução de carga de 2 ; registrador com endereçamento imediato, com 3 ; constantes que não podem ser representadas 4 ; em 8 bits. 5 6 00000108 [02 00 09 00] set r9,400h ; um valor que não pode 7 [00 00 04 00] ; ser representado 8 ; em 8 bits. Código da 9 ; instrução ocupa 10 ; duas palavras. 11 00000110 [02 00 0c 00] set r12,var1 ; carrega endereço de 12 [00 07 00 00] ; var1. Código também 13 ; ocupa duas palavras 14.org 70000h 15 16 var1: 17 00070000.ds 4 ; uma variável associada 18 ; ao endereço 70000h
6 CAPÍTULO 3. O PROCESSADOR FAÍSKA r9 33 33 33 33 00 07 00 00 00114h r9 00 00 04 00 00 07 00 00 00114h r12 55 55 55 55 02 00 0c 00 00 00 04 00 00110h 0010ch r12 00 07 00 00 02 00 0c 00 00 00 04 00 00110h 0010ch 00 00 01 08 03 00 09 00 00108h 00 00 01 18 03 00 09 00 00108h Antes Depois Note que no Exemplo acima, quando o montador avalia a expressão inteira composta pelo rótulo var1, durante a montagem do comando set r12,var, o resultado é o endereço do rótulo, ou seja, o endereço da variável associada àquele rótulo. É esse endereço que é montado na segunda palavra da instrução, e portanto é esse endereço que é carregado como novo valor do registrador r12. Carrega registrador com endereçamento direto O endereçamento imediato só é útil para carregar o valor de uma constante em um registrador. Para implementar o conceito de variável é necessário associar um nome a uma posição específica na memória. Assim, uma variável (i, por exemplo) pode ser associada a uma determinada posição da memória (2000h, por exemplo). Toda vez que se quiser acessar uma variável, faz-se um acesso à posição de memória correspondente. Uma maneira de acessar posições específicas é utilizar o chamado endereçamento direto, no qual a instrução contém o endereço da posição de memória que contém o valor a ser acessado. A instrução ld (abreviatura do inglês load) carrega o valor de um registrador com o conteúdo de uma posição de memória, cujo endereço é dado na própria instrução. LD Carrega registrador com endereçamento direto Sintaxe Operação Flags Codificação ld r dest, expr 32 r dest mem[imd 32 ] 03 r dest imd 32 Note que na descrição da sintaxe do comando em linguagem de montagem aparece o termo expr 32, que representa uma expressão inteira, que quando avaliada deve
3.1. TRANSFERÊNCIA DE DADOS 7 resultar em um inteiro de 32 bits (sem sinal, já que representa um endereço), representada na codificação como imd 32. No entanto, na maioria dos casos expr 32 é na realidade apenas um rótulo, associado a uma variável. O montador monta na segunda palavra da instrução o endereço associado ao rótulo. Para executar uma instrução ld o processador faz três acessos à memória: um acesso no endereço do corrente, para a busca da primeira palavra da instrução; outro acesso no endereço do corrente mais quatro, para a busca do endereço do operando (imd 32, segunda palavra da instrução); e ainda outro acesso para a busca do valor operando (no endereço retirado no segundo acesso). Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplo de instrução ld 2 ; código ocupa duas palavras 3 4 00000100 [03 00 0a 00] ld r9,cont 5 [00 00 20 00] 6... 7 8.org 2000h 9 cont: 10 00002000.ds 4 ; uma variável associada 11 ; ao endereço 2000h 02004h 02004h r10 55 55 55 55 22 22 22 22 02000h 0fffch r10 22 22 22 22 22 22 22 22 02000h 0fffch 00 00 01 00 00 00 01 08 00 00 20 00 00104h 00 00 20 00 00104h Antes 03 00 0a 00 00100h Depois 03 00 0a 00 00100h Carrega registrador com endereçamento indireto por registrador No modo de endereçamento indireto por registrador o endereço do operando é dado em um registrador, ao invés de ser um valor constante, codificado na instrução, como no endereçamento direto. Na linguagem de montagem, utilizaremos para a instrução de carga de registrador com endereçamento indireto por registrador o mesmo mnemônico ld já utilizado anteriormente, mas indicaremos o modo de endereçamento distinto pela grafia do operando fonte. Enquanto na instrução ld com modo de endereçamento direto o operando fonte é um rótulo (no caso geral, qualquer expressão inteira), na instrução
8 CAPÍTULO 3. O PROCESSADOR FAÍSKA ld com modo de endereçamento indireto por registrador o operando fonte é o nome de um registrador entre parênteses. Essa convenção de utilizar o mesmo mnemônico para duas instruções distintas é apenas uma conveniência para o programador; é importante notar no entanto que para o processador o que existe são duas instruções distintas, com codificações diferentes. LD Carrega registrador com endereçamento indireto por registrador Sintaxe Operação Flags Codificação ld r dest, (r fonte ) r dest mem[r fonte ] 04 r dest r fonte Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; instrução carrega registrador com 2 ; endereçamento indireto por registrador 3 ; código da instrução ocupa uma palavra 4 5 000001ac [04 00 06 05] ld r6, (r5) 6 7 03010h 03010h r5 00 00 30 0c 00 00 00 01 0300ch r5 00 00 30 0c 00 00 00 01 0300ch r6 ff ff ff f0 03008h r6 00 00 00 01 03008h 00 00 01 ac 00 00 01 b0 001b0h 001b0h Antes 04 00 06 05 001ach Depois 04 00 06 05 001ach Carrega registrador com endereçamento indireto por registrador mais uma constante A instrução carrega registrador com endereçamento indireto por registrador mais uma constante é na verdade a mesma instrução que carrega registrador com endereça-
3.1. TRANSFERÊNCIA DE DADOS 9 mento indireto por registrador. Apresentamos as duas instruções separadamente apenas como forma mais didática de introduzir o modo de endereçamento indireto por registrador mais constante. Nesse novo modo de endereçamento o operando fonte é uma expressão de adição, entre parênteses, em que um termo é o nome de um registrador e o outro termo é uma expressão constante com valor entre 128 e 127. O termo constante é codificado no campo imd8; o endereço efetivo é calculado efetuando a adição do valor do registrador com o valor de imd8 com o sinal estendido. O fato de que o bit de sinal de imd8 é estendido para compor o valor de 32 bits é mostrado no campo Operação do descritor pela expressão ext(imd 8 ). LD Carrega registrador com endereçamento indireto por registrador mais uma constante Sintaxe Operação Flags Codificação ld r dest, (r fonte + expr 8 ) r dest mem[r fonte + ext(imd 8 )] 04 imd 8 r dest r fonte Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; instrução carrega registrador com 2 ; endereçamento indireto por registrador 3 ; mais uma constante. 4 ; código da instrução ocupa uma palavra 5 6 00000200 [04 08 02 03] ld r2,(r3+8) 7 00000204 [04 fc 06 05] ld r6,(r5-4)
10 CAPÍTULO 3. O PROCESSADOR FAÍSKA 04004h 04004h r2 22 22 22 22 99 99 99 99 04000h r2 77 77 77 77 99 99 99 99 04000h r3 00 00 2f f8 03ffch r3 00 00 2f f8 03ffch r5 00 00 40 04 r5 00 00 40 04 r6 55 55 55 55 03004h 77 77 77 77 03000h r6 99 99 99 99 03004h 77 77 77 77 03000h 00 00 02 00 02ffch 00 00 02 08 02ffch Antes 04 fc 06 05 00204h Depois 04 fc 06 05 00204h 04 08 02 03 00200h 04 08 02 03 00200h É interessante notar que os modos de endereçamento indireto por registrador e indireto por registrador mais uma constante são implementados pela mesma instrução, com código 04h. Na verdade, a execução desta instrução do processador sempre soma o valor do campo imd8 ao valor do registrador destino para encontrar o valor do endereço efetivo do operando. Quando imd8 é zero resulta no modo de endereçamento indireto por registrador ; quando imd8 é diferente de zero resulta no modo de endereçamento indireto por registrador mais uma constante. Transferência de bytes entre a memória e um registrador Como é muito comum a necessidade de manular valores de 8 bits (especialmente caracteres), o Faíska inclui também instruções para carregar um byte da memória em um registrador. Na instrução Carrega registrador com byte da memória, apenas um byte é carregado da memória para o registrador destino. O byte carregado é colocado nos 8 bits menos significativos do registrador destino; os 24 bits mais significativos do registrador são zerados. O mnemônico utilizado pelo montador é ldb; como no caso da instrução ld, há dois modos de endereçamento possíveis: direto e indireto por registrador mais uma constante.
3.1. TRANSFERÊNCIA DE DADOS 11 LDB Carrega registrador com byte da memória Sintaxe Operação Flags Codificação ldb r dest, expr 32 r dest mem 8 [imd 32 ] 07 r dest imd 32 ldb r dest, (r fonte + expr 8 ) r dest mem 8 [r fonte + ext(imd 8 )] 08 imd 8 r dest r fonte Novamente, é interessante notar que os modos de endereçamento indireto por registrador e indireto por registrador mais uma constante são implementados pela mesma instrução, com código 08h. Como comentado anteriormente a execução desta instrução sempre soma o valor do campo imd8 ao valor do registrador destino para encontrar o valor do endereço efetivo do operando, de fomra que o modo de endereçamento indireto por registrador pode ser entendido como um caso especial do modo de endereçamento indireto por registrador mais uma constante, quando a constante tem valor zero. Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; instrução carrega registrador com byte da 2 ; memória 3 4 00000200 [07 00 0d 00] ldb r13,carac+7 ; carrega byte cujo 5 [00 00 04 0b] ; endereço é carac+7 6 7 00000204 [08 00 01 02] ldb r1,(r2) ; r2 tem endereço do 8 ; byte que queremos 9 ; carregar em r1 10 11 00000208 [08 ff 0c 02] ldb r12,(r2-1) ; r2-1 tem endereço do 12 ; byte que queremos 13 ; carregar em r12 14... 15 16.org 4004h 17 carac: ; uma variável que 18 ; contém uma sequência 19 ; de bytes (caracteres) 20 00004004 [55 56 57 58].db U, V, W, X 21 00004008 [61 62 63 64].db a, b, c, d
12 CAPÍTULO 3. O PROCESSADOR FAÍSKA 0400ch 0400ch r1 11 11 11 11 64 63 62 61 04008h r1 00 00 00 63 64 63 62 61 04008h r2 00 00 40 06 55 56 57 58 04004h r2 00 00 40 06 55 56 57 58 04004h r12 bb bb bb bb r12 00 00 00 62 r13 aa aa aa aa 08 00 01 02 00210h 0020ch r13 00 00 00 64 08 ff 0c 02 00210h 0020ch 00 00 02 00 08 00 01 02 00208h 00 00 02 10 08 00 01 02 00208h 00 00 40 0b 00204h 00 00 40 0b 00204h Antes 07 00 0d 00 00200h Depois 07 00 0d 00 00200h 3.1.3 Transferência de um registrador para a memória As instruções de transferência de um registrador para memória permitem armazenar o valor de um registrador em uma posição de memória, efetuando a operação inversa das instruções de carga de registrador. No Faíska, estas instruções utilizam o mnemônico st (do inglês store, armazenar) e possui duas variantes, correspondentes aos modos de endereçamento direto e indireto por registrador. Armazena registrador em memória ST Armazena de registrador na memória Sintaxe Operação Flags Codificação st (r dest + expr 8 ), r fonte mem[r dest +ext(imd8)] r fonte 05 r dest r fonte st (r dest ), expr 32 mem[imd 32 ] r fonte 06 r fonte imd 32 Exemplo
3.1. TRANSFERÊNCIA DE DADOS 13 Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplos de instrução armazena registrador na 2 ; memória 3 4 00000200 [05 00 00 07] st var,r7 ; armazena registrador 5 [00 00 10 00] ; r7 na variável var 6 7 8 00000204 [06 00 04 03] st (r4),r3 ; r4 tem endereço 9 ; onde queremos 10 ; armazenar r3 11 12.org 1000h 13 var: ; uma variável montada 14 00001000.ds 4 ; no endereço 1000h 01008h 01008h r3 ff ff ff ff 00 00 00 00 01004h r3 ff ff ff ff ff ff ff ff 01004h r4 00 00 10 04 ff ff ff ff 01000h r4 00 00 10 04 00 00 00 00 01000h r7 00 00 00 00 r7 00 00 00 00 00 00 03 14 06 00 04 03 00320h 0031ch 00 00 03 20 06 00 04 03 00320h 0031ch Antes 00 00 10 00 05 00 00 07 00318h 00314h Depois 00 00 10 00 05 00 00 07 00318h 00314h
14 CAPÍTULO 3. O PROCESSADOR FAÍSKA Armazena byte de registrador em memória STB Armazena byte de registrador na memória Sintaxe Operação Flags Codificação stb (r dest ), r fonte r dest mem 8 [r fonte ] 0a r dest r fonte stb (r dest ), expr 32 mem 8 [imd 32 ] r fonte r dest 0a imd 32 Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplo de instruções que armazenam byte de 2 ; registrador memória 3 4 00000108 [09 00 00 04] stb carac+2,r4 ; armazena byte de r4 5 [00 00 20 02] ; no endereço carac+2 6 ; instrução ocupa duas 7 ; palavras 8 9 00000110 [0a 00 05 02] stb (r5),r2 ; r5 tem endereço onde 10 ; queremos armazenar 11 ; byte em r2 12 ; instrução ocupa uma 13 ; palavra 14 15.org 2000h 16 carac: ; uma variável montada 17 00002000.ds 8 ; no endereço 2000h que 18 ; representa uma 19 ; sequência de oito 20 ; bytes 21
3.1. TRANSFERÊNCIA DE DADOS 15 02008h 02008h r2 00 00 00 67 48 47 46 45 02004h r2 00 00 00 67 48 47 46 67 02004h r5 00 00 20 04 44 43 42 41 02000h r5 00 00 20 04 44 55 42 41 02000h r4 00 00 00 55 r4 00 00 00 55 00 00 01 08 0a 00 05 02 00114h 00110h 00 00 01 14 0a 00 05 02 00114h 00110h Antes 00 00 20 02 09 00 00 04 0010ch 00108h Depois 00 00 20 02 09 00 00 04 0010ch 00108h Podemos agora ver como traduzir, para linguagem de montagem, um pequeno trecho de programa escrito em linguagem C exemplificando o uso de variáveis e comandos de atribuição: Exemplo Traduzir o trecho abaixo, em linguagem C, contendo alguns comandos de atribuição, para linguagem de montagem do Faíska. 1 // Trecho de programa em C 2 3 #define TAMANHO 256 4 5 int a,b; 6 char c; 7... 8 9 a = TAMANHO; 10 b = a; 11 c = a ;
16 CAPÍTULO 3. O PROCESSADOR FAÍSKA 1 ; tradução para linguagem de montagem 2 ; do trecho de programa acima 3 4 TAMANHO.equ 256 5 6 ; reserva espaço para as variáveis 7.org 20h 8 a:.ds 4 9 b:.ds 4 10 c:.ds 1 11 12.org 100h 13 set r0, TAMANHO ; r0 usado como auxiliar 14 st a, r0 ; armazena valor na variável a 15 st b, r0 ; armazena valor na variável b 16 set r1, a ; r1 usado como auxiliar; note 17 ; que r0 poderia ser reutilizado 18 stb c, r1 ; armazena caractere na variável c 19 3.1.4 Ordem de bytes na memória Como vimos, a memória do computador é vista como um vetor de bytes, em que os endereços de memória representam os índices desse vetor. Ou seja, o primeiro byte da memória tem endereço 0, o segundo byte da memória tem endereço 1, o terceiro byte tem endereço 2 e assim por diante. Muitas vezes também consideramos a memória como uma sequência de palavras. Mas como o endereçamento da memória é por bytes, quando consideramos a memória como uma sequência de palavras continuamos a utilizar os endereços dos bytes individuais. Assim, para um processador com palavras têm 32 bits, como o Faíska, a primeira palavra está no endereço 0, a segunda palavra no endereço 4 (e não 1), a terceira palavra está no endereço 8 (e não 2), e assim por diante. Isso fica também evidente nas figuras que temos usado para representar o conteúdo da memória, como mostrado na figura abaixo, que mostra duas palavras presentes nos endereços de memória 0200h e 0204h. 208h 77 66 55 44 33 22 11 00 204h 200h 1fch Vamos agora examinar com maior detalhe a ordem em que os bytes de uma palavra são armazenados na memória. Quando por exemplo valor de um registrador é transferido para ou da memória, um processador pode considerar os bytes que formam a
3.1. TRANSFERÊNCIA DE DADOS 17 palavra a ser transferida em pelo menos duas ordens distintas: o byte de memória que tem endereço mais baixo pode conter (i) o byte mais significativo do registrador ou (ii) o byte menos significativo da palavra. Registrador 31 25 17 8 0 end_inicio+12 end_inicio+8 end_inicio+4 end_inicio Big-endian end_inicio+12 end_inicio+8 end_inicio+4 end_inicio 31 25 17 8 0 Registrador Little-endian A ordem (i) é chamada em inglês de big-endian, e ordem (i) é chamada de littleendian. Esses nomes são referências ao livro Viagens de Gulliver, de Jonathan Swift, em que dois reinos estão em guerra por divergirem sobre como deve ser comido um ovo quente: a partir do extremo mais fino ou do extremo mais grosso do ovo. Tal como no conto de Swift, a ordem escolhida pelo processador não importa, pois como o processador sempre armazena e lê os bytes da memória na mesma ordem, ambas as ordens são funcionalmente equivalentes, embora haja vantagens e desvantagens de cada uma em relação à implementação em hardware. Mas como processadores distintos utilizam ordens distintas, quando é necessária a transferência de informação entre um computador e outro é importante que se conheça a ordem utilizada em ambos os processadores envolvidos para que a informação seja corretamente recebida. A figura abaixo mostra um exemplo de duas palavras, de valores 33221100h e 77665544h, armazenadas em endereços consecutivos da memória (respectivamente 200h e 204h), utilizado as ordens little-endian e big-endian.
18 CAPÍTULO 3. O PROCESSADOR FAÍSKA (em bytes) (em bytes) 208h 208h (em palavras) 77 66 207h 206h 44 55 207h 206h 208h 55 205h 66 205h 77 66 55 44 204h 44 204h 77 204h 33 22 11 00 200h 33 203h 00 203h 1fch 22 202h 11 202h 11 201h 22 201h 00 200h 33 200h 1ffh 1ffh Little-endian Big-endian Note que o Faíska utiliza a ordem little-endian. 3.2 Instruções aritméticas No grupo das instruções aritméticas encontramos instruções para somar, subtrair, multlicar e dividir números inteiros. Nesta seção estudaremos apenas as instruções para somar e subtrair; multlicação e divisão serão apresentadas mais adiante. No Faíska as instruções de adição e subtração têm sempre como operando destino um registrador; o segundo operando pode ser um outro registrador ou um valor imediato codificado em 8 bits (inteiro em complemento de dois). 3.2.1 Adição ADD Adição Sintaxe Operação Flags Codificação add r dest, expr 8 r dest r dest + ext(imd 8 ) CNVZ 10 imd 8 r dest add r dest, r fonte r dest r dest + r fonte CNVZ 11 r dest r fonte
3.2. INSTRUÇÕES ARITMÉTICAS 19 Bits de estado Note que na instrução add pela primeira vez o campo Flag do descritor de instrução não está vazio, e contém quatro letras. Essas letras representam bits de estado (em inglês, flags). No Faíska os bits de estado são: C: vai-um (carry). Ligado se operação causou vai-um (carry-out) ou vem-um (carryin), desligado caso contrário. Z: zero. Ligado se o resultado foi zero, desligado caso contrário. N: sinal. Cópia do bit mais significativo do resultado; considerando aritmética com sinal, se N igual a zero, o resultado é maior ou igual a zero. Se N igual a 1, resultado é negativo. V: overflow. Ligado se ocorreu estouro de campo; calculado como o ou-exclusivo entre o vem-um e o vai-um do bit mais significativo do resultado. No descritor de instruções o campo Flag indica quais os bits de estado são afetados pela instrução; no caso da instrução add, todos os bits são afetados. Um bit de estado guarda a informação do resultado da última instrução executada que o afetou. Isto é, se uma instrução não afeta um determinado bit de estado, este permanece com o mesmo valor anterior à execução da instrução. Bits de estado não são alterados por operações de transferência de dados. Os bits de estado são armazenados em um registrador especial no Faíska, que não é acessível através de instruções de carga. Nas figuras dos exemplos, esse registrador especial é mostrado com o nome flags. Veremos mais adiante como os bits de estado são utilizados para controlar o fluxo de execução de um programa. Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplos de adição com endereçamento 2 ; imediato e entre registradores 3 4 00030000 [10 01 04 00] add r4,1 ; adição com valor imediato 5 ; instrução ocupa uma 6 ; palavra 7 8 9 00030004 [11 00 01 02] add r1,r2 ; adição de dois 10 ; registradores 11 ; instrução ocupa uma 12 ; palavra
20 CAPÍTULO 3. O PROCESSADOR FAÍSKA r1 80 00 11 11 r1 00 00 11 bc r2 80 00 00 ab 11 00 01 02 30008h 30004h r2 80 00 00 ab 11 00 01 02 30008h 30004h r4 00 ff ff ff 10 01 04 00 30000h r4 01 00 00 00 10 01 04 00 30000h 00 03 00 00 00 03 00 08 flags C N Z V... 0 0 0 0 Antes flags C N Z V... 1 0 0 1 Depois 3.2.2 Subtração SUB Subtração Sintaxe Operação Flags Codificação sub r dest, expr 8 r dest r dest ext(imd 8 ) CNVZ 12 imd 8 r dest sub r dest, r fonte r dest r dest r fonte CNVZ 13 r dest r fonte Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplos de adição com endereçamento 2 ; imediato e entre registradores 3 4 00050000 [12 01 06 00] sub r6,1 ; subtração com valor 5 ; imediato, instrução 6 ; ocupa uma palavra 7 8 9 00050004 [13 00 08 07] sub r8,r7 ; subtrai registrador de 10 ; registrador 11 ; instrução ocupa uma 12 ; palavra
3.2. INSTRUÇÕES ARITMÉTICAS 21 r6 10 00 00 00 r6 0f ff ff ff r7 ff ff ff ff 13 00 08 07 50008h 50004h r7 ff ff ff ff 13 00 08 07 50008h 50004h r8 ff ff ff ff 12 01 06 00 50000h r8 00 00 00 00 12 01 06 00 50000h 00 05 00 00 00 05 00 08 flags C N Z V... 0 0 0 0 Antes flags C N Z V... 0 0 1 0 Depois Exercício 3.1 Escrever um trecho de programa em linguagem de montagem que implemente o seguinte comando de atribuição em C: 1 var a, b, c: integer; 2 3... 4 5 a = b + c - 2; 6 7...
22 CAPÍTULO 3. O PROCESSADOR FAÍSKA Solução 1 ; tradução para linguagem de montagem 2 ; do trecho para implementar a = b + c - 2 3 4 ; reserva espaço para as variáveis inteiras a, b e c 5 a:.ds 4 6 b:.ds 4 7 c:.ds 4 8... 9 ld r0,b ; r0 e r1 são usados como auxiliares 10 ld r1,c 11 add r0,r1 ; r0 agora tem b+c 12 sub r0,2 13 st a,r0 ; e armazena o resultado 3.3 Instruções de desvio Até agora, em todos os exemplos mostrados as instruções são executadas em sequência estrita das suas posições da memória, ou seja, o valor do registrador é sempre incrementado de quatro a cada instrução. Se não houver uma forma de fazer o valor de variar de maneira não sequencial, fica impossível de implementar repetições como os comandos for e while em C ou Pascal. Para controlar o fluxo de execução do programa, são usadas instruções de desvio, que alteram o valor do registrador interno. Instruções de desvio podem ser condicionais ou incondicionais. 3.3.1 Desvio incondicional A execução da instrução de desvio incondicional tem apenas um operando é bastante simples: o valor do registrador é modificado para o valor do operando. Ou seja, o valor do operando é copiado para o registrador, fazendo com que a próxima instrução a ser executada tenha o endereço do operando, alterando dessa forma a execução puramente sequencial de instuções vista até agora. Há duas instruções de desvio incondicional: uma que é codificada em duas palavras, com a segunda palavra contendo o valor do endereço alvo do desvio, e uma instrução codificada em uma palavra, na qual o endereço alvo é dado em um registrador. O mnemônico utilizado para as duas instruções é jmp, do inglês jump (salto).
3.3. INSTRUÇÕES DE DESVIO 23 JMP Armazena byte de registrador na memória Sintaxe Operação Flags Codificação jmp expr 32 imd 32 20 imd 32 jmp r dest r dest 21 r dest Exemplo Endereço Código Programa 1 -------- ------------- ----------------------------------------------- ; exemplo de desvio incondicional 2 3.org 200h 4 00000200 [01 00 00 00] set r0,0 ; uma instrução montada 5 ; no endereço 200h 6 ; ocupa uma palavra 7 8 9 00000204 [20 00 00 00] jmp fora ; instrução de desvio 10 [00 00 30 00] ; incondicional 11 ; codificação ocupa duas 12 ; palavras 13 00000208 [00 00 01 02] mov r1,r2 ; esta instrução não é 14 ; executada 15... 16 17.org 3000h 18 fora: 19 00003000 [00 00 02 01] mov r2,r1 ; esta instrução é a 20 ; próxima a ser executada 21 ; após o desvio