Introduo ao MIPS

Figura 2 Nveis de organizao do software (adaptado de Patterson e Hennessy, 2000, pg. 88). 2

Noo Geral de Arquitetura de Computadores

As arquiteturas convencionais so compostas por: Unidade Central de Processamento: UCP Memria Dispositivos de entrada e sada de dados As interconexes entre estes elementos so feitas por meio de barramentos. Barramentos so linhas fsicas (fios, por exemplo) que fazem a conexo eltrica dos dispositivos. Em termos lgicos estes barramentos so de 3 tipos: Barramento de dados: conjunto de linhas fsicas onde trafega o dado transferido entre os elementos. Nos computadores atuais, normalmente o nmero de linhas do barramento de dados mltiplo de 8 (8/16/32/64/128...) Barramento de endereos: conjunto de linhas fsicas onde trafega o endereo de identificao da clula de memria ou de um dos dispositivos de entrada ou sada de dados. Em termos do nmero de linhas assemelha-se ao barramento de dados. Barramento de controle: conjunto de linhas fsicas onde trafegam os sinais que atuam sobre o hardware e indica o fluxo das informaes, os tipos de operao que devem ser efetuadas, a prioridade de eventos etc. Em termos do nmero de linhas no h um padro e bastante varivel de acordo com a complexidade da arquitetura.

Figura 3 - Detalhamento da arquitetura de barramentos.

No modelo do MIPS que ser estudado os barramentos de dados e de endereos so de 32 bits. No MIPS cada clula de memria de 8 bits, ou seja, a cada endereo de 32 bits corresponde 1 byte (232 X bytes). Nos acessos memria (leitura ou escrita) o melhor desempenho obtido quando 32 bits so lidos simultaneamente, ou seja, 4 bytes, ou seja 4 clulas de memria. Porm, o MIPS dispe de instrues para acessar 1 clula de memria (1 byte) apenas, 2 clulas (2 bytes) ou 4 clulas (4 bytes).

A Unidade Central de Processamento (UCP) A Figura 4 mostra a organizao interna da UCP. O Clock a referncia de tempo necessria a UCP. Trata-se de um circuito eletrnico oscilador que gera uma forma de onda quadrada, a qual essencial para o seqenciamento das operaes eletrnicas realizadas pela UCP. Ele est relacionado com a freqncia (ou taxa) de operao da UCP. A unidade central de processamento (UCP ou CPU) o "crebro" do computador. Sua funo executar programas armazenados na memria principal, buscando as instrues, examinando-as, e ento executando uma aps a outra. A UCP composta de vrias partes distintas, que so a unidade de controle, a unidade lgica e aritmtica e um conjunto de registradores. A Figura 5 ilustra uma UCP genrica. A unidade de controle UC - responsvel pela busca das instrues na memria principal, sua decodificao e execuo. a responsvel pelos sinais no barramento de controle externo e no barramento de controle interno UCP. Fornece todo seqenciamento de sinais eltricos necessrios operao dos circuitos eletrnicos. A unidade lgica e aritmtica ULA ou ALU encarregada das operaes lgicas e aritmticas, como por exemplo adies binrias e E booleano que a UCP realiza. A UCP contm uma memria interna de pequena capacidade de armazenamento mas de alta velocidade, usada para armazenar resultados temporrios e certas informaes de controle. Esta memria formada por um certo nmero de registradores, chamados de uso geral e outros de uso especfico. Os registradores de uso geral so acessveis ao usurio no nvel convencional de mquina j os demais so acessveis diretamente apenas pela unidade de controle (UC) durante a execuo de um programa.

O registrador de uso especfico mais importante o contador de programa PC (Program Counter), que aponta para a prxima instruo a ser executada. Isto , ele sempre contm o endereo de memria onde est a prxima instruo a ser executada. O nome "contador de programa" um tanto enganador, porque ele no tem nada a ver com a contagem de alguma coisa, mas o termo universalmente usado. Ele que determina o fluxo de execuo do programa. O registrador de instrues - RI ou IR - tambm importante. Ele contm a instruo, que est sendo executada. A maioria dos computadores tem outros registradores especficos, alguns deles disponveis aos programadores de nveis 2 e 3 para armazenamento de resultados intermedirios ou para uso exclusivo do sistema operacional. O acesso memria ou aos dispositivos de entrada/sada quase sempre muito mais demorado que o tempo necessrio para executar uma instruo com operandos em registradores. Conseqentemente, a UC deve manter os valores corretos no barramento de dados e endereos, por um tempo suficiente, at que o acesso informao tenha sido complemente efetuado. Assim, geralmente so necessrios dois registradores especficos para esta tarefa um chamado registrador endereo - RE e outro chamado registrador de dados RD. Ambos auxiliam a compatibilizao dos tempos da UCP com o tempo de acesso memria e aos dispositivos de E/S.
clock UC = Unidade de controle

UC
Clock = referncia de tempo

ULA

ULA = Unidade lgica e aritmtica Registradores de uso geral: R0...Rk Registradores de uso especfico: PC = contador de programa RI = registrador de instruo RE = registrador de endereos RD = registrador de dados

R0 Rk ... PC RI RE RD

Figura 4 - Diagrama esquemtico da UCP genrica.

REGISTRADORES DO MIPS (R2000 e R3000) Nmero Nome Funo Guarda a constante zero. um registrador s de leitura. 0 $zero Reservado para uso do montador. 1 $at Retorno de parmetros do procedimento. 2 $v0 3 $v1 4 $a0 Envio de parmetros para o procedimento. 5 $a1 6 $a2 7 $a3 8 $t0 9 $t1 10 $t2 REGISTRADORES TEMPORRIOS: Guardam variveis 11 $t3 temporrias durante a programao. 12 $t4 13 $t5 14 $t6 15 $t7 16 $s0 17 $s1 REGISTRADORES DE SALVAMENTO: Guardam variveis mais 18 $s2 permanentes durante a programao. 19 $s3 20 $s4 21 $s5 22 $s6 23 $s7 REGISTRADORES TEMPORRIOS: Guardam variveis 24 $t8 temporrias durante a programao. 25 $t9 26 $k0 RESERVADOS PARA USO DO S.O. 27 $k1 28 $gp Global Pointer: define para o S.O. a rea de dados do usurio. Stack Pointer: define a rea da pilha, ponteiro da pilha. 29 $sp Frame Pointer: ponteiro auxiliar da pilha 30 $fp/$s8 Define o endereo de retorno de procedimento. 31 $ra

Observaes:

Proced.

S.O.

REGISTRADORES DE USO GERAL

Procedimentos

Os registradores so elementos de armazenamento interno da UCP. So os elementos de armazenamento mais velozes. Todos os registradores do MIPS so de 32 bits. A word no MIPS de 32 bits. Organizao da Memria: 232 X bytes ou 230 X words. As instrues lgicas e aritmticas operam sobre os dados presentes nos registradores. As instrues de acesso memria so s so para leitura ou escrita (load e store) de contedos (8/16/32 bits).

Introduo Linguagem de Montagem do MIPS:

lw (load word): l uma word na memria

Formato geral:

lw reg1, n(reg2) # reg1

M[n + reg2]32

Endereo do operando fonte na memria: M[n+reg2]32 Registrador destino Mnemnico da instruo

Exemplo: $t0 ABCDEF12H ; $s7 Memria Endereo Contedo (hexadec.)
2007 2006 2005 2004 2003 2002 2001 2000 AD 9C 8B 7A F6 E5 D4 C3

30304050H, $s0

2000D; Operando alterado

a) lw $t0, 0($s0) b) lw $s7, 4($s0) c) lw $s7, 2($s0)

# $t0 # $t0 # $s7 # $s7 # $s7 # $s7

M[0+2000] C3D4E5F6H M[4+2000] 7A8B9CADH M[-2+2000] A1B2C3D4H

B2 1999 A1 1998 Observaes: reg1 e reg2 so quaisquer dos registradores de uso geral n valor inteiro sinalizado de 16 bits (-32 768D a +32 767D) No MIPS o acesso memria sempre feito de forma indireta com o endereo do operando dado por n+reg2

sw (store word): armazena uma word na memria

Formato geral:

sw reg1, n(reg2) # M[n + reg2]32

reg1

Endereo do operando destino na memria: M[n+reg2]32 (4 bytes) Registrador fonte Mnemnico da instruo
Exemplo: $t0

$s0

ABCDEF12H ; $s7 2000D; $t5 1500D

30304050H; $t6

906F7788H ;

Memria Endereo Contedo (hexadec.) 2007 AD 50 2006 9C 40 2005 8B 30 2004 7A 30 2003 F6 12 2002 E5 EF 2001 D4 CD 88 2000 C3 AB 77 1999 B2 6F 1998 A1 90

Operando alterado

a) sw $t0, 0($s0) b) sw $s7, 4($s0) c) sw $t6, 498($t5)

# M[0+2000] # M[4+2000] # M[498+1500]

$t0 $s7 $t6

lbu (load byte unigned): l um byte na memria

Formato geral:

lbu reg1, n(reg2)

# reg1

M[n + reg2]8

Endereo do operando fonte na memria: M[n+reg2]8 Registrador destino Mnemnico da instruo

Exemplos: $t0 ABCDEF12H ; $s7 30304050H, $t6 906F7788H $s0 2000D; $t5 1500D Memria Endereo Contedo 2007 2006 2005 2004 2003 2002 2001 2000 1999 1998 AD 9C 8B 7A F6 E5 D4 C3 B2 A1

Operando alterado

(hexadec.)

a) lbu $t0, 0($s0) b) lbu $s7, 5($s0)

# $t0 # $t0 # $s7 # $s7

M[0+2000]; 000000C3H M[5+2000]; 0000008BH M[506+1500] 0000009CH M[-2+2000] 000000A1H

c) lbu $t6, 506($t5) # $t6

# $t6

d) lbu $s7, 2($s0) # $s7

# $s7

como e o seu funcionamento, semelhante ao lbu. Porm, esta instruo difere desta ltima, pois considera o byte lido da memria como com sinal. Ao copi-lo no registrador destino os bits b31 a b8 do registrador destino so preenchidos com o valor de b7 (bit de sinal do byte na memria). Esta instruo ser comentada com detalhes mais adiante quando se analisar a aritmtica com e sem sinal.
9

lb (load byte signed): l um byte sinalizado na memria. O formato geral desta instruo, bem

sb (store byte): armazena um byte na memria

Formato geral:

sb reg1, n(reg2)

# M[n + reg2]8

reg1

Endereo do operando destino na memria: M[n+reg2]8 Registrador fonte (byte menos significativo) Mnemnico da instruo
Exemplo: $t0 ABCDEF12H ; $s7 30304050H, 2000D; $t5 1500D $t6 906F7788H $s0

Memria
Endereo Contedo (hexadec.)

Operando alterado

2007 2006 2005 2004 2003 2002 2001 2000 1999 1998

AD 9C 88 8B 50 7A F6 E5 D4 C3 12 B2 A1 50

a) sb $t0, 0($s0) b) sb $s7, 5($s0)

# M[0+2000] # M[5+2000]

$t0 $s7 $t6 $s7

c) sb $t6, 506($t5) # M[506+1500] d) sb $s7, 2($s0) # M[-2+2000]

10

lhu (load half-word unigned): l uma meia palavra (half-word 16 bits) na memria.
Formato geral:

lhu reg1, n(reg2)

# reg1

M[n + reg2]16

Endereo do operando fonte na memria: M[n+reg2]16 (duas posies) Registrador destino (dois bytes mais direita) Mnemnico da instruo
Exemplos: $t0 ABCDEF12H ; $s7 30304050H, $t6 906F7788H $s0 2000D; $t5 1500D Memria Endereo Contedo 2007 2006 2005 2004 2003 2002 2001 2000 1999 1998 AD 9C 8B 7A F6 E5 D4 C3 B2 A1

Operando alterado

(hexadec.)

a) lhu $t0, 0($s0) b) lhu $s7, 5($s0)

# $t0 # $t0 # $s7 # $s7

M[0+2000]; 0000C3D4H M[5+2000]; 00008B9CH M[506+1500] 00009CADH M[-2+2000] 0000A1B2H

c) lhu $t6, 506($t5) # $t6

# $t6

d) lhu $s7, 2($s0) # $s7

# $s7

instruo, bem como e o seu funcionamento, semelhante ao lhu. Esta instruo (lh) difere desta ltima (lhu), pois considera os 16 bits lidos na memria como com sinal. Ao copi-lo no registrador destino os bits b31 a b16 do registrador destino so preenchidos com o valor de b15 (bit de sinal da meia palavra (16 bits) lida na memria). Esta instruo ser comentada com detalhes mais adiante quando se analisar a aritmtica com e sem sinal.
11

lh

(load half-word signed): l 16 bits (sinalizado) na memria. O formato geral desta

sh (store half-word): armazena um byte na memria

Formato geral:

sh reg1, n(reg2)

# M[n + reg2]16

reg1

Endereo do operando destino na memria: M[n+reg2]16 Registrador fonte (bits b15 a b0 apenas) Mnemnico da instruo
Exemplo: $t0 ABCDEF12H ; $s7 30304050H, 2000D; $t5 1500D $t6 906F7788H $s0

Memria
Endereo Contedo (hexadec.)

Operando alterado

2007 2006 2005 2004 2003 2002 2001 2000 1999 1998

AD 50 9C 40 8B 7A F6 88 E5 77 D4 12 C3 EF B2 50 A1 40

a) sh $t0, 0($s0) b) sh $s7, 6($s0)

# M[0+2000] # M[6+2000]

$t0 $s7 $t6 $s7

c) sh $t6, 502($t5) # M[502+1500] d) sh $s7, 2($s0) # M[-2+2000]

12

add (addition) : adiciona dois operandos. add reg1, reg2, reg3 # reg1 reg2 + reg3

Operando fonte Operando fonte Operando destino Mnemnico da instruo Obs.: No MIPS as instrues aritmticas s utilizam operandos em registradores Exemplo: $t0 ABCDEF12H ; $s7 1500D $s0 2000D; $t5 30304050H, $t7 906F7788H

a) add $t0, $t7, $s7 # $t0 b) add $s7, $s0, $t5 # $s7

30304050 + 906F7788 = C09FB7D8H

2000D + 1500D = 3500D

Exemplo: a) Duas words presentes na memria no endereo 100D e 104D devem ser somadas e o resultado colocado no endereo 108D. Considere que o registrador $s0 j foi inicializado com o valor 100D. Faa um programa na linguagem de montagem do MIPS que execute esta tarefa.

13

sub (subtraction) : subtrai dois operandos

Formato geral:

sub reg1, reg2, reg3

# reg1

reg2 reg3

Operando fonte Operando fonte Operando destino Mnemnico da instruo Exemplo: $t0 ABCDEF12H ; $s7 $s0 2000D; $t5 1500D 30304050H, $t6 906F7788H ,

a) sub $t0, $s7, $t7 # $t0 b) sub $s7, $s0, $t5 # $s7

906F7788 30304050 = 603F3738H 2000D - 1500D = 500D

Exemplo: a) O byte presente no endereo 200D deve ser subtrado do byte presente no endereo 201D resultado colocado no endereo 199D. Considere que o registrador $t0 j foi inicializado com o valor 200D. Faa um programa na linguagem de montagem do MIPS que execute esta tarefa. b) Faa um programa na linguagem de montagem do MIPS que execute a seguinte operao: M[450]16 = M[452]16 + M[454]16- M[456]16. Onde M[450]16 significa o contedo da posio de memria 450 de 16 bits. Considere que o registrador $s7 foi inicializado com 400D.

14

addi (addition immediate): adiciona um operando em

registrador com um dado imediato de 16 bits sinalizado (que vm na prpria instruo)

addi reg1, reg2, n

# reg1

reg2 + n

Operando fonte: valor numrico inteiro sinalizado de 16 bits (-32 768 a +32 767) Operando fonte Operando destino Mnemnico da instruo Exemplo: $t0

$t5

1500D

ABCDEF12H ; $t6

906F7788H $s0

2000D;

a) addi $t7, $t5, 4500D # $t7 1500D + 4500D = 6000D b) addi $t0, $t0, 44H # $t0 ABCDEF12H + 0044H = ABCDEF56H Obs: A instruo addi pode ser utilizada para introduo de dados numricos no programa, para isto usada como no exemplo a seguir: addi $t0, $zero, 4ABCH # $t0 00004ABCH
Neste caso o n deve ser menor ou igual a +32767D (7FFFH)
Exemplo: Faa um programa para carregar o valor 7123 6AFBH no endereo de memria 00001000H. Esquematize como este contedo ficar presente na memria.

15

Instrues de desvio condicional

permitem a tomada de deciso mudam o fluxo do programa se a condio testada for verdadeira a condio default (programado ao nvel de hardware) que as instrues so seqenciais

beq Branch if equal = desvia se igual

Formato geral:

beq reg1, reg2, LABEL

# se (if) reg1= reg2 ento v para (then go to) o endereo rotulado LABEL (um nome dado ao endereo de desvio pelo montador para evitar que o programador se preocupe com os valores numricos dos endereos)

bne Branch if not equal = desvia se no igual

Formato geral:

bne reg1, reg2, LABEL

(if) reg1 reg2 ento v para (then go to) o endereo rotulado LABEL
# se

Instruo de desvio incondicional:

jump ( j ) <==> go to em alto nvel

Formato geral:

J LABEL
# desvia para o endereo rotulado com LABEL
16

Compilao de um comando if. Seja o seguinte cdigo escrito em C, sendo f, g, h, i e j variveis

if (i = = j) go to L1; f = g + h; L1: f = f i;

i=j? no f=g+h f=fi

sim

No MIPS; supondo $t0

f, $t1

g, $t2
# f=g+h # f=f i

h, $t3

i, $t4

j ento:

beq $t3, $t4, L1 add $t0, $t1, $t2 L1: sub $t0, $t0, $t3

# se i = j ? v para L1

Compilao de um comando if-then-else. Seja o seguinte cdigo escrito em C, sendo f, g, h, i e j variveis

if (i = = j) f = g + h; else f = g h;
sim
f=g+h

i=j

no f=g-h

No MIPS; supondo $t0

f, $t1

g, $t2

h, $t3

i, $t4

j ento:

ELSE: EXIT:

bne $t3, $t4, ELSE add $t0, $t1, $t2 j EXIT sub $t0, $t1, $t2

# se i j v para ELSE # f = f+g # f = gh

17

Estruturas de repetio
Comando FOR
Exemplo: Faa um programa que calcule o somatrio dos valores inteiros de 1 a 10. Algoritmo proposto: SOMA <= 0 i <= 1 PARA i de 1 a 10 FAA SOMA = SOMA + i i = i+1 a) Uma soluo possvel:

add $t0, $zero, $zero add $t8, $zero, $zero addi $t9, $zero, 11D REPETE: addi $t8, $t8, 1 beq $t9, $t8, FIM add $t0, $t0, $t8 j REPETE FIM: nop

# $t0 # $t8 # $t9

Soma

contador de iterao = i flag de fim

# conta iterao # se i = 11 vai para FIM # soma soma + 1 # v para REPETE # no operation

b) Proponha uma outra soluo para este algoritmo que no use a instruo J (jump). c) Compare as solues anteriores. Qual teria melhor desempenho? Por que? Sugira outra soluo diferente duas propostas e compare com as demais.

Operaes de comparao: <,

>, <, >

Para implementao destas operaes necessrio utilizar-se a instruo set-on-less-than - slt, que funciona assim: slt reg0, reg1, reg2 # Se reg1 < reg2 ento reg0<=1, seno reg0<=0 (ou seja, reg1 > reg2) Exemplo: $t0 456789ACH, $t1 003421DFH, $s7 slt $t0, $t1, $s7 # $t0 0000 0001H slt $t0, $s1, $s7 # $t0 0000 0000H slt $s1, $s7, $t1 # $s1 0000 0000H 1122A2B0H, $s1 1122A2B0H

Exerccio: Considere 10 words presentes consecutivamente na memria a partir do endereo 4500D. Faa um programa que conte quantas destas words tem valores menores que 1000H. OBS: O MIPS s testa a condio de menor as demais comparaes devem se derivar desta.

18

Exemplos: Considerar as variveis a e b e compilar para a linguagem de mquina do MIPS as seguintes operaes de alto nvel: a) b) c) d) Se a< b v para L1 (if a < b go to L1) Se a > b v para L2 Se a < b v par L3 Se a > b v para L4 c) Se a < b v para L3 Beq $t2, $t3, L1 Slt $t4, $t2, $t3 Bne $t4, $t0, L3 ______ ______ Ou Ou Slt $t4, $t2, $t3 Beq $t4, $t1, L1 ______ ______ b) Se a > b v para L2 Slt $t4, $t2, $t3 Beq $t4, $t0, L2 ______ ______ Ou Slt $t4, $t2, $t3 Bne $t4, $t1, L2 ______ ______ Slt $t4, $t3, $t2 Beq $t4, $t0, L3 ______ ______

Considere: $t0<=0, $t1<=1, $t2 <=a e $t3<=b. Analise todas as possibilidades para cada caso. a) Se a< b v para L1 (if a < b go to L1) Slt $t4, $t2, $t3 Bne $t4, $t0, L1 ______ ______

L3:

L1:

L3:

L1:

L2:

d) Se a > b v para L4 Beq $t2, $t3, PULA Slt $t4, $t2, $t3 Beq $t4, $t0, L4 PULA: ______ ______ L4: ______ Ou Slt $t4, $t3, $t2 Bne $t4, $t0, L4 ______ ______ ______

L2:

L4:

19

Exerccios: LOOP WHILE:

Exemplo: Por meio de subtraes sucessivas divida o valor da varivel V1 (valor entre 0 e 32000) pela varivel V2 (valor entre 1 e 32000). Algoritmo: Resultado <= 0 Passo<= 1 Dividendo = V1 Divisor = V2 Enquanto V1 > V2 faa: V1 = V1- V2 Resultado = Resultado + Passo Resto = V1 FIM: Na linguagem de montagem do MIPS considere os valores:, $t2<= V1 (dividendo), $t3<= V2 (divisor), $t4<=resultado:

WHILE:

add $t4, $zero, $zero # $t4<=resultado <= 0 slt $t5, $t2, $t3 bne $t5, $zero, fim sub $t2, $t2, $t3 addi $t4, $t4, 1 j WHILE Operaes com arrays na memria:

FIM:
As operaes com arrays (vetores) em linguagem de mquina devem converter o ndice dos elementos em endereos de memria para que se possa acessar os elementos. Portanto, considerando que os acessos a elementos podem ser do tipo word (32 bits), half-word (meia-palavra) ou byte na memria no MIPS real tem-se: ELEMENTO DO ARRAY 1o. 2o. 3o. 4o. 5o ... NDICE DO ELEMENTO - i 0 1 2 3 4 ... ENDEREO (base + 4*i) Base + 0 Base + 4 Base + 8 Base + 12 Base + 16 ... ENDEREO (base + 2*i) Base + 0 Base + 2 Base + 4 Base + 6 Base + 8 ... ENDEREO (base + 2*i) Base + 0 Base + 1 Base + 2 Base + 3 Base + 4 ...

Onde chama-se endereo base o endereo do elemento de ndice zero do array. Nas instrues load e store o endereo de memria calculado como segue: Exemplos: a) Um array de 10 words est presente na memria a partir do endereo 100D. Conte no registrador $t9 quantas words so iguais a zero. b) Copie este array para o endereo 1000D. c) A partir do array do item b) gere um outro array apenas com os elementos diferentes de zero. Este array deve iniciar no endereo 2000D e o nmero de elementos deste (word) deve ser armazenado no endereo 1996D. d) Copie o array do item a) para o endereo 3000D em ordem decrescente de endereos. e) Repita os exerccios anteriores considerando os elementos do array como half-words. f) Repita os exerccios anteriores considerando os elementos do array como bytes.

20

d) Dois arrays de 100 words (A1[i] e A2[i]) esto presentes na memria em ordem crescente de endereos. A1[i] inicia no endereo 5000D e A2[i] inicia no endereo 6000D. Conte quantos elementos A1[i] > A2[i] esto presentes e salve o ndice destes elementos em outro array A3[j], que inicia no endereo 7000D em ordem crescente de endereos. A contagem destes elementos deve ser armazenada na word que precede o incio do array A3[j]. Veja o esquema e o algoritmo abaixo:
Endereo 7000+4n Dado (32 bits) A3[n-1] ... ... A3[1] A3[0]

7004 7000

} A3[j]
contagem

6996
6396

n
... ... A2[99] ... ... A2[2] A2[1] A2[0] ... ... A1[99] ... ... A1[2] A1[1] A1[0]

6008 6004 6000

} A2[i] } A1[i]

5396

5008 5004 5000

21

Fluxograma:

Base A1[i]<= 5000 Base A2[i]<= 6000 Base A3[j]<= 7000 I=0 J=0 (contador) Bandeira de fim = 100

Calcula endereo de A1[i] Calcula endereo de A2[i] L elemento A1[i] L elemento A2[i]

A1[i] >A2[i]?

NO

SIM Calcula endereo de A3[J] A3[j] <= I J <= J + 1

I <= I+1

NO

I = 100? SIM FIM

addi $t9, $zero, 100 add $t0, $zero,$zero add $t1, $zero,$zero REPETE: add $t2, $t0, $t0 add $t2, $t2, $t2 lw $t3, 5000 ($t2) lw $t4, 6000 ($t2) slt $t5, $t4, $t3 beq $t5, $zero, PULA add $t2, $t1, $t1 add $t2, $t2, $t2 sw $t0, 7000($t2) addi $t1, $t1, 1 PULA: addi $t0, $t0, 1 bne $t0, $t9, REPETE

# #i #j # # # # # # # # # # # #
22