Figura 8 Diagrama de Compilação

5. A Linguagem de Montagem do DLX 5.1. Introdução Um mercador dispunha de oito pérolas iguais, sendo que sete tinham o mesmo peso; a oitava, entretanto, era um pouco mais leve que as outras. Como poderia o mercador descobrir a pérola mais leve e indicá-la, usando a balança apenas duas vezes? Malba Tahan O Homem que Calculava Programa em Linguagem de Alto Nível Compilador Programa em Linguagem de Montagem Montador Objeto: Rotinas da Biblioteca (em linguagem de máquina) Objeto: Programa em Linguagem de Máquina Ligador Programa Executável Carregador Memória Figura 8 Diagrama de Compilação

Antes de estudarmos o conjunto de instruções do DLX com mais profundidade vamos apresentar todo o processo de conversão da linguagem de alto nível, utilizada pelos programadores, até a execução do programa equivalente em linguagem de máquina, ou seja, aquela que é entendida pelo computador. Um programa compilador utiliza vários passos para converter um arquivo escrito em linguagem de alto nível para linguagem de máquina. O processo se dá em várias etapas para que esta tradução possa ser mais eficiente e que o compilador possa ser portado de um tipo de computador para outro, com mais facilidade. O fluxo de tradução de um programa em linguagem de alto nível até um programa executável é mostrado na figura acima. Nela, o compilador, que é específico para cada linguagem de alto nível, traduz o programa em linguagem de alto nível para a linguagem de montagem, que é específica para cada tipo de processador. Em seguida, o programa é traduzido da linguagem de montagem para a linguagem de máquina pelo montador. Normalmente para cada para de arquitetura/sistema operacional, existe apenas um programa montador. O arquivo resultante é chamado de programa objeto. Contudo, esse programa ainda não está pronto para ser executado. Necessita antes ser acrescido das rotinas existentes nas bibliotecas da linguagem, como por exemplo, printf. O código dessas rotinas foi previamente traduzido para linguagem de máquina, sendo guardado em arquivos chamados de bibliotecas. Esta função é realizada pelo ligador. O resultado é um arquivo chamado de programa executável, também em linguagem de máquina. Finalmente, o programa executável é copiado para a memória principal pelo carregador (loader), quando pode finalmente ser executado pelo processador. O processador não entende nada além da linguagem de montagem, em formato binário, e só pode executar um programa depois que este for carregado na memória principal. Uma instrução em alto nível pode corresponder a uma ou várias instruções em linguagem de montagem, contudo, uma instrução em linguagem de montagem corresponde, normalmente, a apenas uma instrução em linguagem de máquina. Cada arquitetura de processador define um formato específico para as instruções em linguagem de máquina. Isto implica que, para diferentes arquiteturas de processador, teremos diferentes instruções em linguagem de montagem. Na página seguinte apresentamos um exemplo em linguagem de alto nível ( C ) e o seu respectivo código em linguagem de montagem para o processador DLX. Ao longo das demais seções deste capítulo estaremos apresentando exemplos de trechos em linguagem de alto nível e o seu correspondente em linguagem de montagem, para uma melhor compreensão do funcionamento de cada instrução. No exemplo podemos observar, além das instruções em linguagem de montagem que foram geradas, uma série de diretivas para o montador e os rótulos. Os rótulos são uma representação simbólica para os endereços de memória, ou seja, ao invés de utilizarmos endereços, são utilizados nomes e o montador fica responsável por calcular o endereço real. As diretivas orientam o montador sobre que posição de memória as instruções e dados irão ocupar depois de carregados na memória. Servem para definir onde as variáveis ficarão armazenadas e quanto espaço está reservado para cada uma delas. As diretivas são mostradas com mais detalhes na seção 5.5. O trecho de código apresentado pode ser executado no simulador WinDLX, que emula a arquitetura DLX, e que pode ser baixado do seguinte endereço internet:

http://equipe.nce.ufrj.br/gabriel/orgcomp2 As operações de entrada e saída são emuladas pelo simulador WindDLX com a ajuda do sistema operacional, no caso o Windows. Maiores detalhes sobre a forma de realizar operações de entrada e saída podem ser vistas no tutorial sobre o simulador, ao final desta apostila. main () { int a,b,c; } a=3; b=4; c=a+b; if (c==7) printf ("A soma deu certo! \n"); else printf ("A soma deu errado! \n"); exit(0); ;; Compilado por Gabriel ;; Área de Dados.data.align 2 string1:.ascii "A soma deu certo! \n\000".align 2 string2:.asciiz "A soma deu errado! \n".align 2 certo:.word string1.align 2 errado:.word string2 valor:.space 4 ;;Área de Código.text.align 2.global Main main: addi R2,R0,#3 addi R3,R0,#4 add R4,R2,R3 addi R1,R0,#7 sub R5,R4,R1 bnez R5,else then: sw valor, R0 addi R14,R0,certo trap #5 j fim else: sw Valor, R0 addi R14,R0,errado trap #5 fim: trap #0 Lembramos que na arquitetura DLX alguns registradores tem uso especial, entre ele podemos destacar o registrador R0, que sempre retorna o valor 0, o registrador R29, também conhecido como apontador de pilha (SP stack pointer), o registrador R30, também conhecido com apontador de quadro (FP frame pointer), e registrador R31, utilizado para guardar o endereço de retorno nas chamadas de rotinas e procedimentos (RA return address).

5.2. Detalhamento das Instruções 5.2.1. Convertendo de Alto Nível para Linguagem de Montagem Para apresentar as instruções do DLX, utilizamos pequenos trechos escritos em linguagem de alto nível (no caso a linguagem C ), e mostramos o seu correspondente em linguagem de montagem. Esperamos assim facilitar a compreensão do funcionamento das instruções em linguagem de montagem e, por conseqüência, do processador. a) A = 10; Hipótese: A variável A está armazenada no endereço de memória 100 e armazena 1 byte. addi R8, R0, #10 ;; registrador R8 recebe 10 sb 100(R0), R8 ;; A recebe o conteúdo de R8 ;; que é 10 Comentário: O programa equivalente em linguagem de montagem para realizar esta atribuição deve carregar a constante 10 em um registrador temporário. Em seguida o conteúdo do registrador é armazenado na memória pela instrução de sb (store byte). Como a variável A armazena apenas 1 byte, deve-se utilizar a instrução sb, já que esta transfere exatamente 1 byte para a memória. O endereço de memória onde a instrução sb vai armazenar este byte é obtido pela soma do operando imediato (no caso 100) como conteúdo do registrador R0 (que é sempre 0 no DLX). Não existe uma instrução em linguagem de montagem do DLX que atribua o valor de uma constante diretamente a uma variável armazenada na memória. b) A = B + 2; Hipótese: As variáveis inteiras A e B estão armazenadas nos endereços de memória definidos pelos rótulos A e B. Cada inteiro armazena 4 bytes. lw R8, B(R0) ;; registrador R8 recebe o ;; conteúdo de B addi R8, R8, #2 ;; R8 = B + 2 sw A(R0), R8 ;; A recebe o conteúdo de R8 ;; que é B + 2 Comentário: Um rótulo é um símbolo definido pelo programador ou pelo compilador e corresponde a um endereço de memória. Pode então ser utilizado como operando imediato para, junto com um registrador, referenciar as variáveis na memória com as instruções de load e store. Depois do conteúdo da variável B ser armazenado no registrador temporário R8, ele é adicionado à constante especificada (2) e então seu conteúdo é armazenado na posição de memória correspondente à variável A. Não existe uma instrução em linguagem de montagem do DLX que faça uma operação a- ritmética diretamente entre variáveis armazenadas na memória. c) A = (B + C) (D + E); Hipótese: As variáveis inteiras A, B, C, D e E estão armazenadas nos registradores R1, R2, R3, R4 e R5. add R8, R2, R3 add R9, R4, R5 sub R1, R8, R9 ;; registrador R8 recebe B + C ;; registrador R9 recebe D + E ;; A recebe R8 R9 ;; que é (B+C) (D+E)

Comentário: Como as variáveis estão armazenadas em registrador não é necessário que seja feita sua leitura da memória. Neste caso a solução implica apenas em somar as variáveis armazenadas nos registradores, colocando os resultados intermediários em registradores temporários. Esses valores intermediários (R8 e R9) são finalmente subtraídos e o resultado é colocado em R1, que armazena a variável A. d) C = B + A[8]; Hipótese: As variáveis B e C estão armazenadas na memória nos endereços definidos pelos rótulos B e C. O vetor A possui o primeiro elemento armazenado do endereço 100 de memória. Todas as variáveis armazenam 1 byte cada. addi R16, R0, #100 ;; R16 recebe o endereço de A[0] lb R8, 8(R16) ;; registrador R8 recebe A[8] lb R9, B(R0) ;; registrador R9 recebe B add R10, R8, R9 ;; R10 = B + A[8] sb C(R0), R10 ;; C = R10 Comentário: A maior dificuldade neste caso consiste no cálculo do endereço de memória do elemento A[8]. Para isto é necessário saber a posição do primeiro elemento (A[0]) e o tamanho de cada elemento do vetor. Como cada elemento possui apenas 1 byte, basta apenas somar 8 (8x1) ao endereço do elemento A[0] para obter o endereço de A[8]. A instrução lb permite que esta soma seja feita automaticamente, não sendo necessária nenhuma operação adicional para este cálculo. O conteúdo de A[8] é copiado para um registrador temporário (R8), que é então somado à variável B (R9) e o resultado (R10) é guardado na variável C. e) A[12] = B + A[8]; Hipótese: A variável B está armazenada na memória. O vetor A tem o seu endereço inicial definido pelo rótulo A. Todas as variáveis armazenam 4 bytes. addi R16, R0, A ;; R16 = endereço de A[0] lw R8, 32(R16) ;; R8 = A[8] lw R9, B(R0) ;; R9 = B add R8, R9, R8 ;; R8 = B + A[8] sw 48(R16), R8 ;; A[12] = R8 Comentário: Este exemplo é similar ao anterior, sendo necessário o uso de uma instrução adicional sw para armazenar o resultado no elemento A[12]. No cálculo do endereço de A[8] e A[12] deve-se levar em conta que cada elemento contém 4 bytes, logo deve-se multiplicar cada índice por 4 para determinar as constantes a serem utilizadas nas instruções lw e sw. f) C = B + A[i]; Hipótese: O vetor A e as variáveis B, C estão armazenadas em memória. A variável i está armazenada em R1. Todas as variáveis armazenam 4 bytes.

addi R16, R0, A ;; R16 = endereço de A[0] add R9, R1, R1 ;; R9 = i + i add R9, R9, R9 ;; R9 = 2i + 2i (R9 = 4i) add R17, R16, R9 ;; R17 = endereço de A[i] lw R8, 0(R17) ;; R8 = A[i] lw R7, B(R0) ;; R7 = B add R9, R8, R7 ;; R9 = A[i] + B sw C(R0), R9 ;; C = R9 Comentário: Neste exemplo a maior dificuldade é o cálculo do endereço de memória do elemento A[i]. Como i é uma variável, cujo valor a princípio desconhecemos, deve-se multiplicar o seu valor por 4 e então somar ao endereço inicial do vetor A. As quatro primeiras instruções fazem esse cálculo. A instrução lw que carrega o valor de A[i] no registrador deve ser utilizada com a constante 0 pois a arquitetura DLX não possui modo de endereçamento indexado, como iremos ver na seção 5.4, ítem d. g) if (A = = B) { A = B + C; } D = D - B; Hipótese: As variáveis de A até D estão armazenadas nos registradores de R1 até R4, respectivamente. sub R8, R1, R2 ;; R8 = A - B bnez R8, L1 ;; Se R8! = 0 então PC = L1 add R1, R2, R3 ;; Se A = = B executa L1: sub R4, R4, R2 ;; D = D B (é sempre executado) Comentário: Este caso é o de um if simples, onde a sentença guardada (dentro do if) só será executada se a condição for verdadeira. Se A e B forem iguais o resultado (R8) será zero. O teste do desvio deve verificar se o conteúdo de R8 é diferente de zero, quando a instrução guardada deverá ser pulada. A última sentença do programa em alto nível (D = D B) deverá ser sempre executada. h) if (A = = B) D = B + C; else D = C B; Hipótese: a mesma do exemplo anterior seq R8, R1, R2 ;; Se A == B então R8 = 1 beqz R8, ELSE ;; desvia para ELSE se A! = B add R4, R2, R3 ;; não executa se A! = B j FIM ;; tem que pular o ELSE ELSE: sub R4, R3, R2 ;; não executa se A = = B FIM: nop

Comentário: Este caso é o de um if completo, com os dois ramos: then e else. Nesta situação, caso um ramo seja executado, o outro não poderá ser executado. Para a comparação foi utilizada a instrução seq do DLX, que coloca em 1 o registrador destino se a condição for verdadeira. No final do trecho de código correspondente ao then deve haver uma instrução de desvio incondicional (j) para que o trecho correspondente ao else não seja também executado. i) i = 0; do { A = A +( B[i]/2); i = i +1; } while ( i < 10 ); Hipótese: A variável i está armazenada no registrador R1 e a variável A e o vetor B estão armazenados em memória. Todas as variáveis armazenam 4 bytes. addi R16, R0, B ;; R16 = endereço de B[0] addi R1, R0, R0 ;; i = 0 LACO: slli R8, R1, #2 ;; R8 = 4i add R17, R16, R8 ;; R17 = endereço de B[i] lw R8, 0(R17) ;; R8 = B[i] srli R8, R8, #1 ;; R8 = B[i] /2 lw R9, A(R0) ;; R9 = A add R8, R8, R9 ;; R8 = A + B[i]/2 sw A(R0), R8 ;; A = R8 addi R1, R1, #1 ;; i = i +1 slti R8, R1, #10 ;; Se R1 < 10 então R8 = 1 bnez R8, LACO ;; Se R8! = 0 então PC = LACO Comentário: O comando do testa a condição depois que entrar no laço. Neste exemplo, antes de se entrar no laço do programa, o endereço inicial do vetor B é carregado em R16 e depois o valor 0 é atribuído à variável i. Um dos problemas deste exemplo é calcular o endereço do elemento B[i]. Para isso, o valor de valor de i deve ser multiplicado por 4 para ser somado ao endereço armazenado em R16, de modo a obter-se o endereço de B[i]. O conteúdo de B[i] é carregado em R8, dividido por 2 com uma instrução de deslocamento e somado ao conteúdo da variável A, que anteriormente foi carregado em R9. Depois o resultado é novamente armazenado na memória no endereço correspondente à variável A. O índice i é incrementado e verificado o número total de iterações previstas para o laço (10) foi alcançado. j) for ( i = 0, i < 10, i++) { A = A + B[i]/2; } Hipótese: A variável i está armazenada no registrador R1 e a variável A e o vetor B estão armazenados em memória. Todas as variáveis armazenam 4 bytes.

addi R16, R0, B ;; R16 = endereço de B[0] addi R1, R0, R0 ;; i = 0 ;; Verifica se é a ultima iteração LACO: slti R8, R1, #10 ;; Se R1 < 10 então R8 = 1 beqz R8, FIM ;; Se R8 == 0 então PC= FIM slli R8, R1, #2 ;; R8 = 4i add R17, R16, R8 ;; R17 = endereço de B[i] lw R8, 0(R17) ;; R8 = B[i] srli R8, R8, #1 ;; R8 = B[i] /2 lw R9, A(R0) ;; R9 = A add R8, R8, R9 ;; R8 = A + B[i]/2 sw A(R0), R8 ;; A = R8 addi R1, R1, #1 ;; i = i +1 j LACO ;; Retorna para o início do laço FIM: nop ;; Saída Comentário: O comando for testa a condição antes de entrar no laço. Neste exemplo, antes de se entrar no laço do programa, o endereço inicial do vetor B é carregado em R16 e depois o valor 0 é atribuído à variável i. Um dos problemas deste exemplo é calcular o endereço do elemento B[i]. Para isso, o valor de valor de i deve ser multiplicado por 4 para ser somado ao endereço armazenado em R16, de modo a obter-se o endereço de B[i]. O conteúdo de B[i] é carregado em R8, dividido por 2 com uma instrução de deslocamento e somado ao conteúdo da variável A, que anteriormente foi carregado em R9. Depois o resultado é novamente armazenado na memória no endereço correspondente à variável A. O índice i é incrementado e verificado o número total de iterações previstas para o laço (10) foi alcaçado. k) A seguir apresentamos o exemplo de uma pequena rotina em C que recebe os endereços iniciais de duas cadeias de caracteres como parâmetros e realiza a cópia entre as cadeias até encontrar um caractere nulo (0x0): void copia (char *x, char *y){while (*x!= 0) { *y = *x; x++; y++; }} Hipótese: 0s endereços iniciais das cadeias x e y estão em R1 e R2, respectivamente. copia: lb R6, 0(R1) ;; R1 = *x ( conteúdo da memória ) beqz R6, fim ;; se *x == \0 então termina laço: sb 0(R2), R6 ;; *y = R6 ( faz a cópia ) addi R1, R1, #1 ;; x++ ( aponta para a posição seguinte ) addi R2, R2, #1 ;; y++ ( da cadeia de origem e destino ) lb R6, 0(R1) ;; R6 = *x ( lê um novo caractere ) bnez R6, laço ;; desvia se diferente de \0 fim: jr R31 ;; retorna do procedimento Comentário: O comando while tem um comportamento semelhante ao for. O teste da condição de término deve ser feito antes da execução de qualquer instrução do laço. Se for falsa, o laço não será executado. Dado que o endereço inicial dos vetores já está em R1 e R2, o programa primeiro verifica se a cadeia de origem não está vazia, ou seja, contém apenas o caractere nulo (\0). Se houver dados para serem copiados, a leitura de um caractere da cadeia de origem é feita para um registrador temporário R6 e depois seu conteúdo

é armazenado na cadeia de destino. Os respectivos ponteiros são então incrementados, quando então a condição de saída do laço, que é encontrar um caractere igual a 0x0 na cadeia de origem, é novamente testada. A última instrução copia o conteúdo do registrador R31 para o PC e faz o retorno do procedimento. Essa instrução será estudada com maiores detalhes na seção seguinte. 5.2.2. As Instruções de Desvio em Detalhe A execução de um programa requer o uso de instruções de desvio para permitir a mudança da execução de um ponto para outro do programa. Isto é feito alterando-se o valor do apontador de instruções (PC). Existem dois tipos de desvios: condicionais e incondicionais. Na arquitetura DLX os desvios condicionais (beqz e bnez) verificam o valor de um registrador para saber se é zero ou não. Existem instruções auxiliares (do tipo scc) que comparam dois registradores e colocam como resultado o valor 1 no registrador destino quando a condição determinada pela instrução é verdadeira ou valor 0 quando é falsa. As condições que são testadas pela instrução scc são as seguintes: maior ou igual (sge), maior (sgt), menor ou igual (sle), menor (slt), igual (seq) e diferente (sne). Outros processadores possuem instruções em que a comparação entre dois registradores é feita pela própria instrução de desvio; outras comparam o valor de um registrador chamado de código de condição. O registrador de código de condição guarda o resultado da última operação realizada pela ALU, informando se o resultado foi negativo, positivo, igual a zero, e assim por diante. Qual a forma de implementação que será utilizada vai depender da escolha feita pelo projetista da arquitetura. O desvio será tomado ou não de acordo com o resultado da operação de comparação. Os desvios incondicionais (j) também alteram o valor do apontador de instruções (PC) mas, como o nome já diz, sem depender de condição alguma. 5.2.3. As Chamadas de Procedimentos As rotinas ou procedimentos são trechos de código que podem ser chamados várias vezes em um programa. Normalmente se utilizam instruções de desvio para mudar a execução de um ponto para outro do programa. As rotinas, entretanto, não podem ser chamadas desta maneira, pois ao seu término devem retornar para pontos diferentes, o que não seria possível apenas com as instruções de desvio. Existem diversas variações nas soluções propostas para resolver este problema. A maneira encontrada no DLX foi criar duas novas instruções: uma (jal) que guarda em um registrador, antes de realizar o desvio, o endereço da instrução seguinte àquela que chamou a rotina. Na arquitetura DLX esse endereço é salvo no registrador R31, que recebe o nome especial de RA (return address). Existe uma outra instrução de desvio indireto (jr) que altera o conteúdo do PC de acordo com o valor que está armazenado em um registrador. Na realidade esta instrução pode utilizar qualquer registrador mas para o retorno de uma rotina utiliza o registrador R31 como parâmetro. Assim, ao final da execução do código da rotina, uma instrução de retorno (jr R31) copia o valor salvo de volta para o PC e a execução das instruções é retomada no endereço seguinte à instrução que chamou a rotina. Com o uso deste mecanismo, a rotina pode ser chamada de vários pontos do programa principal e o retorno é feito sempre para a instrução seguinte à chamada.

5.2.4. A função da Pilha O mecanismo descrito anteriormente para a chamada de procedimentos não permite que uma rotina seja chamada a partir de uma outra rotina. O valor do endereço de retorno seria perdido quando da execução de uma nova instrução de chamada de rotina. Para resolver este problema utiliza-se salvar o valor do endereço de retorno (R31) na memória, antes de chamarmos uma nova rotina, em uma estrutura de dados chamada pilha. Outros valores que são guardados na pilha são os parâmetros adicionais para a rotina, que não cabem nos registradores. A principal característica da pilha é que os elementos colocados por último são os primeiros a serem retirados. É uma estrutura que cresce do final da memória para o começo. Existe um registrador reservado para esta função do DLX chamado de apontador de pilha (sp), que indica o endereço do último elemento no topo da pilha. Antes do uso de qualquer registrador por uma rotina, os registradores antigos, que contenham valores que já possam estar em uso pelo programa, são também salvos na pilha. Assim, os parâmetros de entrada são colocados na pilha, para serem utilizados pelas instruções na rotina. Antes de os parâmetros serem colocados na pilha, o apontador de pilha (sp) é decrementado (porque a pilha cresce no sentido inverso aos endereços da memória) com um valor igual ao tamanho total dos parâmetros que serão colocados na pilha. Algumas arquiteturas possuem instruções especiais que movem os valores para a pilha e, automaticamente, decrementam o valor do ponteiro de pilha (sp). A arquitetura DLX não possui instruções desse tipo e utiliza o registrador R29 como ponteiro de pilha. 5.2.5. As Chamadas ao Sistema Operacional O Sistema Operacional é um programa que é carregado quando o computador é ligado. A sua função é gerenciar e compartilhar os recursos do computador (memória, dispositivos de E/S, etc.) entre os diversos programas em execução (processos) no computador. O Sistema Operacional tem também uma função de proteção, ou seja, evitar que um programa de usuário interfira em programas ou arquivos de outro usuário, se não tiver autorização para isso. Para que o Sistema Operacional possa realizar estas funções é preciso que existam funções adequadas no processador. Entre elas, destacamos a existência de dois modos de execução dos programas: um normal e outro privilegiado. Os programas de usuário executam em modo normal, isto é, algumas instruções não podem ser executadas, o acesso aos periféricos é restrito e o programa pode ver apenas a área de memória que foi reservada pelo Sistema Operacional. As tarefas mais sensíveis e/ou repetitivas devem ser executadas pelo Sistema Operacional. Os programas do núcleo do S.O. executam em modo privilegiado, podem fazer acesso a todos os dispositivos de E/S e a toda memória. A interface com o Sistema Operacional é feita através de uma instrução especial (chamada trap), que muda o estado da máquina para privilegiado, mas desvia imediatamente para endereços pré-fixados de rotinas do núcleo do S.O.. Um ou mais parâmetros podem ser passados em registradores, de modo a orientar o Sistema Operacional sobre que tarefas são desejadas. Ao receber esse pedido, o Sistema Operacional verifica se o usuário tem privilégios adequados para o serviço que solicitou. Por exemplo, se o programa de usuário solicita a

abertura de um arquivo para escrita, os atributos do arquivo são verificados para saber se aquele usuário é o dono do arquivo e, caso não seja, se o seu dono permite que outros usuários possam escrevê-lo. Se as permissões estiverem de acordo, o serviço é então realizado. Depois de realizar as tarefas solicitadas, o Sistema Operacional retorna o controle para o programa de usuário, através de uma instrução de retorno especial, rett, que muda o modo do processador para o estado normal ao ser executada. A próxima instrução a ser executada nesse retorno está no endereço seguinte à instrução de trap que fez a chamada ao S.O.. 5.2.6. Instruções de Ponto Flutuante Além das instruções que manipulam valores inteiros, os processadores necessitam ter instruções específicas para operar com valores reais. Normalmente esses dados estão no formato IEEE 754, adotado por quase todos os computadores a partir de 1980. Essas instruções são chamadas de instruções de ponto flutuante. As instruções de ponto flutuante fazem uso, normalmente, de registradores especiais, denominados de registradores de ponto flutuante, de onde são lidos/escritos os operandos das instruções. O principal motivo para a separação das instruções em inteiras e de ponto flutuante, é que as últimas necessitam de circuitos muito mais complexos para realizarem as operações a- ritméticas, o que resulta em um tempo muito maior de execução. Como os números inteiros representam uma classe muito grande dos problemas resolvidos por computador, foram criadas duas classes de instruções, para que as instruções inteiras pudessem ser executadas mais rapidamente. 5.3. O Formato das Instruções em Linguagem de Máquina As instruções em linguagem de montagem são traduzidas em instruções em linguagem de máquina, em um formato binário específico para cada tipo de processador. As instruções do processador são organizadas de acordo com o especificado pelo projetista, levando em conta o histórico das máquinas produzidas pelo fabricante. No DLX, todas as instruções possuem 32 bits de largura com um código de operação de 6 bits. Basicamente há 3 tipos diferentes de instruções, apresentados a seguir de acordo com a seguinte convenção: opcode: O código da operação (6 bits) rs1: Registrador com o primeiro operando fonte (5 bits) rs2: Registrador com o segundo operando fonte (5 bits) rd: Registrador que guarda o resultado da operação (5 bits) imediato: Valor utilizado como dado imedifato (16 bits) função: Especifica uma variação da instrução básica. desloc.: Uma constante de 26 bits para ser adicionada com sinal ao valor a- tual do PC.

5.3.1. Instruções tipo-i: As instruçõe do tipo I possuem sempre um campo reservado para o dado imediato, que é uma constante de 16 bits com sinal. Além disso, possuem dois campos de 5 bits cada reservados para o registrador fonte e para o registrador destino da operação. Finalmente, como todas as instruções do DLX, possuem um campo de 6 bits que codificam a operação que será realizada pelo processador. Exemplos: loads e stores: lw, sw, lb e sb. Instruções com dado imediato: ADDI, SUBI, etc. Instruções de desvio condicional: BEQZ, BNEZ. Instruções de desvio indireto: JR. 5.3.2. Instruções tipo-r As instruções do tipo R são aquelas que possuem dois registradores como operando fontes (rs1 e rs2) e um registradror operando de escrita (rd). As instruções deste tipo possuem o campo opcode com o valor 0 e a operação que realizam está codificada no campo func, de 11 bits. Exemplos: Instruções lógicas e aritméticas de registrador para registrador: ADD, SUB, SLL, etc. Instruções de comparação: SEQ, SGT, etc. 5.3.3. Instruções Tipo-J As instruções de desvio incondicional e de chamada e retorno de procedimento são do tipo J. Para permitir uma amplitude maior nos saltos realizados, as instruções possuem um campo de 26 bits para uma constante com sinal que, em tempo de execução, será adicionada ao valor armazenado no PC.

Exemplos: Instruções de desvio incondicional: J (jump) e JAL (jump and link) Instruções de Chamada ao Sistema: TRAP Instruções de Retorno de Exceção: RFE. 5.3.4. Exemplos Algumas instruções utilizam todos os campos, e outras possuem formatos semelhantes, mas com campos diferentes. Ex: add r1, r2, r3 000000 00010 00011 00001 00000001000 and r4, r5, r6 000000 00101 00110 00100 00000010010 addi r8, r0, 10 001000 00000 01000 0000000000001010 lw R1, 10(R5) 001000 00101 00001 0000000000001010 bnez R8, 2048 001000 01000 00000 0000100000000000 j 1024 001000 00000000000000001000000000 5.4. Modos de Endereçamento As instruções podem obter os operandos necessários a cada operação através de vários modos de endereçamento, conforme descrito a seguir: a) Endereçamento Imediato: O operando (dado) está codificado na própria instrução. addi r0 r8 0x10

b) Endereçamento de Registrador: O dado está contido no registrador especificado. add r4 r2 r3 c) Endereçamento Indireto: O campo da instrução aponta para o registrador que contém o endereço do dado. Pode ser acompanhado de uma constante de deslocamento ou não, que é somada ao valor do registrador, para calcular o endereço do dado na memória. lw r4 0 (r3) d) Endereçamento Indexado: Além do registrador contendo o endereço, um outro registrador é utilizado como índice, sendo somado ao valor do registrador, para calcular o endereço de memória. Isto é utilizado, por exemplo, quando queremos endereçar os elementos de um vetor ou matriz. Este modo de endereçamento não existe no DLX. lw r4 r2 (r3) e) Endereçamento de Relativo ao PC: Neste modo de endereçamento, a instrução utiliza o valor atual do apontador de instruções, para adicionar ou subtraí-lo de um determinado valor, guardado na própria instrução ou armazenado em um registrador. j deslocamento f) Endereçamento de Pilha: Uma pilha consiste em itens de dados armazenados em ordem consecutiva na memória, que normalmente cresce do final da memória para o início. O primeiro item é denominado fundo da pilha e o último topo da pilha. São permitidas a- penas operações de pop e push para retirar ou colocar dados da pilha, respectivamente. Este modo de endereçamento não existe no DLX. push R3 5.5. Diretivas para o montador As diretivas são comandos que auxiliam o montador organizar os dados e instruções na memória de forma a obter-se uma execução adequada do programa em linguagem de montagem. Para o montador que estamos utilizando as seguintes diretivas são válidas:

.align n Alinha o dado ou instrução seguinte em uma fronteira de 2 n..ascii str.asciiz str.data <addr>.text <addr>.globl sym.byte b1,..., bn.word w1,..., wn.double n1,..., nn.space size Armazena a cadeia str na memória. Armazena a cadeia str na memória e termina com null (0x0). Indica que os itens a seguir devem ser armazenados na área de memória reservada para os dados a partir do endereço indicado. Indica que itens a seguir devem ser armazenados na área de memória reservada para as instruções a partir do endereço indicado. Declara que o rótulo sym é global, podendo ser referenciado em em outros arquivos. Armazena os bytes listados seqüencialmente na memória. Armazena as n quantidades de 32 bits em posições sucessivas de memória. Armazena os valores listados seqüencialmente na memória como número de ponto flutuante de precisão dupla. Reserva um espaço na memória equivalente em bytes ao parâmetro size.

5.6. Tabela de Instruções Instrução Formato Exemplo Significado Add R add R1, R2, R3 R1 = R2 + R3 Add Immediate I addi R1, R2, #100 R1 = R2 + 100 And R and R1, R2, r3 R1 = R2 AND R3 And Immediate I andi R1, R2, #100 R1 = R2 AND 100 Subtract R sub R1, R2, R3 R1 = R2 - R3 Sub Immediate I subi R1, R2, #100 R1 = R2-100 Or R or R1, R2, R3 R1 = R2 OR R3 Or Immediate I ori R1, R2, #100 R1 = R2 OR 100 Xor R xor R1, R2, R3 R1 = R2 XOR R3 Xor Immediate I xori R1, R2, #100 R1 = R2 XOR 100 Branch on Equal I beqz R1, desvio Se (R1 == 0) faça PC = desvio Zero senão PC = PC+ 4 Branch on Not I bnez R1, desvio Se (R1!= 0) faça PC = desvio Equal Zero senão PC = PC + 4 Jump J j desvio PC = desvio (desvia para desvio) Jump and Link J jal desvio R31 = PC + 4; PC = desvio (chamada de procedimento) Jump Register I jr R31 PC = R31 (desvia para o endereço em R31) (retorno de procedimento) Jump and Link Register I jalr R15 R31 = PC+ 4; PC = R15 (chamada de procedimento em R15) Set If Equal R seq R1, R2, R3 Se (R2 == R3) então R1 = 1 senão R1 = 0 Set if Equal to Immediate I seqi R1, R2, #10 Se (R2 == 10) então R1 = 1 senão R1 = 0 Set if less than or equal R sle R1, R2, R3 Se (R2 <= 10) então R1 = 1 senão R1 = 0 Set if Less than or Equal to Immediate I slei R1, R2, #10 Se (R2 <= 10) então R1 = 1 senão R1 = 0 Set if Less than R slt R1, R2, R3 Se (R2 < 10) então R1 = 1 senão R1 = 0 Set if less than immediate I slti R1, R2, #10 Se (R2 < 10) então R1 = 1 senão R1 = 0 Load word I lw R1, 100(R2) R1 = Memória [R2+ 100] ( lê 4 bytes) Store word I sw 100(R2), R1 Memória [R2+ 100] = R1 (escreve 4 bytes) Load byte I lb R1, 200(R2) R1 = Memória [R2+ 200] (lê 1 byte) Store byte I sb 200(R2), R1 Memória [R2+ 200] = R1 (escreve 1 byte) Load High I lhi R1, #1024 R1 = 1024 << 16 Shift Left Log. R sll R1, R2, R3 R1 = R2 << R3 (R1 = R2 * 2 ** R3) Shift Left Log. Imm. I slli R1, R2, #2 R1 = R2 << 2 (R1 = R2 * 4) Shift right arithmetic R sra R1, R2, R3 R1 = R2 >> R3 (R1 = R2 / (2 ** R3)) (o sinal é replicado à esquerda) Shift Right Arit. Imm I srai R1, R2, #5 R1 = R2 >> 4 (R1 = R2 / 32) (idem) Sift Right Logical R srl R1, R2, R3 R1 = R2 >> R3 (R1 = R2 / (2**R3)) ( 0 s são colocados a esquerda) Shift Right Log. Imm I srli R1, R2, # 4 R1 = R2 >> 4 (R1 = R2 / 16) (idem) Trap trap #5 Desvia para o sistema operacional. Tabela 3 Instruções do DLX