Aula 5 – Sumário
 Revisão
da aula anterior
 Funções
e procedimentos
 Endereçamento
 Instruções
 Acesso
indirecto
pshi e popi
a vectores e matrizes
 Passagem
de referências
 Exemplos
1
Processador MAC-1
Revisão – funções e procedimentos
2
Revisão – funções e procedimentos
Exemplo: Potência natural de 2
Implementar uma função que calcula 2n. n é o valor do
argumento que é passado à função.
// Pseudo-código da função
int power2(int n)
{
int p=1;
for (int i=0, i!=n; i++)
p=2*p;
return p;
}
3
Programação MAC-1
# power2(int n)
jump main
n_ex:
10
# exemplo
power2: lodd n_ex
push
call power2
insp 1
halt
power2: loco 1
push
loco 0
push
ciclo:
Organização da pilha em ‘power2’
SP
p
End. Ret.
n
ret_p:
# i=0
lodl 0
subl 3
jzer ret_p
# i-n==0?
lodl 1
addl 1
stol 1
# p=p+p
loco
addl
stol
jump
i
# criar as var. locais
# p=1
1
0
0
ciclo
lodl 1
insp 2
retn
(p=2*p)
# i=i+1
# AC=p (valor a devolver)
# descartar as locais
4
Processador MAC-1
Endereçamento indirecto
5
Assembly MAC-1

Endereçamento indirecto no MAC-1

Acesso aos elementos de vectores / matrizes
Mnemónica
pshi
popi
Descrição
SP = SP – 1;
M[SP] ← M[AC]
M[AC] ← M[SP];
SP = SP + 1
Significado
Push indirect
Pop indirect
Semelhantes a “push” e “pop”, mas as transferências de dados envolvem
neste caso uma posição de memória que é indicada pelo registo AC.
6
Assembly MAC-1: PSHI
0
1
2
3
4
5
6
SP
PSHI
x
10
6
12
27
x
x
SP
SP
x
x
x
x
10
6
12
27
x
x
12
x
x
x
x
Pilha
x
Pilha
x
AC
0
1
2
3
4
5
6
x
3
7
Assembly MAC-1: POPI
0
1
2
3
4
5
6
SP
POPI
x
10
6
12
27
x
x
SP
SP
50
x
x
x
x
10
6
12
50
27
x
x
50
x
x
x
x
Pilha
x
Pilha
x
AC
0
1
2
3
4
5
6
x
3
8
Assembly MAC-1: PSHI e POPI

Sintetizando:

PSHI
coloca no topo da pilha o valor que está na posição de
memória indicada por AC

POPI
coloca na posição de memória indicada por AC o valor
que está no topo da pilha
9
Programação MAC-1
Exemplo:
calcular a soma de todos os elementos de um vector
// Pseudo-código
int m[5] = {1, 2, 5, 7, 2};
void main()
{
int i=0, soma = 0;
while ( i!=5 )
{
soma = soma + m[i];
i = i + 1;
}
}
10
Programação MAC-1
jump main
m:
1 2 5 7 2 # valores guardados no vector m
n_elem: 5
# numero de elementos
main:
loco 0
push
push
ciclo:
lodd n_elem
subl 1
jzer fim # 5-i=0?
fim:
# criar as variáveis locais:
# i = 0
# soma = 0
loco
addl
pshi
pop
addl
stol
m
1
loco
addl
stol
jump
1
1
1
# i=i+1
ciclo
0
0
lodl 0
insp 2
halt
#
#
#
#
SP
soma
i
calcula a posição do i-ésimo elemento,
em AC fica o endereço da posição m+i
coloca na pilha o valor que está na posição m+i (m[i])
tira m[i]da pilha e põe no AC
# soma = soma + m[i]
SP
m[i]
soma
i
# vai acabar com AC = soma
11
Funções e vectores / matrizes

Para uma função usar um vector (ou uma matriz)
passa-se uma referência à função

A referência não é mais do que a posição de memória do
primeiro elemento do vector (ou da matriz)

Os restantes elementos são acedidos com base nessa posição
de referência
Memória
Referência
para A
Exemplo:
Um vector A em memória. Acedem-se
aos vários elementos a partir da
referência (a posição de memória 2)
0
1
2
3
4
5
6
7
x
x
5
A[0]
7
A[1]
6
A[2]
8
A[3]
Vector A
x
x
...
12
Programação MAC-1
Exemplo:
Implementar um procedimento que mostre no ecrã os
elementos de um vector (para simplificar, vamos assumir
que são inteiros entre 0 e 9).
// Pseudo-código
void mostra_vec(int[] v, int length)
{
for (int i=0; i!=length; ++i)
{
v[i]  output;
}
}
v é a referência para o vector a mostrar
length é o número de elementos do vector
13
Programação MAC-1
jump main
vec1:
6 4 3 5 7
length: 5
char0: '0'
main:
loco
push
lodd
push
call
insp
halt
vec1
length
# mostra_vec(int[] v, int length)
mostra_vec:
loco 0
push
# int i=0
ciclo: lodl 0
subl 2
jzer fim
# i==length?
lodl 3
addl 0
pshi
pop
mostra_vec
2
addd
stod
loco
stod
char0
4094
' '
4094 # mostra no ecran
Organização da pilha em ‘mostra_vec’
loco 1
addl 0
stol 0
SP
jump ciclo
i
End. Ret.
length
vector (ref.)
fim:
# v[i] na pilha
# i=i+1
loco 10
# 10 é o código ascii
stod 4094 # ‘fim de linha’
insp 1
retn
14
Matrizes (arrays)

Uma matriz é uma abstracção própria das
linguagens de programação de alto nível


Uma estrutura regular de dados, com n dimensões,
cujos elementos são acedidos através de índices
(tantos índices quanto as dimensões)
Em geral, para um processador não existe o
conceito de matriz com n dimensões

Para o CPU, uma matriz não é mais do que um
conjunto de vectores em memória

A razão para tal é o facto da memória só ter uma
dimensão
15
Matrizes (arrays)
Exemplo:
Considere a matriz B, bidimensional
j
i
0
1
2
3
0
5
7
6
8
1
12
3
23
1
2
0
15
2
9
Qual será a posição de memória
correspondente a B[1][2]?
pos  ref. B  i  n _ cols  j
Referência
para B
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
x
x
x
5
7
6
i=0
8
12
3
23
i=1
1
0
15
2
i=2
9
x
x
pos  3  1 4  2  9
...
16