Organização de Computadores Antônio Borges / Gabriel P. Silva 5. A Linguagem de Montagem do DLX
“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 5.1. Introdução
Figura 8 – Diagrama de Compilação
Objeto: Programa em Linguagem de Máquina
Compilador
Montador
Objeto: Rotinas da Biblioteca (em linguagem de máquina)
Programa em Lin-guagem de Monta-gem Ligador Programa Executável Carregador Memória Programa em Lin-guagem de Alto Nível
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 é es-pecífica para cada tipo de processador.
Em seguida, o programa é traduzido da linguagem de montagem para a linguagem de máqui-na pelo montador. Normalmente para cada para de arquitetura/sistema operaciomáqui-nal, existe ape-nas 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 cha-mado de programa executável, também em linguagem de máquina.
Finalmente, o programa executável é copiado para a memória principal pelo carregador (loa-der), 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ó po-de executar um programa po-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 ins-truções em linguagem de montagem.
Na página seguinte apresentamos um exemplo em linguagem de alto nível (“C”) e o seu respecti-vo 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 ge-radas, 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 utiliza-dos 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 arquite-tura DLX, e que pode ser baixado do seguinte endereço internet:
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 entra-da e saíentra-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 aponta-dor de quadro (FP – frame pointer), e registraaponta-dor R31, utilizado para guardar o endereço de retor-no nas chamadas de rotinas e procedimentos (RA – return address).
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 atri-buição deve carregar a constante 10 em um registrador temporário. Em seguida o conteú-do conteú-do registraconteú-dor é armazenaconteú-do 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 arma-zenar 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 defi-nidos 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 cor-responde 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 ;; registrador R8 recebe B + C add R9, R4, R5 ;; registrador R9 recebe D + E sub R1, R8, R9 ;; A recebe R8 – R9
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 registra-dores 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 pe-los rótupe-los 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 ins-trução lb permite que esta soma seja feita automaticamente, não sendo necessária ne-nhuma 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.
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 mul-tiplicar 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 de-ve ser utilizada com a constante 0 pois a arquitetura DLX não possui modo de endereça-mento 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
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 compa-ração foi utilizada a instrução seq do DLX, que coloca em 1 o registrador destino se a con-diçã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 va-lor de vava-lor 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, di-vidido 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.
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 mo-do a obter-se o endereço de B[i]. O conteúmo-do de B[i] é carregamo-do em R8, dividimo-do 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 carac-tere da cadeia de origem é feita para um registrador temporário R6 e depois seu conteúdo
Organização de Computadores Antônio Borges / Gabriel P. Silva é 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 maio-res 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 regis-trador para saber se é zero ou não. Existem instruções auxiliares (do tipo sCC) que com-param 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 cha-mado 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 manei-ra encontmanei-rada no DLX foi criar duas novas instruções: uma (jal) que guarda em um regis-trador, 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 alte-ra o conteúdo do PC de acordo com o valor que está armazenado em um registalte-rador. Na realidade esta instrução pode utilizar qualquer registrador mas para o retorno de uma roti-na 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 se-guinte à 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.
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 primei-ros 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 conte-nham 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 ins-truçõ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
Organização de Computadores Antônio Borges / Gabriel P. Silva 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 ins-truçõ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 ins-truções são chamadas de insins-truções de ponto flutuante.
As instruções de ponto flutuante fazem uso, normalmente, de registradores especiais, de-nominados 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 intei-ros 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.
Organização de Computadores Antônio Borges / Gabriel P. Silva
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 re-servados 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 fon-tes (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á adicio-nada ao valor armazenado no PC.
Organização de Computadores Antônio Borges / Gabriel P. Silva
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
and r4, r5, r6
addi r8, r0, 10
lw R1, 10(R5) bnez R8, 2048 j 1024 5.4. Modos de EndereçamentoAs instruções podem obter os operandos necessários a cada operação através de vários mo-dos de endereçamento, conforme descrito a seguir:
a) Endereçamento Imediato: O operando (dado) está codificado na própria instrução. 000000 00010 00011 00001 00000001000 000000 00101 00110 00100 00000010010 001000 00000 01000 0000000000001010 addi r0 r8 0x10 001000 01000 00000 0000100000000000 001000 00101 00001 0000000000001010 001000 00000000000000001000000000
Organização de Computadores Antônio Borges / Gabriel P. Silva b) Endereçamento de Registrador: O dado está contido no registrador especificado.
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.
d) Endereçamento Indexado: Além do registrador contendo o endereço, um outro registra-dor é utilizado como índice, sendo somado ao valor do registraregistra-dor, 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.
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 va-lor, guardado na própria instrução ou armazenado em um registrador.
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, respectivamen-te. Este modo de endereçamento não existe no DLX.
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:
lw r4 0 (r3)
lw r4 r2 (r3)
push R3
j deslocamento
add r4 r2 r3Organização de Computadores Antônio Borges / Gabriel P. Silva .align n Alinha o dado ou instrução seguinte em uma fronteira de 2n.
.ascii str Armazena a cadeia str na memória.
.asciiz str Armazena a cadeia str na memória e termina com “null” (0x0). .data <addr> Indica que os itens a seguir devem ser armazenados na área
de memória reservada para os dados a partir do endereço indicado. .text <addr> Indica que itens a seguir devem ser armazenados na área de
memória reservada para as instruções a partir do endereço indicado. .globl sym Declara que o rótulo sym é global, podendo ser referenciado em
em outros arquivos.
.byte b1, ..., bn Armazena os bytes listados seqüencialmente na memória. .word w1, ..., wn Armazena as n quantidades de 32 bits em posições
sucessivas de memória.
.double n1,..., nn Armazena os valores listados seqüencialmente na memória como número de ponto flutuante de precisão dupla.
Organização de Computadores Antônio Borges / Gabriel P. Silva 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
Zero
I beqz R1, desvio Se (R1 == 0) faça PC = desvio senão PC = PC+ 4 Branch on Not
Equal Zero
I bnez R1, desvio Se (R1 != 0) faça PC = desvio 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 Re-gister
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
Im-mediate
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
im-mediate
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.
