Aula 11 - Professor Diovani

Arquitetura e organização de
computadores
Pilhas
Chamadas de sub-rotinas
Aula 11
Prof. Diovani Milhorim
Chamada de sub-rotina.
Sub-rotinas são usadas quando existe alguma
tarefa em um programa que será necessário
executar mais de uma vez. Por exemplo:
 procurar um elemento em uma tabela
 imprimir uma lista
 classificar elementos em uma lista
 acessar uma estrutura de dados
 efetuar uma operação algébrica,
 etc.
Chamada de sub-rotina.
Qualquer que seja a tarefa a ser executada,
se for preciso fazê-lo mais que uma vez no
programa, não se deve repetir a mesma série
de instruções várias vezes, o que seria um
desperdício de memória e de tempo, além de
eventualmente
ocasionar
erros.
Chamada de sub-rotina.
 A alternativa é agrupar as instruções que
executam a tarefa desejada em uma sub-rotina,
e sempre que for necessário realizar aquela
tarefa, basta inserir uma instrução para chamar
a sub-rotina; quando a tarefa da sub-rotina tiver
terminado, basta retornar ao ponto do seu
programa principal imediatamente posterior
àquele em que a sub-rotina foi chamada.
Chamada de sub-rotina.
O conceito de sub-rotina é o mesmo em
qualquer linguagem utilizada e em
qualquer processador, embora sua
implementação seja sempre um pouco
diferente de um para outro. O local onde o
ponto de retorno ao programa principal é
salvo é uma estrutura chamada pilha.
Chamada de sub-rotina.
Pilha é uma área da memória principal,
endereçada pelo Stack Pointer. O
programa deve inicializar o ponteiro da
pilha com o endereço base da pilha
(geralmente o mais alto disponível na
MP). A pilha cresce decrementando o
ponteiro da pilha.
Chamada de sub-rotina.
 Pilha (stack) é uma área da memória principal,
endereçada pelo Stack Pointer (ponteiro da
pilha). O programa deve inicializar o ponteiro da
pilha com o endereço base da pilha (geralmente
o mais alto disponível na MP). O ponteiro da
pilha aponta para o último endereço ocupado da
pilha (em algumas máquinas o ponteiro da pilha
aponta para a primeira posição vaga). A pilha
cresce decrementando o ponteiro da pilha (em
algumas
máquinas
a
pilha
cresce
incrementando o ponteiro da pilha).
Chamada de sub-rotina.
Pilha
Chamada de sub-rotina.
 Exemplo de Processamento de sub-rotina e uso da pilha
 - execução linear do programa principal
 - preparação para chamada à sub-rotina: o contexto do programa é salvo
na pilha (acumulador, flags, outros registradores)
 o valor no acumulador é armazenado no primeiro endereço vago da Pilha:
(SP - 1) <-- A
 flags são salvos no próximo endereço vago da pilha: (SP - 2) <--Registrador Flags.
 o SP (ponteiro da pilha) é decrementado: SP <--- SP-2 (foram ocupadas
duas posições na pilha)
 - instrução CALL endereço (instrução de chamada de uma sub-rotina com
início em endereço)
 o endereço da próxima instrução do programa principal (contido no CI) é
salvo (push) na pilha: (SP - 1) <--- PCH e (SP - 2) <--- PCL
 o endereço da sub-rotina (endereço) é carregado no CI (Program Counter),
logo: CI <--- endereço
 a sub-rotina é então executada
Chamada de sub-rotina.
 Exemplo de Processamento de sub-rotina e uso da pilha
 Ao final da execução da sub-rotina, é executada a instrução de
retorno RET
 - instrução RET (obs.: a instrução RET não tem operando)
 o endereço de retorno da sub-rotina para o programa principal é
retirado da pilha (pop) e carregado no CI logo: CI <--- (SP) e
incrementa o SP, portanto SP <--- SP + 2 (lembrar que no Intel 8080
um endereço ocupa duas posições de memória).
 - restaura o contexto do programa principal (acumulador e flags),
trazendo (pop), na ordem inversa, o conteúdo que tinha sido salvo
na pilha
- volta a executar em seqüência linear o programa principal
Chamada de sub-rotina.
Processamento de sub-rotina
Chamada de sub-rotina.
 As sub-rotinas podem ser aninhadas, isto é,
este processo pode ser repetitivo (uma subrotina pode chamar uma segunda sub-rotina, e
esta uma terceira, e assim por diante), sempre
repetindo este processo. O retorno se fará
obrigatoriamente no sentido inverso, isto é, da
última chamada para a primeira. A pilha é uma
estrutura LIFO (last in, first out), ou seja, o
último a entrar é o primeiro a sair.
Chamada de sub-rotina.
 Fluxo de Processamento de Sub-rotinas Aninhadas
PROCESSAMENTO LINEAR DO PROGRAMA PRINCIPAL
instrução CALL ---------> SUB-ROTINA 1
---------------------------| processa sub-rotina 1
---------------------------| CALL sub-rotina 2
---------------------------|------------------------------| processa sub-rotina 2
---------------------------|------------------------------| RET
---------------------------| continua processamento sub-rotina 1
---------------------------| RET
CONTINUA PROCESSAMENTO DO PROGRAMA PRINCIPAL