b'\n_START_ARTICLE_\nPilha de chamada\n_START_PARAGRAPH_\nEm ci\xc3\xaancia da computa\xc3\xa7\xc3\xa3o, uma pilha de chamada (ou pilha de execu\xc3\xa7\xc3\xa3o) \xc3\xa9 uma pilha que armazena informa\xc3\xa7\xc3\xb5es sobre as sub-rotinas ativas num programa de computador. Seu principal uso \xc3\xa9 registrar o ponto em que cada sub-rotina ativa deve retornar o controle de execu\xc3\xa7\xc3\xa3o quando termina de executar._NEWLINE_Por exemplo, se uma sub-rotina DesenhaQuadrado chama (invoca) a sub-rotina DesenhaLinha em quatro pontos diferentes, o c\xc3\xb3digo de DesenhaLinha deve saber como retornar a DesenhaQuadrado. Isso geralmente \xc3\xa9 feito adicionando o endere\xc3\xa7o de retorno na pilha de chamada ap\xc3\xb3s a chamada da sub-rotina._NEWLINE_Sendo organizada como uma pilha, quem invoca a sub-rotina empilha o endere\xc3\xa7o de retorno. Quando termina sua execu\xc3\xa7\xc3\xa3o, a sub-rotina invocada desempilha o endere\xc3\xa7o de retorno, desviando a execu\xc3\xa7\xc3\xa3o para aquele endere\xc3\xa7o. Se durante sua execu\xc3\xa7\xc3\xa3o a sub-rotina invocada tamb\xc3\xa9m invocar outra sub-rotina, o endere\xc3\xa7o de retorno tamb\xc3\xa9m ser\xc3\xa1 empilhado, e assim por diante. Quando esse processo de empilhamento consome todo o espa\xc3\xa7o alocado para a pilha de chamada, ocorre um erro chamado estouro de pilha._NEWLINE_Existe um pilha de chamada para cada thread sendo executada, ainda que mais pilhas possam ser criadas para o tratamento de sinais ou para multitarefa cooperativa._NEWLINE_Em linguagens de alto n\xc3\xadvel, detalhes da pilha de chamada s\xc3\xa3o geralmente escondidos do programador. Eles t\xc3\xaam acesso somente a lista de sub-rotinas empilhadas, e n\xc3\xa3o \xc3\xa0 mem\xc3\xb3ria da pilha de chamada em si. Por outro lado, a maioria das linguagens de montagem requerem que programador manipule a pilha de chamada.\n_START_SECTION_\nAtribui\xc3\xa7\xc3\xb5es\n_START_PARAGRAPH_\nUma das principais atribui\xc3\xa7\xc3\xb5es duma pilha de chamada \xc3\xa9 armazenar o endere\xc3\xa7o de retorno. Quando uma sub-rotina \xc3\xa9 chamada, a localiza\xc3\xa7\xc3\xa3o da instru\xc3\xa7\xc3\xa3o a ser retornada deve ser salva. Usar uma pilha para salvar o endere\xc3\xa7o de retorno possui importantes vantagens. Uma delas \xc3\xa9 que cada tarefa possui sua pr\xc3\xb3pria pilha, o que permite reentr\xc3\xa2ncia. Outro benef\xc3\xadcio \xc3\xa9 o suporte autom\xc3\xa1tico a recursividade._NEWLINE_Outra atribui\xc3\xa7\xc3\xa3o \xc3\xa9 o armazenamento de vari\xc3\xa1veis locais. Uma sub-rotina frequentemente precisa de mem\xc3\xb3ria para armazenar vari\xc3\xa1veis locais, aquelas que s\xc3\xa3o usadas somente durante a execu\xc3\xa7\xc3\xa3o da sub-rotina. Geralmente aloca-se espa\xc3\xa7o na pr\xc3\xb3pria pilha de chamada para tal, o que \xc3\xa9 muito r\xc3\xa1pido comparado a aloca\xc3\xa7\xc3\xa3o din\xc3\xa2mica de mem\xc3\xb3ria. Tamb\xc3\xa9m relacionado a vari\xc3\xa1veis locais est\xc3\xa1 a passagem de par\xc3\xa2metros, mais uma atribui\xc3\xa7\xc3\xa3o. Uma sub-rotina frequentemente precisa ser alimentada por par\xc3\xa2metros quando \xc3\xa9 invocada, e \xc3\xa9 comum usar a pilha de chamada para tal. De forma geral, se h\xc3\xa1 poucos e pequenos par\xc3\xa2metros, registradores do processador s\xc3\xa3o usados para passar os par\xc3\xa2metros. Mas se h\xc3\xa1 muitos par\xc3\xa2metros, ou se eles ocupam muito espa\xc3\xa7o, a pilha de chamada \xc3\xa9 usada._NEWLINE_Operandos de opera\xc3\xa7\xc3\xb5es aritm\xc3\xa9ticas ou l\xc3\xb3gicas s\xc3\xa3o manipulados a partir de registradores, de onde s\xc3\xa3o calculados. Mas para casos espec\xc3\xadficos deve-se usar uma profundidade espec\xc3\xadfica de operandos, algo que somente registradores n\xc3\xa3o conseguem armazenar. A pilha de opera\xc3\xa7\xc3\xb5es aritm\xc3\xa9ticas e l\xc3\xb3gicas pode estar localizada na pilha de chamada._NEWLINE_Algumas linguagens orientadas a objeto armazenam o ponteiro this junto aos par\xc3\xa2metros dos m\xc3\xa9todos sendo invocados. Esse ponteiro indica a inst\xc3\xa2ncia associada ao m\xc3\xa9todo sendo invocado, sendo essencial para fornecer contexto a execu\xc3\xa7\xc3\xa3o. Tamb\xc3\xa9m relacionado a contexto, algumas linguagens de programa\xc3\xa7\xc3\xa3o suportam sub-rotinas aninhadas, permitindo que a rotina aninhada acesse o contexto externo, da rotina que a aninhou (par\xc3\xa2metros, vari\xc3\xa1veis locais). Tais linguagens geralmente aceitam a chamada recursiva da sub-rotina aninhada, sendo que todas as chamadas recursivas apontam para o mesmo contexto externo._NEWLINE_Al\xc3\xa9m do endere\xc3\xa7o de retorno, alguns ambientes podem suportar outros estados que s\xc3\xa3o restaurados no retorno duma sub-rotina, como n\xc3\xadveis de privil\xc3\xa9gio, informa\xc3\xa7\xc3\xa3o para o tratamento de exce\xc3\xa7\xc3\xb5es, entre outros.\n_START_SECTION_\nEstouro de pilha\n_START_PARAGRAPH_\nQuando a pilha de chamada usa mais mem\xc3\xb3ria do que suporta, ocorre um estouro de pilha. Em diversas linguagens de programa\xc3\xa7\xc3\xa3o a pilha de chamada possui uma \xc3\xa1rea limitada de mem\xc3\xb3ria, geralmente determinada no in\xc3\xadcio do programa. O resultado do uso excessivo de mem\xc3\xb3ria \xc3\xa9 o estouro, o que geralmente resulta na aborto do programa._NEWLINE_Uma das causas mais comuns desse bug \xc3\xa9 a recursividade infinita, em que o ponto de parada da recursividade n\xc3\xa3o ocorre antes do enchimento da pilha. Outra causa \xc3\xa9 a tentativa de alocar mais mem\xc3\xb3ria na pilha do que ela suporta. Como vari\xc3\xa1veis locais e par\xc3\xa2metros s\xc3\xa3o alocados na pilha de chamada, o uso excessivo de mem\xc3\xb3ria nesses casos pode levar ao estouro da pilha. Uma alternativa \xc3\xa9 alocar a mem\xc3\xb3ria dinamicamente._NEWLINE_Como programas com suporte a threads geralmente possuem uma \xc3\xa1rea de pilha menor que programas sem suporte, o bug geralmente se manifesta mais nesses ambientes multitarefa. Da mesma forma, no desenvolvimento de n\xc3\xbacleo \xc3\xa9 desencorajado o uso de algoritmos recursivos ou de buffers muito grandes na pilha de chamada.'