Assembly MAC-1 Implementação de ciclos Ciclo ‘while’ // Em Java : ... # Em MAC-1: ... while: lodd i subd c jpos cont ... # xpto loco 1 # addd i # stod i # i = i + 1 jump while cont: ... // Em Java : ... while (i < c) { ... // xpto i = i + 1; }

Assembly MAC-1 Ciclo ‘for’ // Em Java : ... for (i=0; i!=c; i++) { # Em MAC-1: ... loco 0 # stod i # i = 0 for: lodd i subd c jzer cont ... # xpto loco 1 # addd i # stod i # i++ jump for cont: ... // Em Java : ... for (i=0; i!=c; i++) { ... // xpto }

A pilha: chamadas a procedimentos Processador MAC-1 A pilha: chamadas a procedimentos

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

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

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)

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

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)

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)

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);

Assembly MAC-1 Código MAC-1 jump main s: 0 main: loco 10 # colocar os argumentos no stack: push # passar o 10 (1º argumento) loco 15 push # passar o 15 (2º argumento) call soma # chamar a rotina insp 2 # descartar os argumentos stod s # guardar o valor em s halt soma: lodl 2 # carregar x (da pilha) addl 1 # somar a y (da pilha) retn # retornar (em AC está x+y)

Assembly MAC-1 Exemplo (evolução da pilha) Logo após o ‘call’ jump main s: 0 main: loco 10 push loco 15 call soma insp 2 stod s halt soma: lodl 2 addl 1 retn Argumentos a passar a ‘soma’. Colocados na pilha antes de se fazer ‘call’. SP End. Ret. (7) Depois de ‘retn’ SP 15 10 Depois de ‘insp 2’ SP ... início

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

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;

Organização da pilha dentro de ‘soma_N’ Programação MAC-1 jump main n: 10 # exemplo main: lodd n push call soma_N # soma_N(10) insp 1 halt # soma_N(n) soma_N: loco 0 push # soma=0 loco 1 push # i=1 ciclo: lodl 3 subl 0 # n-i jneg ret # while n-i>=0 lodl 1 addl 0 stol 1 # soma=soma+i stol 0 # i=i+1 jump ciclo ret: lodl 1 # AC=soma insp 2 retn Organização da pilha dentro de ‘soma_N’ SP i soma End. Ret. n

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

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;

Organização da pilha dentro de ‘div’ Programação MAC-1 jump main main: loco 11 push loco 5 call div # div(11,5) insp 2 halt # div(D,d) div: loco 0 push # q=0 ciclo: lodl 3 subl 2 jneg ret # while D>=d loco 1 addl 0 stol 0 # q=q+1 lodl 3 stol 3 # D=D-d jump ciclo ret: lodl 0 # AC=q insp 1 retn Organização da pilha dentro de ‘div’ SP q End. Ret. d D