MIPS 32 bits: arquitetura e instruções

MIPS 32 BITS
DISCIPLINA DE ARQUITETURA DE
COMPUTADORES
CURSOS DE BACHARELADO EM
ENGENHARIA DE COMPUTAÇÃO E
CIÊNCIA DA COMPUTAÇÃO
Bauru-SP
2015

Arquitetura de Computadores
Ciência da Computação
Engenharia de Computação
2
LISTA DE TABELAS
Tabela 1: Tabela de Operandos do MIPS....................................................................................................18
Tabela 2: Tabela de Instruções na Linguagem de Montagem .....................................................................18
Tabela 3: Tabela de Instruções em Linguagem de Máquina .......................................................................18
Tabela 4: Tabela de código binário dos registradores .................................................................................19
Tabela 5: Tabela de código binário das instruções......................................................................................19

3
SUMÁRIO
A. RESUMO EXERCÍCIOS MIPS...............................................................................................................4
1. Compilação de um comando de atribuição............................................................................................4
2. Compilação de uma atribuição com um operando na memória ............................................................4
3. Compilação usando instruções de LOAD WORD e STORE WORD...................................................5
4. Compilação usando uma variável para indexar o ARRAY...................................................................6
5. Compilação de um comando IF em uma instrução de DESVIO CONDICIONAL ..............................7
6. Compilação de um comando IF-THEN-ELSE em DESVIOS CONDICIONAIS ................................8
7. Compilação de um LOOP contendo um ARRAY com índice variável ................................................9
8. Compilação de um LOOP WHILE......................................................................................................11
9. Compilação do Teste LESS THAN.....................................................................................................12
10. Compilação de um comando SWITCH a partir de uma tabela de endereços de DESVIO ...............14
B. OPERANDOS DO MIPS........................................................................................................................18
C. LINGUAGEM DE MONTAGEM DO MIPS ........................................................................................18
D. LINGUAGEM DE MÁQUINA DO MIPS ............................................................................................18
E. TABELA DE CONVERSÃO BINÁRIA................................................................................................19
E. EXERCÍCIOS .........................................................................................................................................19

4
A. RESUMO EXERCÍCIOS MIPS
1. Compilação de um comando de atribuição
a) Instrução
f = (g + h) – (i + j);
F = $s0, G = $s1, H = $s2, I = $s3, J = $s4
b) Linguagem de montagem
ADD $t0, $s1, $s2
ADD $t1, $s3, $s4
SUB $s0, $t0, $t1
c) Linguagem de máquina
ADD $8, $17, $18
ADD $9, $19, $20
SUB $16, $8, $9
d) Representação das instruções (Consultar as tabelas 3, 4 e 5 para fazer a representação)
TIPO INSTRUÇÃO REPRESENTAÇÃO
R ADD $t0, $s1, $s2 0 $s1 $s2 $t0 0 32
R ADD $t1, $s3, $s4 0 $s3 $s4 $t1 0 32
R SUB $s0, $t0, $t1 0 $t0 $t1 $s0 0 34
R ADD $8, $17, $18 0 $17 $18 $8 0 32
R ADD $9, $19, $20 0 $19 $20 $9 0 32
R SUB $16, $8, $9 0 $8 $9 $16 0 34
e) Código de Máquina
R ADD $t0, $s1, $s2 000000 10001 10010 01000 00000 100000
R ADD $t1, $s3, $s4 000000 10011 10100 01001 00000 100000
R SUB $s0, $t0, $t1 000000 01000 01001 10000 00000 100010
2. Compilação de uma atribuição com um operando na memória
a) Instrução
g = h + a[8];
G = $s0, H = $s1, A = $s2

5
lw $t0, 8 ($s3)
add $s1, $s2, $t0
lw $8, 8 ($19)
add $16, $17, $8
R lw $t0, 8($s3) 35 $t0 $s3 8
I add $s1, $s2, $t0 0 $s2 $t0 $s1 0 32
R lw $8, 8($19) 35 $8 $19 8
I add $16, $17, $8 0 $17 $8 $16 0 32
R lw $t0, 8($s3) 100011 010000 10011 0000 0000 0000 1000
I add $s1, $s2, $t0 000000 10001 01000 10000 00000 100000
3. Compilação usando instruções de LOAD WORD e STORE WORD
a) Instrução
a[12] = h + a[8];
A = $s0, H = $s1
lw $t0, 32($s0)
add $t0, $s1, $t0
sw $t0, 48($s0)
lw $t0, 32($s0)
add $t0, $s1, $t0
sw $t0, 48($s0)

6
I lw $t0, 32($s0) 35 $t0 $s0 32
R add $t0, $s1, $t0 0 $t0 $s1 $t0 0 32
I sw $t0, 48($s0) 43 $t0 $s0 48
I lw $8, 32($16) 35 8 16 32
R add $8, $17, $8 0 8 17 8 0 32
I sw $8, 48($16) 43 8 16 48
I lw $t0, 32($s0) 100011 01000 10000 0000 0000 0010 0000
R add $t0, $s1, $t0 000000 01000 10001 01000 00000 100000
I sw $t0, 48($s0) 101011 01000 10000 0000 0000 0011 0000
4. Compilação usando uma variável para indexar o ARRAY
a) Instrução
g = h + a[i];
G = $s0, H = $s1, A = $s2, I = $s3
add $t0, $s3, $s3 #2*i
add $t0, $t0, $t0 #4*i
add $t0, $t0, $s2 #a[i]=(4*i+$s2)
lw $t1,0($t0) #$t1=a[i]
add $s0, $s1, $t1 #g=h+a[i]
add $8, $19, $19 #2*i
add $8, $8, $8 #4*i
add $8, $8, $18 #a[i]=(4*i+$s2)
lw $9,0($8) #$t1=a[i]
add $16, $17, $9 #g=h+a[i]
R add $t0, $s3, $s3 0 $s3 $s3 $t0 0 32
R add $t0, $t0, $t0 0 $t0 $t0 $t0 0 32
R add $t0, $t0, $s2 0 $t0 $t0 $s2 0 32
I lw $t1,0($t0) 35 $t1 $t0 0
R add $s0, $s1, $t1 0 $s1 $t1 $s0 0 32

7
R add $8, $19, $19 0 $19 $19 $8 0 32
R add $8, $8, $8 0 $8 $8 $8 0 32
R add $8, $8, $18 0 $8 $18 $8 0 32
I lw $9,0($8) 35 $9 $8 0
R add $16, $17, $9 0 $17 $9 $16 0 32
R add $t0, $s3, $s3
R add $t0, $t0, $t0
R add $t0, $t0, $s2
I lw $t1,0($t0)
R add $s0, $s1, $t1
5. Compilação de um comando IF em uma instrução de DESVIO CONDICIONAL
FORMATO DA INSTRUÇÃO BEQ (branch on equal – desvie se igual):
BEQ registrador1, registrador2, endereço de desvio.
Código da operação (6bits) Registrador1 (5 bits) Registrador2 (5 bits) Endereço de desvio (16 bits)
FUNÇÃO: força um desvio para o comando com o LABEL se o valor no registrador1 for igual ao valor
no registrador2.
a) Instrução
if(i==j) go to L1;
f = g + h;
L1: f = f - i;
f = $s0; g = $s1; h = $s2; i = $s3; j = $s4
beq $s3, $s4, L1 #desvia para L1 se i = j
add $s0, $s1, $s2 #f=g+h (não executa esta instrução se i=j)
L1: sub $s0, $s0, $s3 #f=f-i (sempre executa)
beq $19, $20, L1 #desvia para L1 se i = j
add $16, $s17 $18 #f=g+h (não executa esta instrução se i=j)
L1: sub $16, $16, $19 #f=f-i (sempre executa)

8
d) Representação das instruções
END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO
80000 I beq $s3, $s4, L1 4 $s3 $s4 L1: 80008 - 80000 = 8 / 4 = 2
80004 R add $s0, $s1, $s2 0 $s1 $s2 $s0 0 32
80008 R L1: sub $s0, $s0, $s3 0 $s0 $s3 $s0 0 34
80000 I beq $s3, $s4, L1 4 $19 $20 2
80004 R add $s0, $s1, $s2 0 $17 $18 $16 0 32
80008 R L1: sub $s0, $s0, $s3 0 $16 $19 $16 0 34
e) Código de Máquina (preencher com o número binário correspondente)
80000 I beq $s3, $s4, L1
80004 R add $s0, $s1, $s2
80008 R L1: sub $s0, $s0, $s3
6. Compilação de um comando IF-THEN-ELSE em DESVIOS CONDICIONAIS
FORMATO DA INSTRUÇÃO BNE (branch not on equal):
BNE registrador1, registrador2, endereço de desvio.
Código da operação (6bits) = 5 Registrador1 (5
bits)
Registrador2 (5 bits) Endereço de desvio (16 bits)
FUNÇÃO: a próxima instrução a ser executada é aquela que estiver armazenada no endereço do LABEL
se o valor no registrador 1 for diferente do valor no registrador 2
a) Instrução
if( i == j )
f = g + h;
else
f = g – h;
f = $s0; g = $s1; h = $s2; i = $s3; j = $s4
bne $s3, $s4, Else # desvia para ELSE se I < > j
add $s0, $s1, $s2 # f = g + h (salta esta instrução se i <> k
j Exit # desvia para exit
Else: sub $s0, $s1, $s2 # f = g – h (salta esta instrução se i = j
Exit:
bne $19, $20, Else # desvia para ELSE se I < > j
add $16, $17, $18 # f = g + h (salta esta instrução se i <> k

9
Else: sub $16, $17, $18 # f = g – h (salta esta instrução se i = j
Exit:
80000 I bne $s3, $s4, Else 5 $s3 $s4 80012
80004 R add $s0, $s1, $s2 0 $s1 $s2 $s0 0 32
80008 J j Exit 2 80016
80012 I ELSE: sub $s0, $s1, $s2 0 $s1 $s3 $s0 0 34
80016 Exit:
Usamos o PC para calcular o endereço relativo da memória:
 Pegar o endereço da instrução seguinte à instrução corrente que contém o LABEL, portanto, 80.004
 Somar o endereço com 8, portanto, 80.004 + 8 = 80.012
 Portanto, o valor que devemos colocar para ELSE é o número 8
80000 I bne $19, $20, Else 5 $19 $20 8
80004 R add $16, $17, $18 0 $16 $17 $18 0 32
80008 J j Exit 2 80.016
80012 I ELSE: sub $16, $17, $18 0 $17 $18 $16 0 34
80016 EXIT:
Para J EXIT usar o próprio endereço 80.016 que pode ser representado em 26 bits (00 0000 0001 0011 1000 1001 0000)
I bne $19, $20, Else 000101 10011 10100
R add $16, $17, $18 000000 10000 10001 10010 00000 100000
J j Exit 000010 00 0000 0001 0011 1000 1001 0000
I sub $16, $17, $18 000000 10001 10010 10000 00000 100010
7. Compilação de um LOOP contendo um ARRAY com índice variável
a) Instrução
Loop: g = g + A[i];
i = i + j;
if( i != h ) go to Loop;
g = $s1; h = $s2; i = $s3; j = $s4; A = $s5
Loop: add $t1, $s3, $s3 # $T1 = 2 * i
add $t1, $t1, $t1 # $T1 = 4 * i
add $t1, $t1, $s5 # $T1 = A[i]

10
lw $t0, 0($t1) # $T0 = A[i]
add $s1, $s1, $t0 # G = G + A[I]
add $s3, $s3, $s4 # I = I + J
bne $s3, $s2, Loop # desvia para LOOP se i < > h
Loop: add $9, $19, $19 # $T1 = 2 * i
add $9, $9, $9 # $T1 = 4 * i
add $9, $9, $21 # $T1 = A[i]
lw $8, 0($9) # $T0 = A[i]
add $17, $17, $8 # G = G + A[I]
add $19, $19, $20 # I = I + J
bne $19, $18, Loop # desvia para LOOP se i < > h
8 0000
R
Loop: add $t1, $s3,
$s3
0 $s3 $s3 $t1 0 32
8 0004 R add $t1, $t1, $t1 0 $t1 $t1 $t1 0 32
8 0008 R add $t1, $t1, $s5 0 $t1 $s5 $t1 0 32
8 0012 I lw $t0, 0($t1) 43 $t1 $t0 0
8 0016 R add $s1, $s1, $t0 0 $s1 $t0 $s1 0 32
8 0020 R add $s3, $s3, $s4 0 $s3 $s4 $s3 0 32
8 0024 I bne $s3, $s2, Loop 5 $s3 $s2 Loop (8 0000)
8 0000 R add $9, $19, $19 0 $19 $19 $9 0 32
8 0004 R add $9, $9, $9 0 $9 $9 $9 0 32
8 0008 R add $9, $9, $21 0 $9 $21 $9 0 32
8 0012 I lw $8, 0($9) 43 $8 $9 0
8 0016 R add $17, $17, $8 0 $17 $8 $17 0 32
8 0020 R add $19, $19, $20 0 $19 $20 $19 0 32
8 0024 I bne $19, $18, Loop 5 $19 $18 LOOP (-24: 8 0000)
-24 POIS: 80000 - 80024 = -24. Precisa voltar pra 80000, portanto é necessário fazer PC + (-X) = PC É
80024.
80000 R add $9, $19, $19 000000
80004 R add $9, $9, $9 000000
80008 R add $9, $9, $21 000000
80012 I lw $8, 0($9)
80016 R add $17, $17, $8 000000
80020 R add $19, $19, $20 000000
80024 I bne $19, $18, Loop

11
8. Compilação de um LOOP WHILE
a) Instrução:
While( save[i] == k )
i = i +j;
Loop: add $t1, $s3, $s3 # T1 = 2 * i
add $t1, $t1, $t1 # T1 = 4 * i
add $t1, $t1, $s6 # T1 = save[i]
lw $t0, 0($t1) # T0 = save[i]
bne $t0, $s5, Exit # desvia para EXIT se save[i] < > K
add $s3, $s3, $s4 # i = i + j
j Loop # desvia para Loop
Exit;
Loop: add $9, $19, $19 # T1 = 2 * i
add $9, $9, $9 # T1 = 4 * i
add $9, $9, $s6 # T1 = save[i]
lw $8, 0($9) # T0 = save[i]
bne $8, $21, Exit # desvia para EXIT se save[i] < > K
add $19, $19, $20 # i = i + j
j Loop # desvia para Loop
Exit;
80000 R Loop: add $t1, $s3, $s3 0 $s3 $s3 $t1 0 32
80004 R add $t1, $t1, $t1 0 $t1 $t1 $t1 0 32
80008 R add $t1, $t1, $s6 0 $t1 $s6 $t1 0 32
80012 I lw $t0, 0($t1) 43 $t1 $t0 0
80016 I bne $t0, $s5, Exit 5 $t0 $s5 8
80020 R add $s3, $s3, $s4 0 $s3 $s4 $s3 0 32
80024 J j Loop 2 80000
80028 EXIT
END.MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO
80000 R Loop: add $9, $19, $19 0 $19 $19 $9 0 32
80004 R add $9, $9, $9 0 $9 $9 $9 0 32
80008 R add $9, $9, $s6 0 $9 $6 $9 0 32
80012 I lw $8, 0($9) 43 $9 $8 0
80016 I bne $8, $21, Exit 5 $8 $21 8
80020 R add $19, $19, $20 0 $19 $19 $20 0 32
80024 J j Loop 2 -24

12
80.020 + 8 = 80.028
 EXIT: Conteudo do registrador + campo do endereço (cálculo feito pela instrução de desvio condicional)
 *2 = duas instruções de distância
 PC = registrador que contém o valor da instrução corrente
 Desvios condicionais tendem a desviar para uma instrução próxima
 Quase metade de todos os desvios condicionais é para endereços situados a menos de 16 INSTRUÇÕES da origem
do desvio.
 ENDEREÇO RELATIVO AO PC = endereço relativo à instrução seguinte e não à corrente  PC + 4
Formato Instrução Representação
R add $9, $19, $19 000000 10011 10011 1001 00000 100000
R add $9, $9, $9 000000 01001 1001 1001 00000 100000
R add $9, $9, $s6 000000 01001 110 1001 00000 100000
I lw $8, 0($9) 101011 01001 1000 0000 0000 0000 0000
I bne $8, $21, Exit 000101 01000 10101
R add $19, $19, $20 000000 10011 10011 10100 00000 100000
J j Loop 000010 11 1111 1111 1111 1111 1110 1000
9. Compilação do Teste LESS THAN
FORMATO DA INSTRUÇÃO SLT (set on less than):
SLT registrador temporário, registrador1, registrador2.
Código da
operação
(6bits) = 0
Registrador a
ser
comparado 1
(5 bits)
Registrador a
ser
comparado 2
(5 bits)
Registrador
temporário (5
bits)
Shamt
(0 - 5
bits)
Código da operação
aritmética (6 bits) =
42
FUNÇÃO: compara dois valores de dois registradores diferentes e atribui o valor 1 a um terceiro
registrador se o valor do primeiro registrador for menor que o valor do segundo registrador. Caso
contrário, atribui zero.
a) Instrução: Qual o código MIPS necessário para testar se uma variável A, correspondente ao
registrador $S0, é menor que outra variável B (registrador $S1) e desviar para o LABEL LESS se
a condição for verdadeira?
slt $t0, $s0, $s1 # T0 = 1 se $s0 < $s1 (se a < b)
bne $t0, $zero, Less # desvia para Less se $t0<>0

13
slt $8, $16, $s17 # T0 = 1 se $s0 < $s1 (se a < b)
bne $8, $0, Less # desvia para Less se $t0<>0
R slt $t0, $s0, $s1 0 $s0 $s1 $t0 0 42
I bne $t0, $zero, Less 5 $t0 $zero Less
R slt $8, $16, $17 0 $16 $17 $8 0 42
I bne $8, $zero, Less 5 $8 $zero Less
R slt $8, $16, $17 000000 10000 10001 01000 00000 101010
I bne $8, $0, Less 000101 01000 00000 Less
EXEMPLO:
a) Instrução:
if ( i < j )
a = b + c;
else
a = b – c;
a = $s0, b = $s1, c = $s2, i = $s3, j = $s4
b) Linguagem de Montagem
slt $t0, $s3, $s4 # T0 = 1 se ($s0 < $s1), isto é se (a < b). T0 = 0 se
($s0 > $s1), isto é se (a > b)
bne $t0, $zero, ELSE # se ($t0<>0) desvia para ELSE, caso contrário executa
a instrução seguinte
add $s0, $s1, $s2 # a = b + c; (se $t0 <> 0)
ELSE: sub $s0, $s3, $s4 # a = b – c; (se $t0 = 0)
Exit:
c) Linguagem de Máuina
slt $t0, $s3, $s4
bne $t0, $zero, ELSE

14
add $s0, $s1, $s2
j Exit
ELSE: sub $s0, $s3, $s4
Exit:
Endereço M. Formato Instrução Representação
80000 R slt $t0, $s3, $s4 0 $s3 $s4 $t0 0 42
80004 I bne $t0, $zero, ELSE 5 $t0 $zero ELSE
80008 R add $s0, $s1, $s2 0 $s1 $s2 $s0 0 32
80012 J j Exit 2 EXIT
80016 R ELSE: sub $s0, $s3, $s4 0 $s0 $s3 $s4 0 34
80020 Exit:
80000 R slt $8, $19, $20 0 $19 $20 $8 0 42
80004 I bne $8, $zero, ELSE 5 $8 $zero ELSE
80008 R add $16, $17, $18 0 $17 $18 $16 0 32
80012 J j Exit 2 EXIT
80016 R ELSE: sub $16, $19, $20 0 $19 $20 $16 0 34
80020 Exit
e) Código de máquina
R slt $t0, $s3, $s4
I bne $t0, $zero, ELSE
R add $s0, $s1, $s2
J j Exit
R ELSE: sub $s0, $s3, $s4
Exit:
10. Compilação de um comando SWITCH a partir de uma tabela de endereços de
DESVIO
a) Instrução:
Switch (k) {
case 0:
f = i + j; // k = 0
break;
case 1:
f = g + h; // k=1
break;
case 2:
f = g – h; // k = 2
break;

15
case 3:
f = i – j; // k = 3
break;
}
###
- A variável K do comando SWITCH será usada para indexar uma tabela de
endereços de desvio, para então desviar com base no valor carregado.
- Primeiro o valor de K é testado para ter certeza de que ele é igual a
um dos valores do comando case (entre 0 e 1).
- Se não for verdade, o programa ABANDONA o comando SWITCH
###
slt $t3, $s5, $zero # testa se K < 0
bne $t3, $zero, Exit # se K < 0 desvia para EXIT
slt $t3, $s5, $t2 # testa se K < 4
beq $t3, $zero, Exit # se K >= 4 desvia para EXIT
# Primeiro precisamos multiplicar o valor de K por 4 para transformá-lo
em um endereço de BYTE
add $t1, $s5, $s5 # T1 = 2 * K
add $t1, $t1, $t1 # T1 = 4 * K
###
Suponha que quarto palavras consecutivas na memória tenham endereços
correspondentes aos labels L0, L1, L2 e L3, começando no endereço
armazenado em $T4. O endereço do desvio pode ser carregado em um
registrador, neste caso $T0
###
add $t1, $t1, $t4 # T1 = endereço de JumpTable[K]
lw $t0, 0($t1) # T0 = JumpTable[K]

16
# A execução de uma instrução de desvio para o conteúdo de um registrador
faz com que o programa passe a executar a instrução apontada na tabela de
endereços de desvio
jr $t0 # desvia com base no conteúdo de $T0
# Traduzindo os CASOS
L0: add $s0, $s3, $s4 # K = 0  f = i + j
j Exit # fim deste case, desvia para EXIT
L1: add $s0, $s1, $s2 # K = 1  f = g + h
L2: sub $s0, $s1, $s2 # K = 2  f = g - h
###
- No último case podemos eliminar o desvio para a saída do comando
SWITCH, pois as instruções deste case são as últimas do switch.
- No entanto, um LABEL EXIT deve ser pendurado depois do último comando
deste case para marcar o final do comando switch.
###
L3: sub $s0, $s3, $s4 # K = 3  f = i – j
Exit # fim do switch
slt $11, $21, $zero # testa se K < 0
bne $11, $zero, Exit # se K < 0 desvia para EXIT
slt $11, $21, $10 # testa se K < 4
beq $11, $zero, Exit # se K >= 4 desvia para EXIT
add $9, $21, $21 # T1 = 2 * K
add $9, $9, $9 # T1 = 4 * K
add $9, $9, $12 # T1 = endereço de JumpTable[K]
lw $8, 0($9) # T0 = JumpTable[K]
jr $8 # desvia com base no conteúdo de $T0
L0: add $16, $19, $20 # K = 0  f = i + j
L1: add $16, $17, $18 # K = 1  f = g + h

17
L2: sub $16, $17, $18 # K = 2  f = g - h
L3: sub $16, $19, $20 # K = 3  f = i – j
Exit # fim do switch
REPRESENTAÇÃO DA LINGUAGEM DE MONTAGEM
80000 R slt $t3, $s5, $zero 0 $s5 $zero $t3 0 42
80004 I bne $t3, $zero, Exit 5 $t3 $zero 80064
80008 R slt $t3, $s5, $t2 0 $s5 $t2 $t3 0 42
80012 I beq $t3, $zero, Exit 4 $t3 $zero 80064
80016 R add $t1, $s5, $s5 0 $s5 $s5 $t1 0 32
80020 R add $t1, $t1, $t1 0 $t1 $t1 $t1 0 32
80024 R add $t1, $t1, $t4 0 $t1 $t4 $t1 0 32
80028 I lw $t0, 0($t1) 35 $t1 $t0 0
80032 R jr $t0 0 $t0 0 0 0 8
80036 R add $s0, $s3, $s4 0 $s3 $s4 $s0 0 32
80040 R j Exit 2 80064
80044 R add $s0, $s1, $s2 0 $s1 $s2 $s0 32
80048 R j Exit 2 80064
80052 R sub $s0, $s1, $s2 0 $s1 $s2 $s0 34
80056 R j Exit 2 80064
80060 R sub $s0, $s3, $s4 0 $s3 $s4 $s0 34
80064 Exit
REPRESENTAÇÃO DA LINGUAGEM DE MÁQUINA
Formato Instrução
80000 R slt $11, $21, $zero 0 21 0 11 0 42
80004 I bne $11, $zero, Exit 5 11 0 60
80008 R slt $11, $21, $10 0 21 10 11 0 42
80012 I beq $11, $zero, Exit 4 11 0 52
80016 R add $9, $21, $21 0 21 21 9 0 32
80020 R add $9, $9, $9 0 9 9 9 0 32
80024 R add $9, $9, $12 0 9 12 9 0 32
80028 I lw $8, 0($9) 35 9 8 0
80032 R jr $8 0 8 0 0 0 8
80036 R add $16, $19, $20 0 19 20 16 0 32
80040 R j Exit 2 24
80044 R add $16, $17, $18 0 17 18 16 32
80048 R j Exit 2 16
80052 R sub $16, $17, $18 0 17 18 16 34
80056 R j Exit 2 8
80060 R sub $16, $19, $20 0 19 20 16 34
80064 Exit
e) Código de máquina
6 5 5 5 5 6
80000 R slt $11, $21, $zero 000000 10101 00000 01011 00000 101010
80004 I bne $11, $zero, Exit 000101 01011 00000
80008 R slt $11, $21, $10 000000 10101 01010 01011 00000 101010

18
80012 I beq $11, $zero, Exit 000100 01011 00000
80016 R add $9, $21, $21 000000 10101 10101 01001 00000 100000
80020 R add $9, $9, $9 000000 01001 01001 01001 00000 100000
80024 R add $9, $9, $12 000000 01001 01100 01001 00000 100000
80028 I lw $8, 0($9) 100011 01001 01000
80032 R jr $8 000000 01001 00000 00000 00000 001000
80036 R add $16, $19, $20 000000 10011 10100 10000 00000 100000
80040 R j Exit 000010 0000 0000 0000 0001 0011 1000 1001 0000
80044 R add $16, $17, $18 000000 10001 10010 10000 100000
80048 R j Exit 000010 0000 0000 0000 0001 0011 1000 1001 0000
80052 R sub $16, $17, $18 000000 10001 10010 10000 100010
80056 R j Exit 000010 0000 0000 0000 0001 0011 1000 1001 0000
80060 R sub $16, $19, $20 000000 10011 10100 10000 100010
80064 EXIT
B. OPERANDOS DO MIPS
Tabela 1: Tabela de Operandos do MIPS
Nome Exemplo Comentários
32 registradores
$s0, $s1,
$s2, $s3,
$s4, $s5,
$s6, $s7
- Posições de acesso rápido para armazenamento de dados.
- No MIPS, os dados devem estar em registradores para que aas operações aritméticas possam ser realizadas.
- Os registradores $s0 - $s7 são mapeados nos registradores reais de número 16-23 e os registradores $t0-$t7 nos
de número 8-15.
- O registrador $zero do MIPS sempre tem o valor 0 armazenado nele.
230 palavras de
memória
$t0, $t1,
$t2, $t3,
$t4, $t5,
$t6, $t7
- No MIPS, estas posições só são acessadas por instruções de transferência de dados.
- O MIPS endereça byte, de modo que endereços de palavras consecutivas diferem de 4 unidades.
- A memória armazena estruturas de dados, como arrays, além dos registradores derramados.
C. LINGUAGEM DE MONTAGEM DO MIPS
Tabela 2: Tabela de Instruções na Linguagem de Montagem
Categoria Instrução Exemplo Significado Comentários
Aritmética
add add $s1, $s2, $s3 $s1 = $s2 + $s3 Três operandos
Dados em registradoressubtract sub $s1, $s2, $s3 $s1 = $s2 – $s3
Transferencia de dados
load word lw $s1, 100($s2) $s1 = memória[$s2 + 100] Dados transferidos da
memória para registradoresstore word sw $s1, 100($s2) memória[$s2 + 100] = $s1
Desvio Condicional
branch on equal beq $s1, $s2, L se ($s1 == $s2) desvia para L
Testar a igualdade e desviar
se verdadeira
branch on not equal bne $s1, $s2, L se ($s1 != $s2) desvia para L
Testar a desigualdade e
desviar se verdadeira
set on less than slt $s1, $s2, $s3
se ($s2 < $s3)
então $s1 = 1;
senão $s1 = 0
Compare se menor ou igual
Usada junto a BEQ e BNE
Desvio Incondicional
jump j 2500 Desvia para 10000 Desviar para o endereço-alvo
jump register jr $t1 Desvia para $s1 Para comandos switch
D. LINGUAGEM DE MÁQUINA DO MIPS
Tabela 3: Tabela de Instruções em Linguagem de Máquina
Nome Formato Exemplo Comentários
add R 0 18 19 17 0 32 add $s1, $s2, $s3
sub R 0 18 19 17 0 34 sub $s1, $s2, $s3
lw I 35 18 17 100 lw $s1, 100($s2)
sw I 43 18 17 100 sw $s1, 100($s2)

19
beq I 4 17 18 25 Beq $s1, $s2, 100  divide por quatro
bne I 5 17 18 25 Bne $s1, $s2, 100  divide por quatro
slt R 0 18 19 17 0 42 Slt $s1, $s2, $s3
j J 2 2500 j 10000  multiplica por quatro
jr R 0 9 0 0 0 8 jr $t1
Tamanho do
campo
6
bits
5 bits 5 bits 5 bits 5 bits 6 bits Todas as instruções do MIPS tem 32 bits
Formato R R op rs rt rd shamt funct Formato das instruções aritméticas
Formato I I op rs rt endereço
Formato das intruções de transferência de
dados
Formato J J op Endereço-alvo Formato das intruções de desvio incondicional
E. TABELA DE CONVERSÃO BINÁRIA
Tabela 4: Tabela de código binário dos registradores
Nome do
registrador
Número do
registrador
Binário correspondente em 5 bits
16 8 4 2 1
$s0 16 1 0 0 0 0
$s1 17 1 0 0 0 1
$s2 18 1 0 0 1 0
$s3 19 1 0 0 1 1
$s4 20 1 0 1 0 0
$s5 21 1 0 1 0 1
$s6 22 1 0 1 1 0
$s7 23 1 0 1 1 1
$t0 8 0 1 0 0 0
$t1 9 0 1 0 0 1
$t2 10 0 1 0 1 0
$t3 11 0 1 0 1 1
$t4 12 0 1 1 0 0
$t5 13 0 1 1 0 1
$t6 14 0 1 1 1 0
$t7 15 0 1 1 1 1
Tabela 5: Tabela de código binário das instruções
Operação Número Decimal Número Binário em 6 Bits
ADD 32 100 000
SUB 34 100 010
OR 36 100 100
AND 37 100 101
SLT 42 101 010
BNE 4 000 100
BEQ 5 000 101
J 2 000 010
JR 8 001 000
LW 35 100 011
SW 43 101 011
E. EXERCÍCIOS

MIPS 32 bits: arquitetura e instruções

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a MIPS 32 bits: arquitetura e instruções

Semelhante a MIPS 32 bits: arquitetura e instruções (20)

Mais de Elaine Cecília Gatto

Mais de Elaine Cecília Gatto (20)

Último

Último (20)

MIPS 32 bits: arquitetura e instruções