EA869 Subrotinas Faculdade de Engenharia Elétrica e de Computação (FEEC) Universidade Estadual de Campinas (UNICAMP) Prof. Levy Boccato 1.

Apresentação em tema: "EA869 Subrotinas Faculdade de Engenharia Elétrica e de Computação (FEEC) Universidade Estadual de Campinas (UNICAMP) Prof. Levy Boccato 1."— Transcrição da apresentação:

1 EA869 Subrotinas Faculdade de Engenharia Elétrica e de Computação (FEEC) Universidade Estadual de Campinas (UNICAMP) Prof. Levy Boccato 1

2 Objetivos Definir o conceito de subrotina e sua importância na implementação de código em linguagem de montagem. Conhecer as estratégias para a correta preparação de subrotinas. Conhecer de que modo são passados parâmetros à subrotina. 2

3 Recordando Nas últimas aulas, vimos como um processador pode executar instruções de forma mais eficiente através da técnica de pipeline. Além disso, também conhecemos quais os modos de endereçamento permitidos em uma instrução. Resumidamente, aprendemos como melhorar o desempenho de um processador no que diz respeito à taxa de execução das instruções, e como adequar a instrução aos dados que queremos manipular. 3 Como otimizar a escrita de um programa Assembly, principalmente em relação ao uso da memória?

4 Exemplo Considere o exemplo abaixo em linguagem Assembly fictícia, onde o OP1 é o registrador destino: 4 O programa faz somas de posições contíguas da memória e armazena o resultado no último endereço. Necessita de 15 linhas de memória. O que poderíamos fazer para otimizar a escrita deste programa? MOV R0, #200 MOV R0, #100 MOV R0, #300 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2

5 Exemplo Observe que parte do código se repete ao longo do programa. 5 MOV R0, #200 MOV R0, #100 MOV R0, #300 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2

6 Exemplo Observe que parte do código se repete ao longo do programa. 6 MOV R0, #200 MOV R0, #100 MOV R0, #300 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 Criar um subprograma ou uma subrotina! O que poderíamos fazer para resolver essa redundância? MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS Label identifica a posição de memória onde se inicia a subrotina. Instrução que informa o fim da subrotina.

7 Exemplo Observe que parte do código se repete ao longo do programa. 7 Criar um subprograma ou uma subrotina! O que poderíamos fazer para resolver essa redundância? MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS Label identifica a posição de memória onde se inicia a subrotina. Instrução que informa o fim da subrotina. MOV R0, #100 MOV R0, #200 MOV R0, #300 PRINC: CALL SUB MOV R0, #200 CALL SUB MOV R0, #300 CALL SUB Instrução que chama a subrotina

8 Exemplo Observe que parte do código se repete ao longo do programa. 8 Criar um subprograma ou uma subrotina! O que poderíamos fazer para resolver essa redundância? MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS Label identifica a posição de memória onde se inicia a subrotina. Instrução que informa o fim da subrotina. MOV R0, #100PRINC: CALL SUB MOV R0, #200 CALL SUB MOV R0, #300 CALL SUB Instrução que chama a subrotina O programa que antes ocupava 15 linhas de memória, agora necessita apenas de 6. Além disso, a subrotina poderá ser aproveitada em outras partes do programa, tornando o código que efetivamente é armazenado mais enxuto. Conceito de modularização

9 Subrotinas Definição: 9  Subrotinas permitem que uma mesma sequência de instruções seja executada em diferentes pontos de um programa, sobre diferentes conjuntos de dados.  O fluxo de execução do programa será desviado para a posição de memória onde a subrotina está armazenada; após a execução da mesma, o controle deverá ser retornado ao ponto imediatamente posterior ao da ocorrência do desvio.  Subrotinas permitem que uma mesma sequência de instruções seja executada em diferentes pontos de um programa, sobre diferentes conjuntos de dados.  O fluxo de execução do programa será desviado para a posição de memória onde a subrotina está armazenada; após a execução da mesma, o controle deverá ser retornado ao ponto imediatamente posterior ao da ocorrência do desvio.

10 Subrotinas Vantagens:  Redução de código duplicado em um programa.  Possibilidade de reutilizar o mesmo código sem grandes alterações em outros programas.  Decomposição de problemas grandes em pequenas partes – recurso bastante comum em linguagens de alto nível.  Melhorar a interpretação visual de um programa.  Esconder ou regular uma parte de um programa, mantendo o restante do código alheio às questões internas que são resolvidas ou implementadas dentro da subrotina. 10

11 Voltando ao exemplo 11 MOV R0, #100 MOV R0, #200 PRINC: CALL SUB MOV R0, #200 CALL SUB MOV R0, #300 CALL SUB MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS Vamos executá-lo! CALL SUB Desvio para Subrotina Guardar o endereço de retorno Desviar a execução do programa para a Subrotina 13 10 11 12 14 1 7 2 3 4 5 6 PC 1 2 End-R 3 10 1112 13 14 RTS Retorno para o programa Desviar a execução para o endereço correto (End-R) Como implementar as instruções CALL e RTS?

12 Implementando uma subrotina 12 Vamos definir algumas estratégias para implementar subrotinas, determinando as microoperações envolvidas nas instruções CALL e RTS. Voltando para nosso programa inicial, mas agora simplificado: MOV R0, #100PRINC: CALL SUB MOV R0, #200 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS 13 10 11 12 14 1 2 3 ESTRATÉGIA 1: REGISTRADOR LIGANTE (RL) O endereço de retorno é armazenado em um registrador especial (RL) CALL SUB RL ← (PC) PC ← end-de-SUB Endereço seguinte à instrução CALL RL 3 1. Armazena o endereço de retorno em RL: 2. Desvia a execução para a subrotina: PC 2 3 10 14 RTS 1. Desviar a execução do programa para endereço contido em RL PC ← (RL)

13 Implementando uma subrotina 13 MOV R0, #100PRINC: CALL SUB MOV R0, #200 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS 13 10 11 12 14 1 2 3 ESTRATÉGIA 2: ENDEREÇO DE RETORNO JUNTO À SUBROTINA O endereço de retorno é armazenado na primeira linha da subrotina Como? Reservando a palavra de memória referente a primeira linha da subrotina: pseudo-instrução DS

14 Implementando uma subrotina 14 MOV R0, #100PRINC: CALL SUB MOV R0, #200 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS 13 10 11 12 14 1 2 3 ESTRATÉGIA 2: ENDEREÇO DE RETORNO JUNTO À SUBROTINA O endereço de retorno é armazenado na primeira linha da subrotina CALL SUB SUB ← (PC) PC ← end-de-SUB Endereço seguinte à instrução CALL 1. Endereço de retorno é armazenado no endereço SUB 2. Desvia a execução para a subrotina: RTS 1. Desviar a execução do programa para endereço contido em SUB PC ← (SUB) Como? Reservando a palavra de memória referente a primeira linha da subrotina: pseudo-instrução DS 15 DS 1

15 Implementando uma subrotina 15 MOV R0, #100PRINC: CALL SUB MOV R0, #200 MOV (R0), R3 MOV R1, (R0)+ MOV R2, (R0)+ ADD R3, R1, R2 SUB: RTS 13 10 11 12 14 1 2 3 ESTRATÉGIA 2: ENDEREÇO DE RETORNO JUNTO À SUBROTINA 15 DS 1 Qual é a limitação destas duas formas de implementação? Para exemplificar, vamos analisar um exemplo real com o processador ARM...

16 Exemplo: ARM 16 11MOV R1,R2 12BL SUB1 13... 14 20SUB1:... 21BL SUB2 22... 23BX LR 40SUB2:... 41... 42BX LR 43 1322 R14(LR) Como solucionar? Uso da Pilha! PROG. PRINC SUBROTINA 1SUBROTINA 2 NÃO é possível chamar uma subrotina estando dentro de outra subrotina!

17 Implementando uma subrotina 17 MOV R0, #100PRINC: CALL SUB MOV R0, #200 SUB2:MOV R1, R3 MOV R1, (R0)+ CALL SUB2 RTS SUB: RTS 10 11 12 14 1 2 3 ESTRATÉGIA 3: ENDEREÇO DE RETORNO ARMAZENADO NA PILHA 15 O endereço de retorno é armazenado na última posição livre da pilha. Desta forma, pode-se chamar subrotinas recursivamente

18 Implementando uma subrotina 18 ESTRATÉGIA 3: ENDEREÇO DE RETORNO ARMAZENADO NA PILHA O endereço de retorno é armazenado na última posição livre da pilha. Desta forma, pode-se chamar subrotinas recursivamente CALL SUB (SP) ← (PC) PC ← end-de-SUB 1. Endereço de retorno é armazenado na pilha 2. Desvia a execução para a subrotina: SP ← (SP) + 1 MOV R0, #100PRINC: CALL SUB MOV R0, #200 SUB2:MOV R1, R3 MOV R1, (R0)+ CALL SUB2 RTS SUB: RTS 10 11 12 14 1 2 3 15 RTS SP ← (SP) - 1 1. Endereço de retorno é retirado da pilha e alocado em PC PC ← ((SP)) PILHA 3 12

19 Subrotinas 19 Agora que já sabemos estratégias de como implementar uma subrotina usando as instruções CALL e RTS, precisamos abordar a questão de como os dados são passados para a subrotina. Ao chamar uma subrotina através da instrução CALL, é necessário informar onde estão os dados que ela irá manipular. Estes dados formam os parâmetros reais. MOV R0, #100 CALL SUB (A,B) MOV R0, #200 Ao declarar uma subrotina, deve-se indicar quais variáveis ela irá manipular. Estas variáveis são conhecidas como parâmetros formais. Toda vez que a subrotina é chamada, estes parâmetros são substituídos pelos reais enviados para a subrotina. SUBROTINA SUB (X,Y) X = Y*3 Y = 3 + X Finalmente, como os dados são passados para a subrotina?

20 Passagem de parâmetros 20 Existem duas formas de informá-los à subrotina: Desta forma, toda vez que a subrotina manipula um dado, ela está alterando-o permanentemente. Toda vez que a subrotina manipula um dado, ela está alterando uma cópia dele, mantendo inalterado o dado original. Por Valor Por Referência Passo para a subrotina uma cópia do dado Como? Passando o conteúdo do endereço Considere que os dados que a subrotina irá manipular estejam na memória. Passo para a subrotina o endereço do dado Como? Informando o endereço #label Implicações Mas como os dados são alocados na memória?

21 Passagem de parâmetros 21 Como os dados são alocados na memória? Basicamente há duas formas de alocar dados na memória: 1. Através de periféricos: Mouse, teclado, tela touchscreen, HD, enviam dados para os processadores. Estes dados são alocados, primeiramente, na memória e ficam disponíveis para serem acessados pelos programas. 2. Através de pseudo-instruções: É um tipo especial de instrução (veremos mais adiante), não executável, que insere valores em posições de memória ou reserva espaço para receber valores: DS X Reserva X palavras da memória a partir da posição da pseudo- instrução. DW X Posição de memória desta pseudo- instrução recebe o valor X.

22 Passagem de parâmetros 22 Vamos analisar mais detalhadamente como se procede a passagem de parâmetros por valor e por referência: DADO: DW 200 RESULT: DS 1 MOV DADO, R1 MOV #RESULT, R3 CALL SUB SUB:... MOV R1, (R3)... RTS DADO: DW 200 RESULT: DS 1 MOV #DADO, R1 MOV R2, RESULT CALL SUB SUB:... MOV (R1),R2... RTS ADD #10, R2 valor referência

23 Passagem de parâmetros 23 INICIALIZAÇÃO DOS DADOS PASSAGEM DE PARÂMETROS Vamos identificar a passagem de parâmetros no programa abaixo e verificar, passo a passo, as posições de memória dos dados de entrada e saída: MOVE DAD1, DIN1 MOVE DAD2, DIN2 CALL SUB MOVE RES, RESU STOP DAD1: DW 5 DAD2: DW 18 RESU: DS 1 DIN1: DS 1 DIN2: DS 1 RES: DS 1 SUB: ADD DIN1, DIN2 MOVE DIN2, RES RTS PROGRAMASUBROTINA valor

24 Passagem de parâmetros 24 Consideremos agora que a chamada da subrotina foi implementada com pilha. Façamos o mesmo procedimento do exemplo anterior, considerando que DADO está na posição 20 de memória e que cada instrução ocupa uma palavra. SUB: POP R3 POP R2 MOV (R2),R5 SUB #3, R5 PUSH R5 PUSH R3 RTS MOV #0,SP CALL SUB STOP DADO: DW 50 RES: DS 1 MOV #DADO,R1 PUSH R1 POP R1 MOV R1, RES DADORESR1R2R3R5SP01 Inic. (1) (2) (3) (4) (100) (101) (102) (103) (104) (105) (106) (5) (6) (1) (2) (3) (4) (100) (101) (102) (103) (104) (105) (106) (5) (6)... 50 X X XXX X XX 0 X X XXXXX 20 0 50 X XXXXX 20 1 50 X X X XX 20 5 2 50 X X X X 20 5 1 50 XX 5 X 20 5 0 50 X 20 5 X 5 0 50 X 20 5 50 20 5 0 50 X 20 5 47 20 5 1 50 X 20 5 47 20 47 2 50 X 20 5 47 20 5 47 PC ← 5 50 X 20 5 47 20 1 X 47 50 X 20 5 47 0 X 50 47 20 5 47 0 X

25 Conclusão Uma forma eficiente de escrever um programa é através da modularização de partes repetidas do código. Estes módulos podem ser acessados pelo programa em diferentes momentos e com diferentes dados de entrada –são conhecidos como subrotinas. A subrotina é chamada por uma instrução especial (CALL) e sua execução termina com a instrução RTS. As instruções CALL e RTS podem ser implementadas através de 3 estratégias: via registrador RL, via endereço de retorno na primeira linha da subrotina e via pilha. Os dados podem ser passados para a subrotina de duas formas (passagem de parâmetros): por valor, onde passo uma cópia do dado e por referência, onde passo o endereço do dado. O uso da pilha é de extrema importância nas chamadas de subrotina, já que permite que elas chamem outras subrotinas (ou elas próprias, num esquema recursivo). Tal fato faz seu uso ser bastante comum nos processadores. 25

26 Créditos 26  Este material está baseado nas notas de aula elaboradas pelo Prof. Léo Pini e pelo aluno de doutorado Tiago Novaes.