stack pointer, Ponteiro da Pilha:

Um registrador que contm o endereo atual do elemento superior da pilha. Na cincia da computao, uma Stack Pointer (ou Ponteiro da Pilha, Pilha de Execuo) uma pilha que armazena informaes sobre as sub-rotinas ativas num programa de computador. Seu principal uso registrar o ponto em que cada sub-rotina ativa deve retornar o controle de execuo quando termina de executar. Por exemplo, se uma sub-rotina DesenhaQuadrado chama (invoca) a subrotina DesenhaLinha em quatro pontos diferentes, o cdigo de DesenhaLinha deve saber como retornar aDesenhaQuadrado. Isso geralmente feito adicionando o endereo de retorno na Stack Pointer aps a chamada da subrotina. Sendo organizada como uma pilha, quem invoca a sub-rotina empilha o endereo de retorno. Quando termina sua execuo, a sub-rotina invocada desempilha o endereo de retorno, desviando a execuo para aquele endereo. Se durante sua execuo a sub-rotina invocada tambm invocar outra sub-rotina, o endereo de retorno tambm ser empilhado, e assim por diante. Quando esse processo de empilhamento consome todo o espao alocado para a Stack Pointer, ocorre um erro chamado estouro de pilha. Existe um Stack Pointer para cada thread sendo executada, ainda que mais pilhas possam ser criadas para o tratamento de sinais ou para multitarefa cooperativa. Emlinguagens de alto nvel, detalhes da Stack Pointer so geralmente escondidos do programador. Eles tm acesso somente a lista de sub-rotinas empilhadas, e no memria da Stack Pointer em si. Por outro lado, a maioria das linguagens de montagem requerem que programador manipule a Stack Pointer.
ATRIBUIES

Uma das principais atribuies duma Stack Pointer armazenar o endereo de retorno. Quando uma sub-rotina chamada, a localizao da instruo a ser retornada deve ser salva. Usar uma pilha para salvar o endereo de retorno possui importantes vantagens. Uma delas que cada tarefa possui sua prpria pilha, o que permite reentrncia. Outro benefcio o suporte automtico a recursividade. Outra atribuio o armazenamento de variveis locais. Uma sub-rotina frequentemente precisa de memria para armazenar variveis locais, aquelas que so usadas somente durante a execuo da sub-rotina. Geralmente aloca-se espao na prpria Stack Pointer para tal, o que muito rpido comparado a alocao dinmica de memria. Tambm relacionado a variveis locais est a passagem de parmetros, mais uma atribuio. Uma sub-rotina frequentemente precisa ser alimentada por parmetros quando invocada, e comum usar a Stack Pointer para tal. De forma geral, se h poucos e pequenos parmetros, registradores do processador so usados para passar os parmetros. Mas se h muitos parmetros, ou se eles ocupam muito espao, a Stack Pointer usada. Operandos de operaes aritmticas ou lgicas so manipulados a partir de registradores, de onde so calculados. Mas para casos especficos deve-se usar

uma profundidade especfica de operandos, algo que somente registradores no conseguem armazenar. A pilha de operaes aritmticas e lgicas pode estar localizada na Stack Pointer. Algumas linguagens orientadas a objeto armazenam o ponteiro this junto aos parmetros dos mtodos sendo invocados. Esse ponteiro indica a instncia associada ao mtodo sendo invocado, sendo essencial para fornecer contexto a execuo. Tambm relacionado a contexto, algumas linguagens de programao suportam sub-rotinas aninhadas, permitindo que a rotina aninhada acesse o contexto externo, da rotina que a aninhou (parmetros, variveis locais). Tais linguagens geralmente aceitam a chamada recursiva da sub-rotina aninhada, sendo que todas as chamadas recursivas apontam para o mesmo contexto externo. Alm do endereo de retorno, alguns ambientes podem suportar outros estados que so restaurados no retorno duma sub-rotina, como nveis de privilgio, informao para o tratamento de excees, entre outros.
ESTRUTURA

Uma Stack Pointer composta por quadros (muitas vezes chamados de registros de ativao[1]),estruturas de dados que dependem da implementao e que contm informaes sobre o estado da sub-rotina. Cada quadro da pilha corresponde a uma chamada de sub-rotina que ainda no retornou. Por exemplo, se uma sub-rotina DesenhaLinha est em execuo, e foi chamada porDesenhaQuadrado, o topo da Stack Pointer pode ser estruturada da seguinte forma:

Variveis locais de DesenhaLinha Endereo de retorno Quadro de DesenhaLinha Ponteiro do quadro Parmetros de DesenhaLinha Variveis locais de DesenhaQuadrado Quadro de Endereo de retorno DesenhaQuadrado Parmetros de DesenhaQuadrado

Stack Pointer

topo da pilha

O quadro de pilha no topo da pilha se refere a sub-rotina em execuo. Geralmente o quadro inclui espao para as variveis locais, o endereo de retorno para a sub-rotina que invocou a outra (quadro de pilha seguinte) e os parmetros passados para a sub-rotina. A pilha geralmente acessada atravs do registrador "Stack Pointer", que tambm serve para indicar o topo da pilha. Alternativamente, a memria do quadro pode ser acessada por outro registrador, o "ponteiro do quadro", que geralmente aponta para um ponto especfico do quadro, como o endereo de retorno. Cada quadro possui um tamanho especfico, determinado pelo nmero e tamanho de parmetros e variveis locais, ainda que o tamanho seja fixo para diferentes chamadas duma mesma sub-rotina. Entretanto, algumas linguagens suportam alocao dinmica de memria para variveis locais na Stack Pointer, de forma que o tamanho do quadro duma sub-

rotina no seja fixo, variando de acordo com a chamada. Com esse tipo de alocao dinmica, o tamanho do quadro no pode ser obtido em tempo de compilao. Portanto, o acesso ao quadro feito pelo ponteiro de quadro ao invs do Stack Pointer. Em alguns sistemas o quadro de pilha possui um campo que contm o valor anterior do registrador "ponteiro de quadro", isto , o valor desse registrador enquanto o quadro anterior estava em execuo. Por exemplo, no diagrama anterior, o quadro de DesenhaLinha teria uma rea de memria para o valor do ponteiro de quadro de DesenhaQuadrado. Isso permite que se acesse por cdigo os quadros abaixo do atual. Linguagens de programao que suportam sub-rotinas aninhadas possuem um campo no quadro que aponta para o quadro da sub-rotina que comeou o aninhamento. Isso permite que as subrotinas aninhadas acessem as variveis locais e os parmetros da sub-rotina que as invocou.
ESTOURO DE PILHA

Quanto a Stack Pointer usa mais memria do que suporta, ocorre um estouro de pilha. Em diversas linguagens de programao a Stack Pointer possui uma rea limitada de memria, geralmente determinada no incio do programa. O resultado do uso excessivo de memria o estouro, o que geralmente resulta na aborto do programa.[2] Uma das causas mais comuns desse bug arecursividade infinita, em que o ponto de parada da recursividade no ocorre antes do enchimento da pilha. Outra causa a tentativa de alocar mais memria na pilha do que ela suporta. Como variveis locais e parmetros so alocados na Stack Pointer, o uso excessivo de memria nesses casos pode levar ao estouro da pilha. Uma alternativa alocar a memria dinamicamente.[3] Como programas com suporte a threads geralmente possuem uma rea de pilha menor que programas sem suporte, o bug geralmente se manifesta mais nesses ambientes multitarefa. Da mesma forma, no desenvolvimento de ncleo desencorajado o uso de algoritmos recursivos ou de buffers muito grandes na Stack Pointer.[4][5]

Exemplos
Segue abaixo alguns exemplos em C: Recursividade infinita
void f(void); void g(void); int main(void) { f(); } void f(void) { g(); } void g(void) { f(); } f() invoca g(), que invoca f() e assim por diante. Em dado momento a Stack

Pointer estoura. Alocao excessiva de memria

int main(void) { int n[10000000]; /* vetor muito grande */ int j =

0; /* endereo de j excede o limite da pilha, erro */ }