Conjunto de Instruções

Prof. Renato de Aquino Lopes

PATTERSON, D.A; HENNESSY, J.L. Organização e Projeto de Computadores: A Interface

Hardware/Software. 3a. ed. Elsevier, 2005.

Cap. 2

1
 Recordando
Modos de endereçamento:
- Imediato
- Direto
- Via Registrador
- Indireto via Registrador
- Indexado
- Base-Indexado

Via registrador, Direto MOV R7, #10

Via registrador, Indireto via registrador MOV R4, #C
Via registrador, Base Indexado MOV R2,(R7 + R4)
Via registrador, Imediato ADD R1, 8
Via registrador, Indexado LOAD R2, 4(R1)

2
 Conteúdo

●
Introdução
●
Operações no hardware do computador
●
Operandos do hardware do computador
●
Representando instruções no computador
●
Operações lógicas
●
Instruções para tomada de decisões
●
Suporte para procedimentos no hardware do computador

3
 Introdução

●
Para controlar o hardware do computador, é necessário falar a
sua linguagem
●
Palavras da linguagem do computador são chamadas de
instruções = vocabulário é chamado de conjunto de instruções
●
Apresentação das instruções através de uma abordagem top-
down
●
Linguagens de computadores são semelhantes (entre
diferentes arquiteturas), ao contrário da linguagem dos
humanos

4
 Introdução

●
Conjunto de instruções (a ponta do iceberg)
●
Exemplo: MIPS (Microprocessor without Interlocked Pipeline
Stages)
●
Conjunto de instruções criados a partir da década de 80
●
100 milhões de processadores fabricados em 2002
●
ATI, Broadcom, Cisco, NEC, Nintendo, Silicon Graphics, Sony, Texas
Instruments e Toshiba
●
Processador RISC (conjunto reduzido de instruções)
●
Tamanho de instruções fixo (fixed instruction lengths)
●
Instruções de load-store (load-store instruction sets)
●
Modos de endereçamento limitado (limited addressing modes)
●
Operações limitadas (limited operations)

5
 Introdução

●
Arquiteturas de programa armazenado
●
Controle (Control) necessita
●
1. Instruções de entrada da memória
●
2. Sinais para controlar o fluxo de informação entre os componentes do
caminho de dados
●
3. Sequenciamento de instruções
●
Caminho de dados (Datapath) tem
●
Componentes - unidades funcionais e banco de registradores
●
Interconexões - componentes que são conectados de forma que as
instruções possam ser executadas e os dados possam ser trazidos e
armazenados na memória

6
Introdução

Busca

Executa Decodifica

7
MIPS R3000 ISA (Arquitetura do Conjunto de Instruções)

Registradores
 Tipos de instrução
 Movimentação de Dados (Load/Store)
R0 - R31
 Aritmética e Lógica
 Saltos e Desvios (Jump and Branch)
 Ponto flutuante
- co-processor PC
 Gerenciamento de memória HI
 Especial LO

Formatos de instrução: todos com 32 bits

OP rs rt rd sa funct

OP rs rt immediate

OP jump target

8
Operações no hardware do computador

9
 Operações do hardware do computador

●
Todo computador precisa realizar operações aritméticas
●
add a, b, c
●
Instrui o computador para realizar a soma entre as variáveis b e
c e armazenar o resultado em a
●
Exemplo: colocar a soma (b, c, d, e) na variável a:
●
Em linguagem de alto nível
●
a=b+c+d+e
●
Em Assembly MIPS:
●
add a, b, c # soma b+c é colocada em a
●
add a, a, d # soma b+c+d está em a
●
add a, a, e # soma b+c+d+e está em a

10
 Operações de hardware do computador

●
O número natural de operandos para uma operação de adição
é três
●
Exigir que cada instrução tenha exatamente três operandos
nem mais nem menos,
●
manter o hardware simples → o hardware para um número variável de
operandos é mais complicado do que o hardware para um número fixo:

●
Princípio de projeto 1
●
Simplicidade favorece a regularidade

11
 Operações no hardware do computador

●
Compilando duas instruções de atribuição C no MIPS:
●
a = b + c;
●
d = a – e;
●
A tradução é realizada pelo compilador (MIPS):
●
add a, b, c
●
sub d, a, e
●
Agora tente você:
●
f = (g + h) – (i + j)
●
Como ficaria a tradução para o MIPS?

12
COMPILANDO UMA INSTRUÇÃO COMPLEXA NO MIPS

●
Compilando uma instrução complexa no MIPS
●
f = (g + h) – (i + j)
●
O compilador precisa desmembrar essa instrução em várias
instruções assembly, pois somente uma operação é realizada
por instrução MIPS
●
add t0, g, h # var. temp. t0 contém g+h
●
add t1, i, j # var. temp. t1 contém i+j
●
sub f, t0, t1 # f recebe t0 – t1
●
Note que uma expressão na linguagem C gera 3 instruções
assembly para o MIPS

13
Operandos no hardware do computador

14
 Operandos no hardware do computador
●
Os operandos das instruções aritméticas precisam estar
armazenados em um grupo limitado de locais especiais,
embutidos diretamente no hardware, chamados registradores
(registers)
●
Os registradores são os tijolos da construção do computador
●
primitivas usadas no projeto do computador
●
visíveis para o programador
●
O MIPS possui 32 registradores
●
Cada registrador possui 32 bits
●
Grupos de 32 bits ocorrem com tanta frequência no MIPS que recebem
o nome de palavra (word)
●
Grupos específicos de registradores. Por enquanto:
– $s0, $s1, …, $s7 → correspondem as variáveis dos programas C e Java
– $t0, $t1, ..., $t7 → registradores temporários necessários para compilar o
programa

15
 Operandos no hardware do computador

Nome Numero do Uso Valor preservado

registrador
$zero 0 Constante 0 n.a.

$at 1 Reservado p/ montador n.a.

$v0 - $v1 2-3 Valores retornados não

$a0 - $a3 4-7 Argumentos sim

$t0 - $t7 8-15 Temporários não

$s0 - $s7 16-23 Valores salvos sim

$t8 - $t9 24-25 Temporários não

$gp 28 Ponteiro global sim

$sp 29 Ponteiro p/ pilha sim

$fp 30 Ponteiro p/ quadro sim

$ra 31 Endereço de retorno sim

16
 Operandos no hardware do computador
●
Uma diferença entre variáveis de um programa em linguagem
de alto nível e os registradores é que o número de registradores
é limitado
●
O computador MIPS tem 32 registradores
●
Princípio de projeto 2:
●
Menor significa mais rápido

●
Uma quantidade muito grande de registradores pode aumentar o tempo
do ciclo de clock simplesmente porque os sinais eletrônicos levam mais
tempo quando precisam atravessar uma distância maior
●
Deve-se equilibrar o “desejo” dos programas por mais
registradores com o desejo do projetista de manter o ciclo de
clock mais rápido
●
Um número maior de registradores necessita de um número
maior de bits para representação: influência no tamanho da
instrução
17
COMPILANDO UMA ATRIBUIÇÃO EM C USANDO REGISTRADORES

●
Compilando uma atribuição em C usando registradores:
●
f = (g + h) – (i + j)
●
As variáveis f, g, h, i e j estão associadas aos registradores
$s0, $s1, $s2, $s3 e $s4 respectivamente
●
Código MIPS compilado:
●
add $t0, $s1, $s2 # reg. $t0 contém g + h
●
add $t1, $s3, $s4 # reg. $t1 contém i + j
●
sub $s0, $t0, $t1 # reg. $s0 contém $t0 - $t1, que é (g + h) – (i + j)

18
 Operandos no hardware do computador

●
Operandos na memória
●
Operações aritméticas só ocorrem com os registradores nas
instruções MIPS;
●
o MIPS deve ter instruções que transferem os dados entre o
processador e a memória: instruções de transferência de dados
●
Para acessar uma word na memória, é necessário passar o
endereço de memória a ser utilizado

19
 Operandos no hardware do computador

●
A instrução que copia dados da memória para um registrador
tradicionalmente é chamada de load
●
O formato da instrução load é o nome da operação seguido
pelo registrador a ser carregado, depois uma constante e o
registrador usado para acessar a memória.
●
A soma da parte constante da instrução com o conteúdo do
segundo registrador forma o endereço de memória

20
COMPILANDO UMA INSTRUÇÃO QUANDO UM OPERANDO ESTA NA MEMÓRIA

●
A é uma sequência de 100 words e que o compilador tenha
associado as variáveis g e h aos registradores $s1 e $s2.
●
O endereço inicial da sequencia está no endereço armazenado em
$s3 (endereço base)
●
g = h + A[8]; // código em linguagem C
●
embora haja uma única operação nessa instrução de atribuição,
um dos operandos está na memória
●
precisamos transferir A[8] para um registrador ($s3 contém elemento base) :
●
lw $t0, 8($s3) #registrador temporário $t0 recebe A[8]
– Constante → offset
– Registrador somado ao offset → registrador de base
●
A instrução seguinte (add) pode operar sobre o valor em $t0, já
que é um registrador:
●
add $s1, $s2, $t0
●
Porém...
21
 Interface hardware/software
●
Além de associar variáveis a registradores, o compilador aloca estrutura de
dados, como vetores, em locais na memória
●
Bytes de 8 bits são úteis em muitos programas
– a maioria das arquiteturas endereça bytes individuais
●
Endereços de words combinam os endereços dos 4 bytes dentro da palavra (32 bits)
●
No MIPS, palavras precisam começar em endereços que sejam múltiplos de 4
●
Restrição de Alinhamento

Para endereçar uma word

Big endian → Utiliza o endereço do
bite mais a esquerda (MIPS)
7 Little endian → Utiliza o endereço do
6 byte mais a direita
palavra
5
4
3
2
palavra
1
0

Byte (8 bits)
22
 Operandos no hardware do computador
●
No MIPS, palavras precisam começar em endereços que sejam
múltiplos de 4 (restrição de alinhamento)
●
O endereçamento em bytes afeta o índice do array: para obter
o endereço em bytes de maneira apropriada o offset necessita
ser igual a 4x8=32
●

●
A instrução complementar ao load chama-se store; ela copia
dados de um registrador para a memória
●
A instrução store é representada pelo mnemônico sw
23
 Operandos no hardware do computador

●
Compilando com load e store
●
Suponha que a variável h esteja associada ao registrador $s2 e o
endereço base do vetor A esteja armazenado em $s3. Qual código
assembly do MIPS para a instrução de atribuição C a seguir?
– A[12] = h + A[8]
●
Embora seja uma instrução na linguagem C, dois operandos estão na
memória; são necessárias instruções para buscar os dois operandos da
memória:

lw $t0, 32($s3) # reg. temp. $t0 recebe A[8]

add $t0, $s2, $t0 # reg. temp. $t0 recebe h + A[8]
sw $t0, 48($s3) # armazena resultado em A[12]

24
 Operandos no hardware do computador
●
Interface hardware/software
●
Muitos programas têm mais variáveis do que os computadores têm
registradores
●
O compilador tenta manter as variáveis mais utilizadas nos
registradores e coloca as restantes na memória, usando load e store
para movimentar os dados
●
O processo de colocar variáveis menos utilizadas na memória ou
aquelas que só serão empregadas mais tarde é denominado spilling
registers
●
Registradores, apesar de serem mais reduzidos e terem um tamanho
menor que a memória principal, são mais rápidos: isso define a
preocupação com a utilização correta dos registradores
●
Constantes ou operandos imediatos
●
Muitas vezes, os valores que necessitam ser trabalhados são passados
na instrução como constantes, e não como endereços de memória;
quando os dados são passados dessa forma, como constantes, é
utilizado o modo de endereçamento imediato
25
 Operandos no hardware do computador

●
Trabalhando com constantes
●
Usando apenas instruções, teríamos de ler uma constante da memória
para utilizá-la:
– lw $t0, EndConstante4($s1)
– add $s3, $s3, $t0
●
Supondo que EndConstante4 seja o endereço de memória para a
constante 4
●
Uma alternativa que evita a instrução load, e assim uma leitura em
memória, é oferecer instruções aritméticas em que o operando seja
uma constante
●
Essa instrução (no caso de uma soma) é chamada de add imediato, ou
addi:
– addi $s3, $s3, 4 # $s3 = $s3 + 4

26
 Operandos no hardware do computador

●
Trabalhando com constantes (cont.)
●
Princípio de projeto 3:
●
Agilize os casos mais comuns

●
Os operandos com constantes ocorrem com bastante frequência e,
incluindo constantes dentro das instruções aritméticas, as operações
tornam-se mais rápidas para serem executadas

27
 Assembly do MIPS

Assembly do MIPS
Categoria instrução Exemplo Significado Comentários
Aritmética add Add $s1, $s2, $s3 $s1 = $s2 + $s3 Três operandos;
Dados nos registradores
subtract Sub $s1, $s2, $s3 $s1 = $s2 - $s3 Três operandos;
Dados nos registradores
Transf. de load word Lw $s1, 100($s2) $s1 = Memória[$s2 + 100] Dados da memória para
dados o registrador
store word Sw $s1, 100($s2) Memória[$s2 + 100] = $s1 Dados do registrador
para a memória

28
 Exercícios

●
(1) Compile o código a seguir escrito em linguagem C
f = (g + h) – (i + j – k)
●
Considere que as variáveis f, g, h, i, j e k estão associadas aos
registradores $s0, $s1, $s2, $s3, $s4, $s5 respectivamente.

●
(2) Compile o código a seguir escrito em linguagem C
V[10] = h + V[2]
Considere que a variável h esta associada ao registrador $s1 e
o registrador $t0 contém o endereço de V[0] (registrador de
base)

29
Representando instruções no computador

30
 Representando instruções no computador

●
Embora quando programa-se em assembly utiliza-se
mnemônicos (como lw, sw, add e sub), as instruções são
representadas e executadas através de um conjunto de bits
●
Além disso, como os registradores são parte de quase todas as
instruções, é preciso haver uma convenção para mapear os
nomes dos registradores em números binários
●
$s0 a $s7 são mapeados nos registradores de 16 a 23;
●
$t0 a $t7 são mapeados nos registradores de 8 a 15;

31
 Representando instruções no computador
●
Traduzindo uma instrução assembly MIPS para uma instrução de
máquina:
●
add $t0, $s1, $s2

0 17 18 8 0 32

●
Cada um desse segmentos de uma instrução é chamado campo;
o primeiro e o último campos combinados dizem ao computador
MIPS que essa instrução realiza soma
●
O segundo campo indica o número do registrador que é o
primeiro operando de origem da operação de soma (17 = $s1)
●
O terceiro campo indica o outro operando de origem (18 = $s2)
●
O quarto campo contém o número do registrador que receberá o
resultado (8 = $t0)
●
O quinto campo não é empregado nessa instrução
32
 Representando instruções no computador

●
Para diferenciar do assembly chamamos a versão numérica da
instrução de LINGUAGEM DE MÁQUINA
●
A sequencia de instrução em linguagem de máquina é
denominada de CÓDIGO DE MÁQUINA

33
 Representando instruções no computador
●
Esse layout da instrução é chamado de formato de instrução
●
As instruções no MIPS tem todas 32 bits de tamanho
●
Os campos do MIPS
OP RS RT RD SHAMT FUNCT

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

●
op: operação básica, tradicionalmente chamada de opcode
●
rs: o registrador do primeiro operando de origem
●
rt: o registrador do segundo operando de origem
●
rd: o registrador do operando de destino
●
shamt: shift amount; quantidade de deslocamento
●
funct: função;
– seleciona a variante específica da operação no campo op (código de função)
34
 Representando instruções no computador
●
Problemas de endereçamento
●
Existe um problema quando uma instrução precisa de campos maiores
do que aqueles mostrados. Por exemplo, a instrução lw precisa
especificar dois registradores e uma constante; se o endereço tivesse
apenas 5 bits do formato anterior, a constante estaria limitada a 32 (2^5)
●
Existe então um conflito entre o desejo de manter todas as instruções
com o mesmo tamanho e o desejo de ter uma instrução único

●
Princípio de Projeto 4
●
Um bom projeto exige bons compromissos

●
O compromisso escolhido pelos projetistas do MIPS é manter todas as
instruções com o mesmo tamanho, exigindo assim diferentes formatos
para os campos para diferentes tipos de instruções
●
O formato anterior é chamado de tipo R (de registrador) ou formato R.
●
Um segundo tipo de formato de instrução é chamado de formato I,
utilizando pelas instruções imediatas e de transferência de dados.
35
 Representando instruções no computador
●
Formato I
OP RS RT Constante ou endereço

(6 bits) (5 bits) (5 bits) (16 bits)

●
O endereço de 16 bits significa que uma instrução lw pode carregar qualquer
word dentro de uma região de +/- 2^15 do endereço do registrador base
(8192 words)
●
De modo semelhante, a soma imediata é limitada a constantes que não
sejam maiores do que 2^15

– lw $t0, 32($s3)

●
Aqui, 19 (para $s3) é colocado no campo rs, 8 (para $t0) é colocado no
campo rt e 32 é colocado no campo de endereço (veja que o formato mudou:
o campo rt especifica o registrador de destino, que recebe o resultado do lw

36
 Representando instruções no computador

●
Traduzindo do assembly MIPS para a linguagem de máquina
●
Se $t1 possui a base do array A e $s2 corresponde a h:
●
A[300] = h + A[300];
●
É compilada para:
lw $t0, 1200($t1) # reg. $t0 recebe A[300]
add $t0, $s2, $t0 # reg. $t0 recebe h + A[300]
sw $t0, 1200($t1) # armazena h +A[300] na mem.
35 9 8 1200

0 18 8 8 0 32

43 9 8 1200

100011 01001 01000 0000 0100 1011 0000

000000 10010 01000 01000 00000 100000

101011 01001 01000 0000 0100 1011 0000 37
 Representando instruções no computador

●
A instrução lw é representada por 35 no opcode
●
O registrador base 9 ($t1) é especificado no segundo campo
(rs) e o registrador de destino 8 ($t0) é especificado no terceiro
campo (rt)
●
O offset para selecionar A[300] (1200=300x4) aparece no
campo final
●
A instrução add é especificada com opcode 0 e funct 32
●
A instrução sw é identificada com 43 no opcode
●
Importante: lembre-se que os valores estão representados em
decimal, mas na verdade são representados em binário.

38
 Representando Instruções no Computador
Instrução Formato op rs rt rd Shamt Funct endereço
add R 0 reg reg reg 0 32dec n.a.

sub R 0 reg reg reg 0 34dec n.a.

addi I 8dec reg reg n.a. n.a. n.a. constante

lw I 35dec reg reg n.a. n.a. n.a. endereço

sw I 43dec reg reg n.a. n.a. n.a. endereço

39
Operações Lógicas

40
 Operações Lógicas
●
Embora o projeto dos primeiros computadores se concentrasse
em words completas, logo ficou claro que é útil atuar sobre
campos de bits de uma word
●
Operações lógicas servem para empacotar e desempacotar
grupos de bits em words
Operações lógicas Operadores C Operadores Java Instruções MIPS

Shift à esquerda << << sll

Shift à direita >> >> srl

AND bit a bit & & and, andi

OR bit a bit | | or, ori

NOT bit a bit ~ ~ nor

41
 Operações Lógicas

●
Operações de deslocamento (shifts)
●
Movem todos os bits de uma word para esquerda ou para direita,
preenchendo com zero os bits que ficaram vazios
●
Shift left logical:
●
sll $t2, $s0, 4 # reg $t2 = reg $s0 << 4 bits
●
O campo da instrução MIPS chamado de shamt (shift amount) é usado
nas instruções de deslocamento
●
sll é codificada com zeros nos campos op e funct, rd contém $t2, rt
contém $s0 e shamt contém 4
●
rs não é utilizado.

0(op) 0(rs) 16(rt) 10(rd) 4(shamt) 0(funct)

42
 Operações Lógicas

●
Operações de deslocamento
●
O deslocamento lógico à esquerda de i bits gera o mesmo resultado
que multiplicar por 2^i
●
Operações lógicas
●
A operação AND é útil para isolar bits de uma palavra (operações com
máscara)
–

●
Para colocar um bit em 1 em um grupo de bits, pode-se utilizar a
operação OR

43
 Operações Lógicas

●
Operações lógicas
●
Os projetistas do MIPS decidiram incluir a instrução NOR no lugar de
NOT: se um operando for zero, a instrução é equivalente a NOT:
– A NOR 0 = NOT (A OR 0) = NOT (A)
– nor $t0, $t1, $t3 # $t0 = ~($t1 | $t3)
●
O MIPS oferece instruções lógicas para trabalhar com constantes
(modo de endereçamento imediato)
– AND imediato (andi)
– OR imediato (ori)

44
Instruções para tomadas de decisão

45
 Instruções para tomadas de decisão

●
O que diferencia o computador de uma calculadora simples é a
capacidade de tomar decisões
●
Em linguagens de alto nível: if, else, goto
●
Instruções de desvio condicional no MIPS
●
Branch if equal (desvie se igual)
●
beq registrador1, registrador2, L1
●
Essa instrução significa ir até a instrução rotulada por L1 se o valor no
registrador1 for igual ao valor no registrador2
●
O rótulo é alterado pelo compilador por endereços de memória

46
 Instruções para tomadas de decisão

●
Instruções de desvio condicional no MIPS
●
Branch if not equal (desvie se não for igual)
●
Bne registrador1, registrador2, L1
●
Significa desviar o fluxo de execução para o rótulo L1 caso os valores
contidos nos registradores registrador1 e registrador2 forem diferentes
●
Compilando if-then-else em desvios condicionais
●
No segmento de código a seguir f, g, h, i e j são variáveis. Se as cinco
variáveis correspondem aos cinco registradores de $s0 a $s4, qual é o
código compilado para esta instrução if em C?
●
if (i == j) f = g + h; else f = g – h;

47
Instruções para tomadas de decisão
i=j i != j
i == j

f=g+h f=g-h

if (i == j)
Exit: f = g + h;
else
f = g – h;
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit:

●
A instrução j implementa o desvio incondicional (jump)
48
 Instruções para tomadas de decisão

●
Interface hardware/software
●
Compiladores criam estruturas mais próximas a linguagem humana
como while, do until, etc.
●
Compilando um loop while em C
while (save[i] == k)
i+= 1;

●
Suponha que i e k correspondam aos registradores $s3 e $s5 e base do
vetor save esteja em $s6. Qual o código em MIPS que corresponde a
esse segmento C?

49
 Instruções para tomadas de decisão

while (save[i] == k)
i+= 1;

●
Suponha que i e k correspondam aos registradores $s3 e $s5 e
base do vetor save esteja em $s6. Qual o código em MIPS que
corresponde a esse segmento C?

loop:
sll $t1, $s3, 2 # $t1 = 4 * i
add $t1, $t1, $s6 # $t1 = endereço de save[i]
lw $t0, 0($t1) # $t0 = save[i]
bne $t0, $s5, Exit # vá para Exit se save[i] <> k
addi $s3, $s3, 1 # i += 1
j Loop
Exit:

50
 Instruções para tomadas de decisão
●
Bloco básico
●
Uma sequencia de instruções sem desvios (exceto, possivelmente no
final) e sem destinos de desvio ou rótulos de desvio (exceto,
possivelmente, no início)
●
Uma das primeiras fases da compilação é desmembrar o programa em
blocos básicos
●
Testes de igualdade em assembly MIPS
●
Comparações são realizadas de forma que a instrução compara dois
registradores e atribui 1 a um terceiro registrador se o primeiro for
menor que o segundo; caso contrário, é atribuído 0
●
Set on less than (atribuir se menor que)
●
slt $t0, $s3, $s4
●
Significa que é atribuído 1 ao registrador $t0 se o valor no
registrador $s3 for menor que o valor no registrador $s4

51
 Instruções para tomadas de decisão

●
Testes de igualdade em assembly MIPS
●
Operadores constantes são populares nas comparações
●
Como o registrador $zero sempre tem 0, pode-se comparar
com zero; para comparar com outros valores, existe uma
versão com endereçamento imediato da instrução slt:
●
slti $t0, $s2, 10 # $t0 =1 se $s2 < 10
●
Interface hardware/software
●
Os compiladores MIPS utilizam as instruções slt, slti, beq, bne e o valor
fixo 0 para criar todas as condições relativas:
– ==; !=; <; >; <=; >=.
●
Assim, as construções lógicas de linguagens de alto nível, como C e
Java, são mapeadas em instruções assembly de desvio condicional

52
 Assembly do MIPS
Categoria instrução Exemplo Significado
Aritmética Add add $s1, $s2, $s3 $s1 = $s2 + $s3

Subtract sub $s1, $s2, $s3 $s1 = $s2 - $s3

Transf. de Load word lw $s1, 100($s2) $s1 = Memória[$s2 + 100]

dados
Store word sw $s1, 100($s2) Memória[$s2 + 100] = $s1

Lógica And And $s1, $s2, $s3 $s1 = $s2 & $s3

Or or $s1, $s2, $s3 $s1 = $s2 | $s3

Nor nor $s1, $s2, $s3 $s1 = ~($s2 | $s3)

And immediate andi $s1, $s2, 100 $s1 = $s2 & 100

Or immediate ori $s1, $s2, 100 $s1 = $s2 | 100

Shift left logical sll $s1, $s2, 10 $s1 = $s2 << 10

Shift right logical srl $s1, $s2, 10 $s1 = $s2 >> 10

Desvio Branch on equal beq $s1, $s2, L If ($s1 == $s2) go to L

Condicional
Branch on not equal bne $s1, $s2, L If ($s1 != $s2) go to L

Set on less than slt $s1, $s2, $s3 If ($s2 < $s3) $s1 = 1; else $s1 = 0

Set on less than slti $s1, $s2, 100 If ($s2 < 100) $s1 = 1; else $s1 = 0
immediate
Desvio jump jL Go to L
incondicional 53
 Exercícios

●
1) Compile os trecho de código em linguagem C para o
assembly do MIPS. As variáveis a, b e c estão associadas aos
registradores $s0, $s1 e $s2 respectivamente. O registrador
$s3 contém o endereço de base do vetor V.
●
a) if( a < b )
a = b + c
else
a = a – c

●
b)
while( V[0] >= b )
V[0] = V[0]-(a + b)

54