Por que o uso de alloca () não é considerado uma boa prática?

alloca()aloca memória na pilha e não na pilha, como no caso de malloc(). Então, quando eu volto da rotina, a memória é liberada. Então, na verdade, isso resolve meu problema de liberar memória alocada dinamicamente. A liberação de memória alocada malloc()é uma grande dor de cabeça e, se perdida de alguma forma, leva a todos os tipos de problemas de memória.

Por que o uso de alloca()desencorajado apesar dos recursos acima?

A resposta está aí na manpágina (pelo menos no Linux ):

VALOR DE RETORNO A função alloca () retorna um ponteiro para o início do espaço alocado. Se a alocação causar estouro de pilha, o comportamento do programa será indefinido.

O que não quer dizer que nunca deva ser usado. Um dos projetos de OSS em que trabalho o usa extensivamente e, desde que você não esteja abusando (com allocavalores enormes), tudo bem. Depois de ultrapassar a marca "algumas centenas de bytes", é hora de usar os mallocamigos. Você ainda pode ter falhas de alocação, mas pelo menos terá alguma indicação da falha, em vez de apenas estourar a pilha.

Um dos bugs mais memoráveis ​​que tive foi o uso de uma função inline usada alloca. Ele se manifestou como um estouro de pilha (porque é alocado na pilha) em pontos aleatórios da execução do programa.

No arquivo de cabeçalho:

void DoSomething() {
   wchar_t* pStr = alloca(100);
   //......
}

No arquivo de implementação:

void Process() {
   for (i = 0; i < 1000000; i++) {
     DoSomething();
   }
}

Então, o que aconteceu foi a DoSomethingfunção incorporada do compilador e todas as alocações de pilha estavam acontecendo dentro da Process()função e, assim, explodindo a pilha. Em minha defesa (e não fui eu quem encontrou o problema; tive que chorar para um dos desenvolvedores seniores quando não consegui consertá-lo), não foi direto alloca, foi um dos conversores de string ATL macros.

Portanto, a lição é - não use allocaem funções que você acha que podem estar embutidas.

Pergunta antiga, mas ninguém mencionou que deveria ser substituída por matrizes de comprimento variável.

char arr[size];

ao invés de

char *arr=alloca(size);

Está no padrão C99 e existia como extensão de compilador em muitos compiladores.

alloca () é muito útil se você não puder usar uma variável local padrão porque seu tamanho precisaria ser determinado em tempo de execução e você pode garantir absolutamente que o ponteiro obtido de alloca () NUNCA será usado após o retorno dessa função .

Você pode estar razoavelmente seguro se você

• não retorne o ponteiro ou qualquer coisa que o contenha.
• não armazene o ponteiro em nenhuma estrutura alocada no heap
• não deixe nenhum outro thread usar o ponteiro

O perigo real vem da chance de alguém violar essas condições algum tempo depois. Com isso em mente, é ótimo para passar buffers para funções que formatam texto neles :)

Conforme observado nesta postagem do grupo de notícias , existem alguns motivos pelos quais o uso allocapode ser considerado difícil e perigoso:

• Nem todos os compiladores suportam alloca.
• Alguns compiladores interpretam o comportamento pretendido de maneira allocadiferente, portanto, a portabilidade não é garantida, mesmo entre os compiladores que o suportam.
• Algumas implementações são com erros.

Uma questão é que não é padrão, embora seja amplamente suportado. Sendo outras coisas iguais, eu sempre usaria uma função padrão em vez de uma extensão comum do compilador.

Ainda assim, o uso de cocaína é desencorajado, por quê?

Não percebo tal consenso. Muitos profissionais fortes; alguns contras:

• O C99 fornece matrizes de comprimento variável, que costumam ser usadas preferencialmente, pois a notação é mais consistente com matrizes de comprimento fixo e intuitiva em geral.
• muitos sistemas têm menos espaço de memória / endereço geral disponível para a pilha do que para a pilha, o que torna o programa um pouco mais suscetível à exaustão de memória (devido ao estouro de pilha): isso pode ser visto como algo bom ou ruim - um Uma das razões pelas quais a pilha não cresce automaticamente da mesma forma que a pilha é para impedir que programas fora de controle tenham tanto impacto adverso em toda a máquina
• quando usada em um escopo mais local (como a whileou forloop) ou em vários escopos, a memória se acumula por iteração / escopo e não é liberada até que a função saia: isso contrasta com as variáveis ​​normais definidas no escopo de uma estrutura de controle (por exemplo, for {int i = 0; i < 2; ++i) { X }acumularia a allocamemória solicitada no X, mas a memória para uma matriz de tamanho fixo seria reciclada por iteração).
• compiladores modernos normalmente não inlinefuncionam com a chamada alloca, mas se você forçá-los, allocaisso acontecerá no contexto dos chamadores (ou seja, a pilha não será liberada até que o chamador retorne)
• há muito tempo, allocamigrou de um recurso / hack não portátil para uma extensão padronizada, mas alguma percepção negativa pode persistir
• o tempo de vida está vinculado ao escopo da função, que pode ou não se adequar melhor ao programador do que malloco controle explícito
• o uso mallocincentiva o pensamento sobre a desalocação - se isso é gerenciado por meio de uma função de wrapper (por exemplo WonderfulObject_DestructorFree(ptr)), a função fornece um ponto para a implementação de operações de limpeza (como fechar descritores de arquivo, liberar ponteiros internos ou fazer log) sem alterações explícitas no cliente código: às vezes é um bom modelo para adotar de forma consistente
  • nesse estilo de programação pseudo-OO, é natural querer algo como WonderfulObject* p = WonderfulObject_AllocConstructor();- isso é possível quando o "construtor" é uma função que retorna mallocmemória (como a memória permanece alocada após a função retornar o valor a ser armazenado p), mas não se o "construtor" usaralloca
    • uma versão macro WonderfulObject_AllocConstructorpoderia conseguir isso, mas "as macros são más", pois podem entrar em conflito entre si e com o código não macro e criar substituições não intencionais e consequentes problemas difíceis de diagnosticar
  • as freeoperações ausentes podem ser detectadas pelo ValGrind, Purify etc., mas as chamadas "destruidoras" ausentes nem sempre podem ser detectadas - um benefício muito tênue em termos de aplicação do uso pretendido; algumas alloca()implementações (como as GCCs) usam uma macro embutida para alloca(), portanto, a substituição em tempo de execução de uma biblioteca de diagnóstico de uso de memória não é possível do jeito que é para malloc/ realloc/ free(por exemplo, cerca elétrica)
• algumas implementações têm problemas sutis: por exemplo, na página de manual do Linux:

  Em muitos sistemas, o alloca () não pode ser usado na lista de argumentos de uma chamada de função, porque o espaço da pilha reservado por alloca () apareceria na pilha no meio do espaço para os argumentos da função.

Eu sei que essa pergunta está marcada como C, mas como programador de C ++, pensei em usar o C ++ para ilustrar a utilidade potencial de alloca: o código abaixo (e aqui na ideone ) cria um vetor que rastreia tipos polimórficos de tamanhos diferentes e com alocação de pilha (com tempo de vida vinculado ao retorno da função) em vez do heap alocado.

#include <alloca.h>
#include <iostream>
#include <vector>

struct Base
{
    virtual ~Base() { }
    virtual int to_int() const = 0;
};

struct Integer : Base
{
    Integer(int n) : n_(n) { }
    int to_int() const { return n_; }
    int n_;
};

struct Double : Base
{
    Double(double n) : n_(n) { }
    int to_int() const { return -n_; }
    double n_;
};

inline Base* factory(double d) __attribute__((always_inline));

inline Base* factory(double d)
{
    if ((double)(int)d != d)
        return new (alloca(sizeof(Double))) Double(d);
    else
        return new (alloca(sizeof(Integer))) Integer(d);
}

int main()
{
    std::vector<Base*> numbers;
    numbers.push_back(factory(29.3));
    numbers.push_back(factory(29));
    numbers.push_back(factory(7.1));
    numbers.push_back(factory(2));
    numbers.push_back(factory(231.0));
    for (std::vector<Base*>::const_iterator i = numbers.begin();
         i != numbers.end(); ++i)
    {
        std::cout << *i << ' ' << (*i)->to_int() << '\n';
        (*i)->~Base();   // optionally / else Undefined Behaviour iff the
                         // program depends on side effects of destructor
    }
}

Todas as outras respostas estão corretas. No entanto, se o que você deseja alocar alloca()é razoavelmente pequeno, acho que é uma boa técnica mais rápida e conveniente do que usar malloc()ou não.

Em outras palavras, alloca( 0x00ffffff )é perigoso e provavelmente causa estouro, exatamente o que char hugeArray[ 0x00ffffff ];é. Seja cauteloso e razoável e você ficará bem.

Muitas respostas interessantes para essa pergunta "antiga", até algumas respostas relativamente novas, mas não encontrei nenhuma que mencionasse isso ...

Quando usado de maneira adequada e cuidadosa, o uso consistente alloca() (talvez em todo o aplicativo) para lidar com pequenas alocações de tamanho variável (ou C99 VLAs, quando disponíveis) pode levar a um crescimento geral menor da pilha do que uma implementação equivalente usando matrizes locais de tamanho fixo de tamanho fixo . Portanto, alloca()pode ser bom para sua pilha se você a usar com cuidado.

Encontrei essa citação em ... OK, fiz essa citação. Mas realmente, pense nisso ....

@j_random_hacker está muito certo em seus comentários sob outras respostas: Evitar o uso de a alloca()favor de matrizes locais superdimensionadas não torna seu programa mais seguro contra estouros de pilha (a menos que seu compilador tenha idade suficiente para permitir a inclusão de funções usadas alloca()nesse caso, você deve atualização, ou a menos que você use alloca()loops internos; nesse caso, você não deve ... usar alloca()loops internos).

Trabalhei em ambientes de desktop / servidor e sistemas embarcados. Muitos sistemas embarcados nem sequer usam um heap (eles nem se vinculam no suporte a ele), por motivos que incluem a percepção de que a memória alocada dinamicamente é ruim devido aos riscos de vazamento de memória em um aplicativo que nunca sempre reinicia por anos, ou a justificativa mais razoável de que a memória dinâmica é perigosa porque não se pode ter certeza de que um aplicativo nunca fragmentará sua pilha ao ponto de falsa exaustão de memória. Portanto, os programadores incorporados ficam com poucas alternativas.

alloca() (ou VLAs) pode ser a ferramenta certa para o trabalho.

Eu vi várias vezes em que um programador cria um buffer alocado para a pilha "grande o suficiente para lidar com qualquer caso possível". Em uma árvore de chamada profundamente aninhada, o uso repetido desse padrão (anti -?) Leva ao uso exagerado da pilha. (Imagine uma árvore de chamadas com 20 níveis de profundidade, onde, em cada nível, por diferentes razões, a função superaloca cegamente um buffer de 1024 bytes "apenas por segurança", quando geralmente usa apenas 16 ou menos deles, e apenas em casos raros podem usar mais.) Uma alternativa é usaralloca()ou VLAs e aloque apenas o espaço de pilha necessário para sua função, para evitar sobrecarregar desnecessariamente a pilha. Felizmente, quando uma função na árvore de chamadas precisa de uma alocação maior que o normal, outras ainda estão usando suas alocações pequenas normais e o uso geral da pilha de aplicativos é significativamente menor do que se todas as funções superalocassem cegamente um buffer local .

Mas se você optar por usar alloca()...

Com base em outras respostas nesta página, parece que os VLAs devem ser seguros (eles não compõem alocações de pilha se chamados de dentro de um loop), mas se você estiver usando alloca(), tenha cuidado para não usá-lo dentro de um loop e faça verifique se sua função não pode ser incorporada se houver alguma chance de ser chamada no loop de outra função.

Todo mundo já apontou a grande coisa que é o comportamento indefinido potencial de um estouro de pilha, mas devo mencionar que o ambiente Windows possui um ótimo mecanismo para capturar isso usando exceções estruturadas (SEH) e páginas de proteção. Como a pilha cresce apenas conforme necessário, essas páginas de proteção residem em áreas não alocadas. Se você alocá-los (excedendo a pilha), uma exceção será lançada.

Você pode capturar essa exceção SEH e chamar _resetstkoflw para redefinir a pilha e continuar no seu caminho alegre. Não é o ideal, mas é outro mecanismo para pelo menos saber que algo deu errado quando o material atinge o ventilador. * Nix pode ter algo semelhante que eu não conheço.

Eu recomendo limitar seu tamanho máximo de alocação, envolvendo alloca e rastreando-o internamente. Se você fosse realmente sincero, jogaria algumas sentinelas de escopo na parte superior da sua função para rastrear alocações de aloca no escopo e na sanidade da função e verifique isso com o valor máximo permitido para o seu projeto.

Além disso, além de não permitir vazamentos de memória, o alloca não causa fragmentação de memória, o que é muito importante. Não acho que alloca seja uma má prática se você a usar de maneira inteligente, o que é basicamente verdadeiro para tudo. :-)

alloca () é agradável e eficiente ... mas também está profundamente quebrado.

• comportamento do escopo quebrado (escopo da função em vez do escopo do bloco)
• use inconsistente com malloc (o ponteiro com aloca () não deve ser liberado; daí em diante você deve rastrear de onde os ponteiros estão vindo para liberar () somente aqueles que você obteve com malloc () )
• mau comportamento quando você também usa inlining (o escopo às vezes vai para a função de chamada, dependendo se o receptor está embutido ou não).
• sem verificação do limite da pilha
• comportamento indefinido em caso de falha (não retorna NULL como malloc ... e o que significa falha porque não verifica os limites da pilha de qualquer maneira ...)
• não padrão ansi

Na maioria dos casos, você pode substituí-lo usando variáveis ​​locais e tamanho majorante. Se for usado para objetos grandes, colocá-los na pilha geralmente é uma idéia mais segura.

Se você realmente precisa do C, pode usar o VLA (sem vla em C ++, muito ruim). Eles são muito melhores que alloca () em relação ao comportamento e consistência do escopo. A meu ver, o VLA é uma espécie de alloca () corrigida .

É claro que uma estrutura ou matriz local usando um majorante do espaço necessário ainda é melhor, e se você não tiver essa alocação de heap majorante usando malloc () simples, provavelmente é sensato. Não vejo nenhum caso de uso sensato em que você realmente precise de alloca () ou VLA.

Aqui está o porquê:

char x;
char *y=malloc(1);
char *z=alloca(&x-y);
*z = 1;

Não que alguém escreva esse código, mas o argumento de tamanho para o qual você está passando allocaquase certamente vem de algum tipo de entrada, que poderia ter como objetivo malicioso levar seu programa a allocaalgo enorme como esse. Afinal, se o tamanho não é baseado na entrada ou não tem a possibilidade de ser grande, por que você simplesmente não declarou um buffer local pequeno e de tamanho fixo?

Praticamente todo o código que usa allocae / ou o C99 vlas possui bugs sérios que levarão a falhas (se você tiver sorte) ou comprometimento de privilégios (se você não tiver tanta sorte).

Não acho que alguém tenha mencionado isso: o uso de alloca em uma função dificultará ou desabilitará algumas otimizações que poderiam ser aplicadas na função, pois o compilador não pode saber o tamanho do quadro de pilha da função.

Por exemplo, uma otimização comum dos compiladores C é eliminar o uso do ponteiro de quadro dentro de uma função; acessos ao quadro são feitos em relação ao ponteiro da pilha; então há mais um registro para uso geral. Mas se alloca for chamado dentro da função, a diferença entre sp e fp será desconhecida para parte da função, portanto, essa otimização não pode ser feita.

Dada a raridade de seu uso e seu status obscuro como uma função padrão, os projetistas de compiladores possivelmente desativam qualquer otimização que possa causar problemas com o alloca, se for necessário mais do que um pequeno esforço para fazê-lo funcionar com o alloca.

ATUALIZAÇÃO: Como matrizes locais de tamanho variável foram adicionadas a C e, como apresentam aloca problemas de geração de código muito semelhantes aos do alloca, vejo que 'raridade de uso e status obscuro' não se aplica ao mecanismo subjacente; mas eu ainda suspeitaria que o uso de alloca ou VLA tende a comprometer a geração de código dentro de uma função que os use. Gostaria de receber qualquer feedback dos designers do compilador.

Uma armadilha allocaé que a longjmprebobina.

Ou seja, se você salvar um contexto com setjmp, em seguida, allocaum pouco de memória, em seguida, longjmppara o contexto, você pode perder a allocamemória. O ponteiro da pilha está de volta onde estava e, portanto, a memória não é mais reservada; se você chamar uma função ou executar outra alloca, você derrotará o original alloca.

Para esclarecer, o que estou me referindo especificamente aqui é uma situação em longjmpque não retorna da função em que allocaocorreu! Em vez disso, uma função salva o contexto com setjmp; então aloca memória com allocae, finalmente, um longjmp ocorre nesse contexto. A allocamemória dessa função não é toda liberada; apenas toda a memória que alocou desde o setjmp. Claro, estou falando de um comportamento observado; nenhum requisito desse tipo está documentado sobre algum allocaque eu conheça.

O foco na documentação geralmente está no conceito de que a allocamemória está associada a uma ativação de função , não a qualquer bloco; que várias invocações allocasimplesmente capturam mais memória da pilha, que é liberada quando a função termina. Não tão; a memória está realmente associada ao contexto do procedimento. Quando o contexto é restaurado com longjmp, o mesmo ocorre com o allocaestado anterior . É uma conseqüência do próprio registro de ponteiro de pilha ser usado para alocação e também (necessariamente) salvo e restaurado no arquivo jmp_buf.

Aliás, isso, se funcionar dessa maneira, fornece um mecanismo plausível para deliberadamente liberar memória que foi alocada com alloca.

Eu corri para isso como a causa raiz de um bug.

Um local onde alloca()é especialmente perigoso do que malloc()o kernel - o kernel de um sistema operacional típico possui um espaço de pilha de tamanho fixo codificado em um de seus cabeçalhos; não é tão flexível quanto a pilha de um aplicativo. Fazer uma chamada para alloca()um tamanho não autorizado pode causar uma falha no kernel. Certos compiladores avisam o uso alloca()(e até mesmo de VLAs) sob certas opções que devem ser ativadas durante a compilação de um código do kernel - aqui, é melhor alocar memória no heap que não é corrigido por um limite codificado.

Se você acidentalmente gravar além do bloco alocado com alloca(devido a um estouro de buffer, por exemplo), substituirá o endereço de retorno da sua função, porque esse está localizado "acima" na pilha, ou seja, após o bloco alocado.

A consequência disso é dupla:

1. O programa falhará espetacularmente e será impossível dizer por que ou onde ele falhou (a pilha provavelmente se descontrairá em um endereço aleatório devido ao ponteiro do quadro substituído).

2. Isso torna o buffer overflow muitas vezes mais perigoso, pois um usuário mal-intencionado pode criar uma carga útil especial que seria colocada na pilha e, portanto, acabaria sendo executada.

Por outro lado, se você escrever além de um bloco na pilha, "apenas" terá corrupção na pilha. O programa provavelmente será encerrado inesperadamente, mas irá desenrolar a pilha corretamente, reduzindo assim a chance de execução de código malicioso.

Infelizmente, o verdadeiramente impressionante alloca()está faltando no tcc quase incrível. Gcc tem alloca().

1. Semeia a semente de sua própria destruição. Com retorno como destruidor.

2. Como se malloc()ele retornasse um ponteiro inválido em caso de falha, que irá falhar nos sistemas modernos com uma MMU (e esperamos reiniciar aqueles sem).

3. Diferente das variáveis ​​automáticas, você pode especificar o tamanho no tempo de execução.

Funciona bem com recursão. Você pode usar variáveis ​​estáticas para obter algo semelhante à recursão de cauda e usar apenas algumas outras informações de passagem para cada iteração.

Se você for muito fundo, terá a garantia de um segfault (se você tiver uma MMU).

Observe que ele malloc()não oferece mais, pois retorna NULL (que também será segfault se atribuído) quando o sistema estiver sem memória. Ou seja, tudo o que você pode fazer é pagar a fiança ou apenas tentar atribuí-lo de qualquer maneira.

Para usar malloc(), uso globals e atribuo a eles NULL. Se o ponteiro não for NULL, libero-o antes de usá-lo malloc().

Você também pode usar realloc()como caso geral se desejar copiar dados existentes. Você precisa verificar o ponteiro antes para descobrir se deseja copiar ou concatenar após o realloc().

3.2.5.2 Vantagens da alloca

Os processos têm apenas uma quantidade limitada de espaço na pilha disponível - muito menos do que a quantidade de memória disponível malloc().

Ao usá- alloca()lo, você aumenta drasticamente suas chances de obter um erro de Estouro de pilha (se tiver sorte ou uma falha inexplicável, se não tiver).

Não é muito bonito, mas se o desempenho realmente importa, você pode pré-alocar algum espaço na pilha.

Se você já tem o tamanho máximo da memória bloqueado e precisa manter verificações de excesso, faça algo como:

void f()
{
    char array_on_stack[ MAX_BYTES_TO_ALLOCATE ];
    SomeType *p = (SomeType *)array;

    (...)
}

A função alloca é ótima e todos os opositores estão simplesmente espalhando FUD.

void foo()
{
    int x = 50000; 
    char array[x];
    char *parray = (char *)alloca(x);
}

Matriz e parray são EXATAMENTE iguais, com EXATAMENTE os mesmos riscos. Dizer que um é melhor que o outro é uma escolha sintática, não técnica.

Quanto à escolha de variáveis ​​de pilha versus variáveis ​​de heap, há muitas vantagens em programas de longa execução usando pilha sobre heap para variáveis ​​com vida útil no escopo. Você evita a fragmentação de heap e pode aumentar o espaço do processo com espaço de heap não utilizado (inutilizável). Você não precisa limpá-lo. Você pode controlar a alocação de pilha no processo.

Por que isso é ruim?

Na verdade, não é garantido que o alloca use a pilha. De fato, a implementação do alloca do gcc-2.95 aloca memória do heap usando o próprio malloc. Além disso, essa implementação é incorreta, pode levar a um vazamento de memória e a um comportamento inesperado se você a chamar dentro de um bloco com um uso adicional de goto. Não, para dizer que você nunca deve usá-lo, mas algumas vezes alloca leva a mais sobrecarga do que libera.

IMHO, alloca é considerado uma má prática, porque todo mundo tem medo de esgotar o limite de tamanho da pilha.

Eu aprendi muito lendo este tópico e alguns outros links:

• /unix/63742/what-is-automatic-stack-expansion
• Limite de alocação de pilha para programas em uma máquina Linux de 32 bits
• ulimit -s

Eu uso o alloca principalmente para tornar meus arquivos C simples compiláveis ​​no msvc e gcc sem nenhuma alteração, estilo C89, sem #ifdef _MSC_VER, etc.

Obrigado ! Este tópico me fez inscrever neste site :)

Na minha opinião, alloca (), quando disponível, deve ser usado apenas de maneira restrita. Muito parecido com o uso de "goto", um grande número de pessoas razoáveis ​​tem forte aversão não apenas ao uso de, mas também à existência de alloca ().

Para uso incorporado, onde o tamanho da pilha é conhecido e os limites podem ser impostos por convenção e análise sobre o tamanho da alocação e onde o compilador não pode ser atualizado para oferecer suporte ao C99 +, o uso de alloca () é bom, e eu estive conhecido por usá-lo.

Quando disponíveis, os VLAs podem ter algumas vantagens sobre alloca (): O compilador pode gerar verificações de limite de pilha que obterão acesso fora dos limites quando o acesso ao estilo de matriz for usado (não sei se algum compilador faz isso, mas pode ser feita) e a análise do código pode determinar se as expressões de acesso à matriz estão adequadamente delimitadas. Observe que, em alguns ambientes de programação, como automotivo, equipamentos médicos e aviônicos, essa análise deve ser feita mesmo para matrizes de tamanho fixo, tanto automáticas (na pilha) quanto alocação estática (global ou local).

Em arquiteturas que armazenam dados e retornam endereços / ponteiros de quadro na pilha (pelo que sei, são todos eles), qualquer variável alocada à pilha pode ser perigosa porque o endereço da variável pode ser obtido e valores de entrada não verificados podem permitir todos os tipos de travessuras.

A portabilidade é menos preocupante no espaço incorporado, no entanto, é um bom argumento contra o uso de alloca () fora de circunstâncias cuidadosamente controladas.

Fora do espaço incorporado, usei alloca () principalmente dentro das funções de registro e formatação para obter eficiência, e em um scanner lexical não recursivo, em que estruturas temporárias (alocadas usando alloca () são criadas durante a tokenização e a classificação e, em seguida, um persistente O objeto (alocado via malloc ()) é preenchido antes do retorno da função.O uso de alloca () para estruturas temporárias menores reduz bastante a fragmentação quando o objeto persistente é alocado.

A maioria das respostas aqui em grande parte esquece o ponto: há uma razão pela qual o uso _alloca()é potencialmente pior do que simplesmente armazenar objetos grandes na pilha.

A principal diferença entre o armazenamento automático e _alloca()o fato de este sofrer um problema adicional (sério): o bloco alocado não é controlado pelo compilador ; portanto, não há como otimizar ou reciclar o compilador.

Comparar:

while (condition) {
    char buffer[0x100]; // Chill.
    /* ... */
}

com:

while (condition) {
    char* buffer = _alloca(0x100); // Bad!
    /* ... */
}

O problema com o último deve ser óbvio.

Eu não acho que alguém tenha mencionado isso, mas a alloca também tem alguns problemas sérios de segurança que não estão necessariamente presentes no malloc (embora esses problemas também surjam com qualquer matriz baseada em pilha, dinâmica ou não). Como a memória está alocada na pilha, os estouros / estouros de buffer têm consequências muito mais sérias do que apenas com malloc.

Em particular, o endereço de retorno para uma função é armazenado na pilha. Se esse valor for corrompido, seu código poderá ser criado para ir para qualquer região executável da memória. Os compiladores fazem um grande esforço para dificultar isso (em particular ao aleatorizar o layout do endereço). No entanto, isso é claramente pior do que apenas um estouro de pilha, pois o melhor caso é um SEGFAULT se o valor de retorno estiver corrompido, mas também pode começar a executar uma parte aleatória da memória ou, no pior caso, alguma região da memória que comprometa a segurança do programa. .