Assembly MAC-1
 Implementação
 Ciclo
‘while’
de ciclos
# Em MAC-1:
...
// Em Java :
while: lodd i
...
while (i < c)
subd c
{
jpos cont
... // xpto
...
# xpto
i = i + 1;
loco 1
#
}
addd i
#
...
stod i
# i = i + 1
jump while
cont:
...
1
Assembly MAC-1
 Ciclo
‘for’
# Em MAC-1:
...
// Em Java :
...
for (i=0; i!=c; i++)
{
for:
loco 0
#
stod i
# i = 0
lodd i
subd c
... // xpto
jzer cont
}
...
...
# xpto
loco 1
#
addd i
#
stod i
# i++
jump for
cont:
...
2
Processador MAC-1
A pilha: chamadas a procedimentos
3
A pilha

Durante a execução dos programas são normalmente invocados
procedimentos

Cada procedimento pode possuir:

Variáveis locais (válidas apenas dentro do procedimento)

Argumentos (“passados” ao procedimento)

Este tipo de dados são criados num espaço da memória designado
por pilha (ou stack)

Sendo assim, a pilha é utilizada para guardar:

Argumentos passados aos procedimentos

Variáveis locais dos procedimentos

Endereços de retorno dos procedimentos

Outros dados de carácter temporário
4
A pilha

Invocação de procedimentos

Do lado da invocação:




Colocar os argumentos na pilha
Invocar o procedimento
Descartar os argumentos da pilha
Dentro do procedimento:




Criar as variáveis locais (colocando-as na pilha)
Executar o código do procedimento
Destruir as variáveis locais (descartando-as da pilha)
Retornar do procedimento
5
A pilha

Retorno dos procedimentos

Quando é invocado um procedimento, é colocado na pilha o
valor guardado no Program Counter.

Quando o procedimento retorna, é lido da pilha o valor de PC
armazenado anteriormente.

Em princípio a função devolve um único valor


O valor é devolvido através do Acumulador (AC)
As variáveis locais e os argumento são acedidos através
de endereçamento local

Endereços calculados com base no valor guardado no Stack
pointer (SP)
6
Assembly MAC-1
 Invocação/retorno
de procedimentos
Instruções:
Mnemónica
Descrição
Significado
CALL x
SP ← SP – 1; M[SP] ← PC; PC ← x Call procedure
RETN
PC ← M[SP]; SP ← SP + 1
Return
x é qualquer valor inteiro entre 0 e 4095 (12 bits)
ou uma label que represente um endereço
7
Assembly MAC-1
 Manipulação
básica da pilha
Instruções:
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 é qualquer valor entre 0 e 255 (8 bits)
8
Assembly MAC-1
 Endereçamento
local
Instruções:
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 é qualquer valor entre 0 e 255 (8 bits)
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)
jump
s:
0
main: loco
push
loco
push
call
insp
stod
halt
Logo após o ‘call’
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
End. Ret. (7)
SP
15
10
SP
Depois de ‘retn’
Depois de ‘insp 2’
...
início
12
Programação MAC-1
 Exemplo:
Soma dos N primeiros números
Pretende-se fazer uma função que calcula a
soma dos números inteiros entre 1 e N

N é o argumento passado à função
13
Programação MAC-1

Possível solução:
usar uma variável local para ir acumulando a soma.
// Código da função (em Java)
public static int soma_N( final int n )
{
int soma = 0, i;
for ( i=1; i<=n; i++)
{
soma = soma + i;
}
return soma;
}
14
Programação MAC-1
# soma_N(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
ret:
lodl
subl
jneg
lodl
addl
stol
loco
addl
stol
jump
# soma=0
# 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
15
Programação MAC-1

Exemplo: Divisão inteira
No MAC-1 não existe nenhuma instrução para dividir…
Vamos fazer uma função que calcule o resultado da
divisão inteira entre dois números inteiros positivos.

D é o dividendo

d é o divisor

q é o quociente
16
Programação MAC-1

Possível solução:
utilizar o método das subtracções sucessivas:
// Possível código (em Java)
public static int div( int D, final int d )
{
int q = 0;
while (D >= d)
{
q = q + 1;
D = D - d;
}
return q;
}
17
Programação MAC-1
main:
jump main
# div(D,d)
loco
push
loco
push
call
insp
halt
div:
11
# q=0
5
div
2
# div(11,5)
Organização da pilha dentro de ‘div’
SP
loco 0
push
q
End. Ret.
d
ciclo: lodl
subl
jneg
loco
addl
stol
lodl
subl
stol
jump
ret:
3
2
ret # while D>=d
1
0
0
# q=q+1
3
2
3
# D=D-d
ciclo
lodl 0
insp 1
retn
# AC=q
D
18