Aula 4 – Sumário
 Linguagem
assembly do MAC-1:
Funções e procedimentos
A
pilha
 Invocação
 Variáveis
 Retorno
de funções e procedimentos
locais e argumentos
e devolução de valores
 Instruções
 Exemplos
assembly envolvidas
de programas
1
Processador MAC-1
Funções e procedimentos
2
A pilha

Durante a execução de um programa são invocadas
funções e procedimentos (ou métodos)

Cada função ou procedimento pode ter:


Variáveis locais
Variáveis que só são válidas dentro do procedimento

Argumentos
Valores ou referências passados ao procedimento
Quando um procedimento retorna, o CPU necessita de
saber qual o ponto do programa para onde se volta
Todos estes dados são guardados num espaço
da memória designado por pilha (ou stack)
3
A pilha


0
1
2
...


Variáveis locais e argumentos
Pontos de retorno dos procedimentos
Outros dados de natureza temporária
O CPU guarda a posição do topo da
pilha no registo Stack Pointer (SP)
Pilha
Utiliza-se para guardar:


Ocupa posições de memória consecutivas
Cresce no sentido decrescente dos
endereços
Inserem-se e retiram-se elementos a partir
do seu topo
Programa


Memória
Estrutura de dados muito simples
I/O

4
Assembly MAC-1

Invocação e retorno de procedimentos

Instrução call – invocar

Instrução retn – retornar
Mnemónica Descrição
Significado
call x
SP ← SP – 1; M[SP] ← PC; PC ← x Call function or procedure
retn
PC ← M[SP]; SP ← SP + 1
Return
x é um endereço entre 0 e 4095, ou uma label que represente esse endereço.
Corresponde à posição do programa onde começa a rotina.
5
Funções e procedimentos


Mecanismo de retorno

Quando se invoca um procedimento (call), o valor de
Program Counter (PC) é copiado para pilha.

Esse valor é o endereço de retorno – ponto para
onde o programa volta após o procedimento retornar

Para a rotina retornar, o endereço de retorno é
transferido da pilha para PC (retn).
Devolução de valores

Quando se pretende devolver um valor, coloca-se
esse valor no Acumulador (AC), antes da função
retornar
6
Funções e procedimentos

Do lado da invocação:




Colocar os argumentos na pilha
Invocar a função ou procedimento usando call
Retirar os argumentos da pilha
Dentro do procedimento ou função:





Criar as variáveis locais, reservando espaço na pilha
Executar o código do procedimento
“Destruir” as variáveis locais, descartando-as da pilha
Deixar em AC o valor a devolver
Retornar, usando retn
7
Assembly MAC-1

Manipulação básica da pilha

Colocar e retirar os argumentos da pilha

Criar e descartar as variáveis locais (ou outros dados
de carácter local ou temporário)
Mnemónica
Descrição
Significado
push
SP ← SP – 1; M[SP] ← AC
Push onto stack
pop
AC ← M[SP]; SP ← SP + 1
Pop from stack
desp n
SP ← SP – n
Decrement SP
insp n
SP ← SP + n
Increment SP
n é um valor entre 0 e 255, e especifica o número de posições que
se querem acrescentar ou retirar à pilha.
8
Assembly MAC-1

Endereçamento local

Acesso a dados guardados na pilha, com destaque
para as variáveis locais e argumentos dos
procedimentos
Mnemónica
Descrição
Significado
lodl n
AC ← M[SP + n]
Load local
stol n
M[SP + n] ← AC
Store local
addl n
AC ← AC + M[SP + n]
Add local
subl n
AC ← AC – M[SP + n]
Subtract local
n designa a posição relativa a SP.
Será portanto a n-ésima posição da pilha a contar do topo.
9
Assembly MAC-1
Exemplo:
uma função que calcula a soma de dois números
public class Exemplo
{
public static int s = 0;
// s – variável global
public static int soma( final int x, final int y)
{
return x + y;
}
public static void main(String[] args)
{
s = soma(10, 15);
}
}
10
Assembly MAC-1
Código MAC-1
jump main
s:
0
main: loco
push
loco
push
call
insp
stod
halt
10
# colocar os argumentos no stack:
# passar o 10 (1º argumento)
15
soma
2
s
soma: lodl 2
addl 1
retn
#
#
#
#
passar o 15 (2º argumento)
chamar a rotina
descartar os argumentos
guardar o valor em s
# carregar x (da pilha)
# somar a y (da pilha)
# retornar (em AC está x+y)
11
Assembly MAC-1
Exemplo: evolução da pilha
Logo após o ‘call’
jump
s:
0
main: loco
push
loco
push
call
insp
stod
halt
main
Argumentos a
passar a ‘soma’.
Colocados na
pilha antes de se
fazer ‘call’.
10
15
soma
2
s
soma: lodl 2
addl 1
retn
SP
7 (end. ret.)
SP
15
10
SP
Logo após ‘retn’
Depois de ‘insp 2’
...
início
12
Programação MAC-1

Exemplo: soma dos n primeiros naturais
Pretende-se implementar uma função que devolve a
soma dos n primeiros números inteiros naturais.
// Possível código da função (em Java)
public static int soma_n( final int n )
{
int soma = 0;
for (int i=1; i<=n; i++)
soma = soma + i;
return soma;
}
13
Programação MAC-1
# soma_n(int n)
jump main
n:
10
# exemplo
main:
lodd n
push
call soma_n # soma_n(10)
insp 1
halt
soma_n: loco 0
push
loco 1
push
ciclo:
Organização da pilha dentro de ‘soma_n’
SP
i
soma
variáveis
locais
ret:
lodl
subl
jneg
lodl
addl
stol
loco
addl
stol
jump
# int soma=0
# int i=1
3
0
#
ret #
1
0
1
#
1
0
0
#
ciclo
lodl 1
insp 2
retn
n-i
while n-i>=0
soma=soma+i
i=i+1
# AC=soma
end. ret.
n
argumento
14
Programação MAC-1

Exemplo: divisão inteira
Pretende-se implementar função que devolve o
quociente da divisão inteira entre dois números inteiros
positivos D e d.

D é o dividendo

d é o divisor

q é o quociente
Nota: Esta função pode ser útil, pois na linguagem assembly do
processador MAC-1 não existe nenhuma instrução para dividir…
15
Programação MAC-1
Possível solução:
utilizar o método das subtracções sucessivas:
// Possível código da função (em Java)
public static int div( int D, final int d )
{
int q = 0;
while (D >= d)
{
q++;
D = D - d;
}
return q;
}
16
Programação MAC-1
main:
jump main
# div(int D, int d)
loco
push
loco
push
call
insp
halt
div:
11
# int q=0
5
div
2
# div(11,5)
Organização da pilha dentro de ‘div’
SP
loco 0
push
q
variável local
end. ret.
d
argumentos
ciclo: lodl
subl
jneg
loco
addl
stol
lodl
subl
stol
jump
ret:
3
2
ret # while D>=d
1
0
0
# q++
3
2
3
# D=D-d
ciclo
lodl 0
insp 1
retn
# AC=q
D
17