Partilhar via

Erro: stack-use-after-return

Erro AddressSanitizer: Uso de memória de pilha após o retorno

Observações

Essa verificação requer a geração de código que é ativada por uma opção de compilador extra, /fsanitize-address-use-after-returne definindo a variável ASAN_OPTIONS=detect_stack_use_after_return=1de ambiente .

Esta verificação pode atrasar substancialmente a sua aplicação. Considere o resumo Clang do algoritmo que suporta o uso após o retorno e os maiores custos de desempenho.

Importante

Se você criar um arquivo de objeto usando a opção /fsanitize-address-use-after-returnde compilador extra, o código gerado pelo compilador tomará uma decisão de tempo de execução sobre como alocar um quadro de pilha. Se a variável ASAN_OPTIONS de ambiente não estiver definida como detect_stack_use_after_return, o código ainda será mais lento do que usar /fsanitize=address por si só. É mais lento porque ainda há sobrecarga adicional de alguns quadros de pilha que alocam espaço para partes de um quadro usando alloca()o . É melhor excluir esses arquivos de objeto quando terminar de processar erros de uso após retorno.

Exemplo - C simples

// example1.cpp
// stack-use-after-return error
volatile char* x;

void foo() {
    char stack_buffer[42];
    x = &stack_buffer[13];
}

int main() {

    foo();
    *x = 42; // Boom!

    return (*x == 42);
}

Para criar e testar este exemplo, execute estes comandos em um prompt de comando do desenvolvedor do Visual Studio 2019 versão 16.9 ou posterior:

cl example1.cpp /fsanitize=address /fsanitize-address-use-after-return /Zi
set ASAN_OPTIONS=detect_stack_use_after_return=1
devenv /debugexe example1.exe

Erro resultante - C simples

Captura de tela do depurador exibindo erro stack-use-after-return no exemplo 1.

Exemplo - C++ e modelos

// example2.cpp
// stack-use-after-return error
#include <stdlib.h>

enum ReadOrWrite { Read = 0, Write = 1 };

struct S32 {
    char x[32];
};

template<class T>
T* LeakStack() {
    T t[100];
    static volatile T* x;
    x = &t[0];
    return (T*)x;
}

template<class T>
void StackUseAfterReturn(int Idx, ReadOrWrite w) {
    static T sink;
    T* t = LeakStack<T>();
    if (w)
        t[100 + Idx] = T();
    else
        sink = t[100 + Idx];
}

int main(int argc, char* argv[]) {

    if (argc != 2) return 1;
    int kind = atoi(argv[1]);

    switch (kind) {
    case 1: StackUseAfterReturn<char>(0, Read); break;
    case 2: StackUseAfterReturn<S32>(0, Write); break;
    }
    return 0;
}

Para criar e testar este exemplo, execute estes comandos em um prompt de comando do desenvolvedor do Visual Studio 2019 versão 16.9 ou posterior:

cl example2.cpp /fsanitize=address /fsanitize-address-use-after-return /Zi /Od
set ASAN_OPTIONS=detect_stack_use_after_return=1
devenv /debugexe example2.exe 1

ASAN é uma forma de análise dinâmica, o que significa que só pode detetar código incorreto que é realmente executado. Um otimizador pode determinar que o valor de t[100 + Idx] ou sink nunca é usado e elidir a atribuição. Como resultado, este exemplo requer o /Od sinalizador.

Erro resultante - C++ e modelos

Captura de tela do depurador exibindo o erro stack-use-after-return no exemplo 2.

Ver também

Visão geral do AddressSanitizer
AddressSanitizer problemas conhecidos
de compilação e referência de linguagem AddressSanitizer
de referência de tempo de execução AddressSanitizer
AddressSanitizer shadow bytes
AddressSanitizer na nuvem ou de testes distribuídos
de integração do depurador AddressSanitizer
Exemplos de erro AddressSanitizer

  • Last updated on