MIPS 32 BITS

19
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

Transcript of MIPS 32 BITS

Page 1: MIPS 32 BITS

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

Page 2: MIPS 32 BITS

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

Page 3: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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

Page 4: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

Page 5: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

5

b) Linguagem de montagem

lw $t0, 8 ($s3)

add $s1, $s2, $t0

c) Linguagem de máquina

lw $8, 8 ($19)

add $16, $17, $8

d) Representação das instruções (Consultar as tabelas 3, 4 e 5 para fazer a representação)

TIPO INSTRUÇÃO REPRESENTAÇÃO

R lw $t0, 8($s3) 35 $t0 $s3 8

I add $s1, $s2, $t0 0 $s2 $t0 $s1 0 32

TIPO INSTRUÇÃO REPRESENTAÇÃO

R lw $8, 8($19) 35 $8 $19 8

I add $16, $17, $8 0 $17 $8 $16 0 32

e) Código de Máquina

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

b) Linguagem de montagem

lw $t0, 32($s0)

add $t0, $s1, $t0

sw $t0, 48($s0)

c) Linguagem de máquina

lw $t0, 32($s0)

add $t0, $s1, $t0

sw $t0, 48($s0)

d) Representação das instruções (Consultar as tabelas 3, 4 e 5 para fazer a representação)

Page 6: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

6

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

e) Código de Máquina

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

b) Linguagem de montagem

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]

c) Linguagem de máquina

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]

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, $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

Page 7: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

7

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

e) Código de Máquina

TIPO INSTRUÇÃO REPRESENTAÇÃO

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

b) Linguagem de montagem

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)

c) Linguagem de máquina

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)

Page 8: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO 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)

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO 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

b) Linguagem de montagem

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:

c) Linguagem de máquina

bne $19, $20, Else # desvia para ELSE se I < > j

add $16, $17, $18 # f = g + h (salta esta instrução se i <> k

Page 9: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

9

j Exit # desvia para exit

Else: sub $16, $17, $18 # f = g – h (salta esta instrução se i = j

Exit:

d) Representação das instruções

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO 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

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO 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)

e) Código de Máquina

TIPO INSTRUÇÃO REPRESENTAÇÃO 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

b) Linguagem de montagem

Loop: add $t1, $s3, $s3 # $T1 = 2 * i

add $t1, $t1, $t1 # $T1 = 4 * i

add $t1, $t1, $s5 # $T1 = A[i]

Page 10: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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

c) Linguagem de máquina

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

d) Representação das instruções

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO

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)

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO

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.

e) Código de Máquina

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO

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

Page 11: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

11

8. Compilação de um LOOP WHILE

a) Instrução:

While( save[i] == k )

i = i +j;

b) Linguagem de montagem

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;

c) Linguagem de máquina

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;

d) Representação das instruções

END. MEM. TIPO INSTRUÇÃO REPRESENTAÇÃO 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

Page 12: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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

e) Código de Máquina

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?

b) Linguagem de montagem

slt $t0, $s0, $s1 # T0 = 1 se $s0 < $s1 (se a < b)

bne $t0, $zero, Less # desvia para Less se $t0<>0

Page 13: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

13

c) Linguagem de máquina

slt $8, $16, $s17 # T0 = 1 se $s0 < $s1 (se a < b)

bne $8, $0, Less # desvia para Less se $t0<>0

d) Representação das instruções

Formato Instrução Representação

R slt $t0, $s0, $s1 0 $s0 $s1 $t0 0 42

I bne $t0, $zero, Less 5 $t0 $zero Less

Formato Instrução Representação

R slt $8, $16, $17 0 $16 $17 $8 0 42

I bne $8, $zero, Less 5 $8 $zero Less

e) Código de Máquina

Formato Instrução Representação

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)

j Exit # desvia para exit

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

Page 14: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

14

add $s0, $s1, $s2

j Exit

ELSE: sub $s0, $s3, $s4

Exit:

d) Representação das instruções

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:

Endereço M. Formato Instrução Representação 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

Formato Instrução Representação

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;

Page 15: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

15

case 3:

f = i – j; // k = 3

break;

}

b) Linguagem de montagem

###

- 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]

Page 16: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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

j Exit # fim deste case, desvia para EXIT

L2: sub $s0, $s1, $s2 # K = 2 f = g - h

j Exit # fim deste case, desvia para EXIT

###

- 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

c) Linguagem de máquina

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

j Exit # fim deste case, desvia para EXIT

L1: add $16, $17, $18 # K = 1 f = g + h

j Exit # fim deste case, desvia para EXIT

Page 17: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

17

L2: sub $16, $17, $18 # K = 2 f = g - h

j Exit # fim deste case, desvia para EXIT

L3: sub $16, $19, $20 # K = 3 f = i – j

Exit # fim do switch

d) Representação das instruções

REPRESENTAÇÃO DA LINGUAGEM DE MONTAGEM

Endereço M. Formato Instrução Representação

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

Page 18: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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 registradores subtract 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 registradores store 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)

Page 19: MIPS 32 BITS

Arquitetura de Computadores

Ciência da Computação

Engenharia de Computação

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