Linguagem de Montagem

Prof. Marcos Quinet

Universidade Federal Fluminense UFF
Plo Universitrio de Rio das Ostras - PURO

Introduo
Independente da linguagem de programao utilizada,
todo programa ser convertido em um conjunto de
instrues, chamado linguagem de montagem, antes de
ser convertido em cdigo binrio.
Apesar de aparentemente limitadas, as linguagens de
montagem definem todo o conjunto de instrues
reconhecidas e utilizadas em um sistema computacional,
representando uma das caractersticas mais importantes
do projeto de um processador.
A programao em linguagem de montagem requer tanto
conhecimentos de lgica quanto do hardware utilizado.
2

Linguagem de mquina
O que representa
cdigo ao lado?

Resposta: rotina que

calcula e imprime a
soma dos quadrados dos
inteiros entre 0 e 100.

00100111101111011111111111100000
10101111101111110000000000010100
10101111101001000000000000100000
10101111101001010000000000100100
10101111101000000000000000011000
10101111101000000000000000011100
10001111101011100000000000011100
10001111101110000000000000011000
00000001110011100000000000011001
00100101110010000000000000000001
00101001000000010000000001100101
10101111101010000000000000011100
00000000000000000111100000010010
00000011000011111100100000100001
00010100001000001111111111110111
10101111101110010000000000011000
00111100000001000001000000000000
10001111101001010000000000011000
00001100000100000000000011101100
00100100100001000000010000110000
10001111101111110000000000010100
00100111101111010000000000100000
00000011111000000000000000001000
00000000000000000001000000100001

Conjunto de instrues MIPS

Diferentes projetos de processadores implementam
diferentes conjuntos de instrues.
Um dos mais populares conjuntos de instrues
chamado MIPS (Microprocessor without Interlocked
Pipeline Stages), criado pela MIPS Computer Systems
para ser utilizado em seus processadores, utilizados por
companhias como NEC, Nintendo, Silicon Graphics, Sony,
Siemens, e muitas outras.
Na metade da dcada de 90, estima-se que um a cada 3
microprocessadores RISC produzidos utilizavam MIPS.
4

MIPS
Nas lies a seguir ser adotado o padro da
arquitetura de 32 bits (apesar que tambm
utilizado em arquiteturas de 64 bits, com
adaptaes de endereamento e tamanho de
campos).
A arquitetura MIPS segue os princpios bsicos de
um projeto de hardware. Estes princpios foram
estabelecidos para, na criao de um novo
hardware, que o resultado fosse o mais simples,
eficiente e livre de falhas possvel, com o menor
custo necessrio.
5

Princpio de projeto 1
A simplicidade favorecida pela
regularidade
A representao de instrues em MIPS segue um
formato regular de campos, cada um com uma
funo especfica bem definida.
Por exemplo, a operao de soma em MIPS seria
feita da forma: ADD a, b, c significa somar o
valor das variveis b e c e armazenar o resultado
em a.
6

Prncipio de projeto 1
Como escrever em MIPS a operao a b + c +d +e ?

add a, b, c
add a, a, d
add, a, a, e

# a soma de b e c
armazenada em a
# a soma de b, c e d
armazenada em a
# a soma de b, c, d e e
armazenada em a

A operao de subtrao, atravs do mnemnico sub,

funciona de maneira anloga.
7

Exerccio
Qual o cdigo MIPS correspondente a instruo:
f (g + h) (i + j);
Dica: considere o uso de duas variveis temporrias,
t0 e t1, criadas pelo compilador
Resposta:
add t0, g, h
add t1, i, j
sub f, t0, t1

# a varivel t0 recebe g + h
# a varivel t1 recebe i + j
# a varivel f recebe t0 - t1

OBS: este ainda no um cdigo MIPS real, um pseudo-MIPS

8

Princpio de projeto 2
Quanto menor, mais rpido
No so utilizadas variveis em linguagens de
montagem, pois este conceito s existe em
linguagens de alto nvel.
O MIPS utiliza registradores de 32 bits, cada um
representando uma palavra da arquitetura.
Um grande nmero de registradores no hardware
certamente tornaria maior o ciclo de clock,
tornando o sistema computacional mais lento.
9

Princpio de projeto 2
Registradores existem em quantidades limitadas. No
projeto de uma arquitetura MIPS existem
exatamente 32 registradores, identificados atravs
de um $, seguido de um identificador (que pode
conter uma parte numrica).
Dentre os registradores disponveis ao programador
MIPS esto alguns de propsito geral e outros com
propsito especfico.
Alguns no so utilizados pelo programador, mas
pelo sistema operacional.
10

Registradores do MIPS
Nome

Nmero

Uso

$zero

Constante 0

$at

Reservado para o montador

$v0, $v1

2, 3

$a0,..., $a3

4 ao 7

Argumentos 1 a 4

$t0,..., $t7

8 ao 15

Temporrio (no preservado pela chamada)

$s0,..., $s7

16 ao 23

Temporrio salvo (preservado pela chamada)

$t8, $t9

24, 25

Temporrio (no preservado pela chamada)

$k0

26

Reservado para o kernel do sistema operacional

$k1

27

Reservado para o kernel do sistema operacional

$gp

28

Ponteiro para rea global

$sp

29

Apontador de pilha (stack pointer)

$fp

30

Apontador de contexto (frame pointer)

$ra

31

Endereo de retorno (usado por chamada de funo)

Avaliao de expresso e resultado de uma funo

11

Representao de instrues em
MIPS
op

rs

rt

rd

shamt

funct

6 bits

5 bits

5 bits

5 bits

5 bits

6 bits

op: operao bsica a ser realizada pela instruo

(opcode).
rs: registrador contendo o primeiro operando-fonte.
rt: registrador contendo o segundo operando-fonte.

12

Representao de instrues em
MIPS
Rd: registrador que guarda o resultado da operao
(registrador destino).
Shamt: quantidade de bits a serem deslocados (especfico
para instrues de deslocamento; se a instruo no for
deste tipo, conter zero).
Funct: funo. Seleciona uma variao especfica da
operao apontada no campo op, sendo chamado de
cdigo da funo.
Observe que o formato de instruo contm
exatamente 32 bits, o tamanho de uma palavra de
memria e de um dado (princpio de projeto 1).
13

Exemplo
Para a instruo: add $t0, $s1, $s2;
Representao decimal:

17

18

32

Representao binria:

000000

10001

10010

01000

00000

100000

6 bits

5 bits

5 bits

5 bits

5 bits

6 bits

14

Tamanho dos campos

Podem ocorrer problemas caso a instruo precise
de campos maiores do que os apresentados.
Por exemplo, se um dos campos for um valor
constante, esta constante estaria limitada a 25 = 32.
Campos de 5 bits podem ser pequenos para os
propsitos necessrios.
Existe um conflito entre manter todas as instrues
do mesmo tamanho e o desejo de ter um nico
formato de instrues.
15

Princpio de projeto 3
Um bom projeto demanda
compromisso
Em MIPS todas as instrues so do mesmo tamanho,
mas so utilizados formatos diferentes para tipos
distintos de instrues.
O tipo que vimos anteriormente chamado de tipo R,
ou formato R, sendo o R usado para lembrar o uso de
registradores pela instruo.

16

Instruo do tipo I
O outro tipo chamado de tipo I, ou formato I,
sendo o I utilizado para lembrar que usado em
instrues de transferncia de dados.
O formato de instrues do tipo I o seguinte:

op

rs

rt

endereo

6 bits

5 bits

5 bits

16 bits

17

Instrues de acesso memria

Dos elementos presentes em um sistema
computacional, o processador pode manter apenas
uma pequena quantidade de dados em seus
registradores, mas a memria de um computador
pode conter milhes de estruturas de dados.
O MIPS precisa de instrues que permitam a
transferncia de dados entre registradores e a
memria do sistema.
Para acessar uma palavra na memria, a instruo
deve fornecer ao processador o endereo na
memria da palavra a ser acessada.
18

Instrues de acesso memria

A memria vista como um imenso array
unidimensional de dados, com o endereo servindo
como um ndice para este array, comeando do zero.
No exemplo a seguir, o endereo do terceiro elemento
dos dados 8, e o contedo de memria[8] 10.
Endereo

12

...

Dados

101

10

100

...

19

Instrues de acesso memria

Quase todas as arquiteturas endeream bytes
individuais, portanto, o endereo de uma palavra
deve ser igual ao endereo de um dos bytes
componentes da palavra.
Como pode ser observado no exemplo anterior, o
endereo de duas palavras sequenciais difere
sempre de 4 bytes (em arquiteturas de 32 bits).
Em MIPS, as palavras precisam sempre comear em
endereos mltiplos de 4, propriedade chamada de
restrio de alinhamento.
20

Instrues de acesso memria

A instruo de transferncia de dados que move
um dado da memria para um registrador
chamada de load word, codificada atravs do
mnemnico lw.
A instruo complementar a de load chamada de
store word (armazenamento), que transfere um
dado de um registrador para a memria, utilizando
o mnemnico sw.

21

Instrues de acesso memria

A sintaxe dos comandos de leitura e escrita na memria so:
Load: lw $reg, desloc(endereo base)
Onde $reg um registrador temporrio qualquer ($t0, $s0, etc.),
desloc o nmero de bytes de deslocamento em relao ao
endereo-base do array.

Store: sw $reg, desloc(endereo base)

Onde $reg um registrador temporrio onde est o dado a ser
salvo ($t0, $s0, etc.), desloc o nmero de bytes de deslocamento
em relao ao endereo-base do array.

Importante: o deslocamento precisa ser expresso por um valor

inteiro, no pode ser referenciado um registrador no campo.
22

Instrues de acesso memria

Por exemplo, suponha que A seja um array de 100
palavras, e que o compilador tenha associado as
variveis g e h aos registradores $s1 e $s2. Suponha
tambm que o endereo-base do array est
armazenado em $s3.
Como ficaria em MIPS a instruo g h + A[8]; ?

23

Instrues de acesso memria

Inicialmente, precisamos transferir o contedo da
posio de memria A[8] para um registrador:
Obtm-se o endereo deste elemento do array
atravs da soma do endereo base (em $s3) com o
ndice, usado para selecionar o nono elemento do
array.
O deslocamento a ser adicionado ao contedo do
registrador-base $s3 deve ser 4 x 8, ou 32.
lw $t0, 32($s3)
#o reg. Temporrio $t0 recebe A[8]

Em seguida basta fazer a soma:

add $s1, $s2, $t0

# $s1 (g) recebe h + A[8]

24

Instrues de acesso memria

Para o prximo exemplo, ao invs de armazenar o
resultado em um registrador, vamos armazenar em
uma posio de memria. O endereo-base do array
A continua em $s3.
A[12] = h + A[8];
lw $t0, 32($s3)
add $t0, $s2, $t0
sw $t0, 48($s3)

# $t0 recebe o valor de A[8]

# $t0 recebe h + A[8]
# h + A[8] armazenado em
# A[12]

25

Acesso a posies de um array com

ndice varivel
At o momento, todos os acessos realizados a um
elemento de um array foram feitos atravs do ndice
constante * 4 (para o clculo do byte correspondente).
Em algumas situaes, o ndice do array ser uma
varivel i, que tambm ter que ser multiplicada por 4.
Como a operao de multiplicao ainda no foi
estudada (e pode nem estar implementada em algumas
linguagens de montagem), como fazer este ajuste de
endereo a byte?

26

Acesso a posies de um array com

ndice varivel
Uma soluo para obter o valor de i*4 seria:
Some o valor de i a ele mesmo (i + i = 2i);
Depois some esta soma a ela mesma (2i + 2i = 4i);

Exemplo:
Sendo A um array de 100 elementos cujo endereobase est em $s3, e as variveis g, h e i esto associadas
aos registradores $s1, $s2 e $s4, qual o cdigo MIPS
para a operao g = h + A[i]?

27

Acesso a posies de um array com

ndice varivel
O primeiro passo multiplicar o valor de i, que est
em $s4 por 4:
add $t1, $s4, $s4
add $t1, $t1, $t1

# $t1 recebe 2 * i
# $t1 recebe 4 * i

Em seguida, usamos as tcnicas j conhecidas para

acessar a memria e realizar a soma:
add $t1, $t1, $s3
lw $t0, 0($t1)
add $s1, $s2, $t0

# soma o end. base em $s3

# com o deslocamento de $t1
# carrega A[i] em $t0
# g = h + A[i]
28

Codificao de instrues MIPS (at o momento...)

instruo

formato

op

rs

rt

rd

shamt

funct

endereco

add

reg

reg

reg

32

n/a

sub

reg

reg

reg

34

n/a

lw

35

reg

reg

n/a

n/a

n/a

endereo

sw

43

reg

reg

n/a

n/a

n/a

endereo

Legenda:
reg: nmero de um registrador, entre 0 e 31
endereo: valor de 16 bits
n/a: no se aplica
29

Exerccio
Supondo que $t1 tem o valor-base do array A e que $s2
corresponde a varivel h, diga como fica o comando a
seguir em MIPS e linguagem de montagem:
A[300] = h + A[300];
Soluo:
lw $t0, 1200($t1)
add $t0, $s2, $t0
sw $t0, 1200($t1)

# $t0 recebe A[300]

# $t0 recebe h + A[300]
# h + A[300] armazenado
de volta em A[300]

30

Exerccio
Op

Rs

Rt

35

18

43

Op

Rs

Rt

100011

01001

01000

000000

10010

01000

101011

01001

01000

Rd

Endereo/
shamt

funct

1200
8

32

1200

Rd

Endereo/
shamt

funct

0000010010110000
01000

00000

100000

0000010010110000

31

Instrues de desvio
As linguagens de programao de alto nvel geralmente
implementam o comando de tomada de deciso atravs
do comando if.
O MIPS possui duas instrues de desvio:
beq r1, r2, L1 se os valores de r1 e r2 so iguais, desvia
para a linha identificada pelo label L1.
bne r1, r2, L1 se os valores de r1 e r2 so diferentes, desvia
para a linha identificada pelo label L1.
OBS: beq: branch if equal
bne: branch if not equal

32

Instrues de desvio
O label apenas um identificador de linha, inserido
no comeo e separado da instruo por :
Exemplo:
if (i == j) go to L1;
f = g + h;
L1: f = f i;
Supondo que as variveis f, g, h, i e j correspondem aos registradores
de $s0 a $s4, escreva o cdigo MIPS correspondente

33

Instrues de desvio
Soluo:
beq $s3, $s4, L1
add $s0, $s1, $s2
L1: sub $s0, $s0, $s3

# desvia para L1 se i for igual a j

# f = g + h; no executada se i = j
#f = f i; sempre executada

O label L1 corresponde aonde a instruo sub est

armazenada. No h a necessidade de calcular endereos
de memria, como acontece com os comandos de load e
store.

34

Instrues de desvio
Os desvios feitos at agora se basearam no resultado de
um teste de comparao. possvel ainda fazer desvios
incondicionais, isto , que sempre sero tomados, atravs
da instruo j (jump).
Exemplo: if-then-else usando desvios em MIPS:
if (i == j)
f = g + h;
else
f = g h;
Novamente, estamos supondo que as variveis f, g, h, i e j
correspondem aos registradores de $s0 a $s4
35

Instrues de desvio
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit:

# desvia para Else se i j

# f = g + h; no executada se i j
# desvia incondicionalmente para
Exit
# salta essa instruo se i = j

36

Instrues de desvio
possvel utilizar uma variao do jump, conhecida
como jump register (jr), que realiza um desvio
incondicional para um registrador especificado na
instruo.
jr $t1

Muitas vezes so guardados endereos de memria

em registradores, e a utilizao do jr faz com que
o salto seja feito diretamente para o endereo
armazenado no registrador em questo.

37

Instrues de repetio
Desvios condicionais em MIPS podem ser utilizados
para a implementao de estruturas de repetio,
como um loop de instrues, por exemplo:
Loop: g = g + A[i];
i = i + j;
if (i != h) go to Loop;

Suponha que A seja um array de 100 elementos, que

as variveis g, h, i e j esto associadas aos
registradores $s1, $s2, $s3 e $s4, respectivamente, e
que o endereo-base do array A esteja em $s5.
38

Instrues de repetio
Loop: add $t1, $s3, $s3
add $t1, $t1, $t1
add $t1, $t1, $s5
lw $t0, 0($t1)
add $s1, $s1, $t0
add $s3, $s3, $s4
bne $s3, $s2, Loop

# $t1 recebe 2*i

# $t1 recebe 4*i
# $t1 recebe endereo de A[i]
# $t0 recebe A[i]
# g = g + A[i]
#i=i+j
# desvia para Loop se i h

39

Instrues de repetio
Repetio com o comando while
Os loops de repetio de comandos so
implementados em linguagens de alto nvel mais
frequentemente atravs do comando while, por
exemplo:
while (save[i] ==k)
i= i + j;

Como fica este loop em MIPS, considerando as

variveis i, j e k nos registradores $s3, $s4 e $s5, e o
endereo-base do array save[ ] em $s6?
40

Instrues de repetio
Loop: add $t1, $s3, $s3
add $t1, $t1, $t1
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
add $s3, $s3, $s4
j Loop
Exit:

# $t1 recebe 2*i

# $t1 recebe 4*i
# $t1 recebe end. de
save[i]
# $t0 recebe save[i]
# exit se save[i] k
# i recebe i + j
# desvia para Loop
# fim
41

Teste de igualdade e desigualdade

Testes de condio geralmente fazem testes de
igualdade ou desigualdade, verificando se o valor
assumido por uma varivel menor ou maior do
que um outro valor.
Em MIPS utilizada a instruo slt, que compara o
valor armazenado em dois registradores e
armazena o valor 1 em um terceiro registrador se o
valor do primeiro registrador for menor do que o
valor do segundo; caso contrrio, armazena 0 no
terceiro registrador.
42

Teste de igualdade e desigualdade

Exemplo:
slt $t0, $s3, $s4

# $t0 recebe 1 se $s3 < $s4

# $t0 recebe 0 se $s3 $s4

Exerccio: qual o cdigo para testar uma se uma

varivel a, armazenada em $s0, menor do que
uma varivel b, armazenada em $s1, e se for
menor, desviar para um label Less?

43

Teste de igualdade e desigualdade

Resposta:
slt $t0, $s0, $s1
bne $t0, $zero, Less
Less: ...

# reg. $t0 recebe 1 se $s0 <

$s1
# desvia para Less se $t0 0
# instrues caso o desvio seja
tomado

Exerccio: escreva um algoritmo em MIPS equivalente a

estrutura (considerando x em $s0 e y em $s1):
se x > y
x x + y;
seno y y x;
44

Operandos Imediatos ou Constantes

A utilizao de valores constantes comum em vrias
estruturas de dados, como o incremento de um ndice de
um array, o nmero de iteraes de um loop, etc.
Esto disponveis em MIPS instrues do tipo I onde um
dos operandos pode ser representado na forma de um
valor constante, de at 16 bits, mantido dentro da
prpria instruo.

op

rs

rt

6 bits 5 bits 5 bits

imediato
16 bits
45

Princpio de projeto 4
Torne o caso comum mais
rpido
A utilizao de operandos imediatos ocorre com
tanta frequncia em linguagens de montagem que
a melhor deciso de projeto trat-los como um
caso comum, e no como instrues especiais.

46

Operandos Imediatos ou Constantes

Muitas das instrues MIPS vistas anteriormente
possuem correspondentes em instrues do tipo i,
cujo mnemnico geralmente similar ao utlizado
pela instruo do tipo r, mas acrescido da letra i
no final
Seguindo o formato de instrues do tipo i, o
campo de 16 bits reservado para um endereo de
memria, pode ser passado diretamente um valor
inteiro, de at 216

47

Operandos Imediatos ou Constantes

A operao de soma utilizando um dos operandos
imediatos feita atravs da instruo addi
(mnemnico para add immediate), por exemplo:
addi $sp, $sp, 4

# $sp = $sp + 4

29

29

op

rs

rt

imediato

001000

11101

11101

0000000000000100

48

Operandos Imediatos ou Constantes

Operandos imediatos so muito utilizados em
operaes de comparao; quando necessrio
comparar com o valor zero, basta utilizar o
registrador especial $zero; em outros casos, pode
ser utilizada a instruo slti e um valor constante.
Exemplo:
slti $t0, $s2, 10

# $t0 recebe 1 se $s2 < 10

49

Operandos Imediatos ou Constantes

Como em alguns casos so necessrias constantes
maiores do que o limite de 16 bits do campo, o MIPS
inclui a instruo lui (load upper immediate), que carrega
os 16 bits de ordem mais alta de uma constante em um
registrador.
Neste caso necessrio a utilizao de uma outra
instruo para especificar os 16 bits de mais baixa ordem
da constante.
O registrador $at mantido reservado para o montador
para operaes que ele precise quebrar constantes
grandes em pedaos para depois remont-las.
50

Operandos Imediatos ou Constantes

Exemplo: como carregar a constante binria de 32
bits 0000 0000 0011 1101 0000 1001 0000 0000 no
registrador $s0?
lui $s0, 61

# 61 decimal igual a 0000 0000

# 0011 1101 binrio
#aps esta operao, o valor de $s0 0000 0000 0011 1101
0000 0000 0000 0000
addi $s0, $s0, 2304
# 2304 decimal igual a 0000
# 1001 0000 0000 binrio
Aps a soma imediata, o valor armazenado em $s0 0000 0000
0011 1101 0000 1001 0000 0000
51

Exerccios
1.

Comente o cdigo MIPS a seguir. Suponha que $a0 a

entrada, contendo o valor 5, e que $v0 usado para
armazenar o resultado; qual o valor final?
begin:
loop:

finish:

addi $t0, $zero, 0

addi $t1, $zero, 1
slt $t2, $a0, $t1
bne $t2, $zero, finish
add $t0, $t0, $t1
addi $t1, $t1, 2
j loop
add $v0, $t0, $zero

52

Exerccios
2.

Mostre qual a instruo do MIPS ou o menor

conjunto de instrues do MIPS necessrio para
implementar os comandos a seguir:
a. a = b + 100
b. x[10] = x[11] + c
c. while x[a] < b {
c = x[a] + b;
a++;
{
OBS: as variveis a, b, c e o end. base de x esto em
$s1, $s2, $s3 e $s4, respectivamente.
53

Exerccios
3.

Converta os seguintes trechos de cdigo em

instrues MIPS equivalentes:

a.

while (a!=0) {
c = a + b;

Considere a, b, c e i em $s1, $s2,

$s3 e $s4, respectivamente

a = a--;
}
for (i=0, i !=10, i++) {
c = a + b;

b.

54

Suporte a procedimentos do MIPS

Procedimentos e sub-rotinas so uma forma de escrever
mdulos para funes especficas, que tornam o programa
mais fcil de ser entendido e possibilitam a reutilizao de
cdigo.
MIPS oferece suporte a implementao de procedimentos,
inclusive com o uso dos seguintes registradores especiais:
$a0 a $a3: 4 registradores para argumento, para a passagem
de parmetros do programa para o procedimento;
$v0 e $v1: registradores para retorno de valores do
procedimento;
$ra: registrador que contm o endereo para o controle
retornar ao final da execuo do procedimento.
55

Suporte a procedimentos do MIPS

Passos realizados durante a execuo de um procedimento:
Colocar os parmetros em um lugar onde eles possam ser
acessados pelo procedimento;
Transferir o controle para o procedimento;
Garantir os recursos de memria necessrios execuo do
procedimento;
Realizar a tarefa desejada;
Colocar o resultado em um lugar acessvel ao programa que
chamou o procedimento;
Retornar ao ponto de origem.

56

Suporte a procedimentos do MIPS

O MIPS implementa uma instruo de jump and link
(jal), que desvia para um endereo de memria (ou
nome do procedimento) e simultaneamente salva o
endereo da instruo seguinte em $ra.
jal endereo-do-procedimento

A instruo jal salva o valor armazenado no PC + 4

no registrador $ra para estabelecer um link do final
do procedimento com a instruo do programa
principal imediatamente aps a que realizou a
chamada ao procedimento.
jr $ra
57

Suporte a procedimentos do MIPS

Muitas vezes a quantidade de registradores
disponveis no MIPS insuficiente para armazenar
todos os valores necessrios na execuo de um
programa, principalmente
na ocorrncia de
chamadas recursivas.
Nestas situaes, so utilizadas pilhas, que so
estruturas de dados armazenadas na memria
principal do sistema.
Uma pilha implementa uma estrutura LIFO (last in
first out o ltimo a entrar o primeiro a sair)
58

Manipulao de pilhas
Duas operaes podem ser realizadas em uma pilha: a
operao push, onde um dado colocado no topo da
pilha, e a operao pop, que retira o elemento que
encontra-se no topo da pilha. Estas operaes existem
em linguagens de alto nvel, no no MIPS.
O endereo de memria que indica qual a posio
ocupada pelo topo da pilha (e consequentemente, o
elemento que encontra-se no topo), fica armazenado
no registrador $sp, tambm chamado de apontador
de pilha (stack point).
59

Manipulao de pilhas
Observe que, tradicionalmente, as pilhas crescem
dos endereos de memria mais altos para os mais
baixos; quando um item empilhado, o valor do
apontador de pilha ($sp) deve diminuir.

60

Exemplo de procedimento
Converta para MIPS o seguinte trecho de cdigo que
representa um procedimento:
int funcao_f (int g, int h, int i, int j)
{
int f;
f = (g+h) (i + j);
return f;
}
As variveis g, h, i e j correspondem aos registradores
$a0, $a1, $a2 e $a3; o resultado da varivel f
corresponde ao registrador $s0.

61

Exemplo de procedimento
Inicialmente, deve-se salvar em algum espao da
memria o contedo das variveis que sero
utilizadas na operao.
J fizemos essa operao antes, lembra (l no slide
8)? Foram utilizados dois registradores
temporrios, ento necessrio reservar uma rea
de memria para eles e para o resultado (a varivel
de retorno f).
O procedimento comea com um label, que neste
exemplo ser chamado de funcao_f:
62

Exemplo de procedimento

sub $sp, $sp, 12

sw $t1, 8 ($sp)
sw $t0, 4 ($sp)
sw $s0, 0 ($sp)

# ajusta a pilha para armazenar 3 itens

# empilha o contedo do registrador de $t1
# empilha o contedo do registrador de $t0
# empilha o contedo do registrador de $s0
63

Exemplo de procedimento
Com os valores de $t1, $t0 e $s1 empilhados na
memria, estes registradores podem ser utilizados
por outras operaes do programa.
Uma vez carregados, podemos fazer as operaes:
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero

# $t0 recebe g+h

# $t1 recebe i+j
# f recebe $t0 - $t1
# coloca o valor de f no
# registrador de retorno, $v0

64

Exemplo de procedimento
No final das operaes, os valores originais dos
registradores sero desempilhados, com os comandos:
lw $s0, 0($sp)
lw $t0, 4($sp)
lw $t1, 8($sp)
add $sp, $sp, 12
jr $ra

# desempilha o topo da pilha para $s0

# desempilha o topo da pilha para $t0
# desempilha o topo da pilha para $t1
# ajusta a pilha de modo a remover os 3 itens
# desvia de volta para o programa que
# chamou a funo

65

Instrues de acesso memria

O compilador aloca em endereos da memria
diversas estruturas de dados, como os arrays. Logo, o
compilador deve colocar o endereo inicial da
estrutura nas instrues de transferncia de dados, j
que ele o responsvel pela alocao de espao na
memria para programas em execuo.
O MIPS utiliza uma forma de representao de dados
chamada big endian, pois enderea a partir do byte
mais esquerda (o byte mais significativo
armazenado no menor endereo de byte).
66

Representao e referncia de bytes

Conceito da disposio dos bytes (endianness) de
valores escalares compostos por mltiplos bytes.
Big-endian: o byte mais significativo armazenado no
menor endereo de byte.
Little-endian: o byte menos significativo armazenado no
menor endereo de byte.
Ex: armazenamento do hexa 12345678 (palavra de 32 bits):
Endereo

Valor

Endereo

Valor

184

12

184

78

185

34

185

56

186

56

186

34

187

78

187

12

67