exercicio_subprog

Exercícios de Arquitetura de Computadores:
Como é feita a chamada de um subprograma ?
A chamada de um subprograma é feita através de uma instrução call que possui o
seguinte formato:
Cod. Op.
End. do operando
Call End. do subprograma
Quando executada a instrução call, primeiramente é salvo o endereço de retorno,
ou seja, o endereço da próxima instrução a ser executada. Este endereço está no
CI, no momento da execução da instrução call. O conteúdo do CI é empilhado.
sp  sp –1
Memória[sp]  CI
Empilha CI
A partir daí é feito o desvio, é movido para o CI o conteúdo do campo de
endereço do operando – o endereço do subprograma.
CI  endereço do
subprograma
Desvia para o
subprograma
Qual é o conteúdo no topo da pilha no instante inicial (de começar executar a
primeira instrução) de um subprograma ?
O conteúdo existente no topo da pilha será o endereço de retorno da
subprograma que é igual ao endereço da próxima instrução a ser executada
imediatamente a instrução call.
Pilha antes
//////////
//////////
 sp
Pilha depois da chamada
End.
retorno
//////////
//////////
 sp (endereço do topo da
pilha)
Por quê, quando fazemos várias chamadas sucessivas de subprogramas, o
retorno deve ocorrer na ordem inversa das chamadas ?
Quando temos chamadas sucessivas a subprograma os endereços de retorno
são empilhados na ordem da chamada, portanto, a cada instrução que retorno
executada é retirado o que estiver no topo da pilha. Quando o controle retorna
para o programa principal, a pilha deve estar como estava quando ocorreu a
chamada.
Como ocorre o retorno de um subprograma ?
Todo subprograma possui, em seu final, uma instrução de retorno, chamada de
ret ou return. Esta instrução retira o conteúdo armazenado no topo da pilha
movendo-o para o CI.
Como é feita a passagem de parâmetros para subprograma ?
Passagem por valor ou por endereço.
Na passagem por valor o subprograma recebe, na pilha, uma cópia do valor do
parâmetro especificado na chamada. O subprograma operará com este valor.
Na passagem por endereço o subprograma recebe, na pilha, o endereço do
parâmetro especificado na chamada. O subprograma utilizará este endereço para
acessar a variável na memória.
Compare os dois modos de passagem de parâmetros, mostrando qual o conteúdo
da pilha em cada caso.
I)
Na passagem de parâmetros por valor, são colocados na pilha o valor dos
parâmetro, portanto, para 3 parâmetros passados por valor teremos:
Pilha
End. de retorno
Parâmetro 3
Parâmetro 2
Parâmetro 1
/////////////////
///////////////////
II)
 sp (endereço do topo da pilha)
Valor do parâmetro 3 especificado na chamada.
Valor do parâmetro 2 especificado na chamada.
Valor do parâmetro 1 especificado na chamada.
Na passagem de parâmetros por endereço, é colocado na pilha o endereço
do parâmetro, portanto, para 3 parâmetros sendo o primeiro passado por
endereço, segundo e o terceiro por valor teremos:
Pilha
End. de retorno  sp (endereço do topo da pilha)
Valor do terceiro parâmetro especificado na
3 Parâmetro
chamada.
Valor do segundo parâmetro especificado na
2 Parâmetro
chamada.
Endereço do 1 Endereço do primeiro parâmetro especificado na
chamada.
parâmetro
/////////////////
///////////////////
Vemos que na passagem por valor a pilha armazena o valor do parâmetro e é
sobre este valor que o subprograma opera. Já na passagem por endereço a pilha
conterá o endereço do parâmetro que será utilizado pelo subprograma para
acessar a variável no programa que executou a chamada.
CHAMADA DE SUBPROGRAMA
 Salvamento do endereço de retorno;
 Desvio para o subprograma.
Salvamento do endereço de retorno:
- Pilha: estrutura de dados do tipo lista linear
na qual as inserções, consultas e
exclusões acontecem em um mesmo
extremo (topo)
xxx
xxx
 sp
xxx
xxx
CI - endereço da próxima instrução a ser
executada