有没有办法在 GCC/Clang 中将变量设置为未初始化？

Question

我很想知道是否可以将 C 中的变量显式污染为未初始化。

伪代码...

{
    int *array;
    array = some_alloc();
    b = array[0];
    some_free(array);
    TAINT_MACRO(array);

    /* the compiler should raise an uninitialized warning here */
    b = array[0];
}

这是污染变量的一种方法的一个示例，但是当 'a' 被分配给未初始化的 var 时，GCC 会发出警告，而不是第二次使用 'a'。

{
    int a = 10;
    printf("first %d\n", a);
    do {
        int b;
        a = b;
    } while(0);
    printf("second %d\n", a);
}

我能想出的唯一解决方案是用未初始化的变量显式隐藏变量，（添加了空格，因此没有未使用的警告）。

#define TAINT_MACRO_BEGIN(array) (void)(array); { void **array; (void)array;
#define TAINT_MACRO_END(array) } (void)(array);
{
    int *array;
    array = some_alloc();
    b = array[0];
    some_free(array);
    TAINT_MACRO_BEGIN(array);

    /* the compiler should raise an uninitialized warning here */
    b = array[0];
    TAINT_MACRO_END(array);
}

这种方法增加了太多开销，无法包含在现有代码中（增加了很多噪音并且维护起来很烦人），所以我想知道是否有其他方法可以告诉编译器变量未初始化。

我知道有静态检查器并且我确实使用了这些，但是我正在寻找可以在编译时发出警告并且没有误报的东西，我相信在这种情况下这是可能的并且可以避免某些类别的错误。

Answer 1

我在 GCC 列表上发送了一个答案，但由于我自己先使用 SO...

在现代 C 和 C++ 中，我希望程序员使用有限的 可变范围来控制这种曝光。

例如，我认为您想要这样的东西（请注意 我正在使用的属性实际上并不存在，我只是想 解释你的要求）。

int x = 1; // initialized 
int y;     // uninitialized 

x = y;     // use of uninitialized value 'y' 

y = 2;     // no longer uninitialized 
x = y;     // fine 

y = ((__attr__ uninitialized))0; // tell gcc it's uninitialized again 

x = y;    // warn here please. 

如果是这样，我会在 C99（或更高版本）或 C++（漂亮 至少从 1993 年的 ARM 开始，它就已经“在使用点声明”了……）：

int x = 1; // initialized 

{ 
    int y; // uninitialized 
    x = y; // warn here 
    y = 2; // ok, now it's initialized 
    x = y; // fine, no warning 
} 

{ 
    int y; // uninitialized again! 
    x = y; // warns here 
} 

额外的范围有点令人反感，但我已经习惯了 C++（来自大量使用 RAII 技术。）

由于主流语言对此有答案，我不知道 认为值得添加到编译器中。

看看你的例子，你关心的是一个数组。那应该 与额外的范围一样工作，不应该有额外的 运行时成本，因为整个堆栈帧是在函数上分配的 条目（至少 SFAIK）。

Answer 2

Based on an answer to a different question，您可以使用setjmp 和longjmp 使更改的局部变量具有不确定的值。

#define TAINT(x)                             \
        do {                                 \
            static jmp_buf jb;               \
            if (setjmp(jb) == 0) {           \
                memset(&x, '\0', sizeof(x)); \
                longjmp(jb, 1);              \
            }                                \
        } while (0)

如果x 是一个局部变量，它的值在应用TAINT 之后的代码行中将是不确定的。这是因为 C.11 §7.13.2 ¶3（强调我的）：

所有可访问对象都有值，并且所有其他组件 抽象机有状态，截至longjmp 函数是 调用，除了自动存储对象的值 包含调用的函数的本地持续时间 对应的没有 volatile 限定的 setjmp 宏 类型并已在 setjmp 调用和 longjmp 之间更改 调用是不确定的。

请注意，使用受污染的变量不需要诊断。但是，编译器编写者正在积极检测未定义的行为以增强优化，所以如果这永远无法诊断出来，我会感到惊讶。

Answer 3

我会反过来，将污染宏包装在分配和释放函数周围。这就是我的想法：

#ifdef O_TAINT
volatile int taint_me;
#define TAINT(x, m) \
    if (taint_me) { goto taint_end_##x; } else {} x = m
#define free(x) free(x); taint_end_##x: (void)0
#else
#define TAINT(x, m) x = m
#endif

因此，您的示例将如下所示：

int *array;
int b;

TAINT(array, malloc(sizeof(int)));
b = array[0];
printf("%d\n", b);
free(array);

/* the compiler should raise an uninitialized warning here */
b = array[0];
printf("%d\n", b);

这并不完美。每个受污染的变量只能调用一次free()，因为goto 标签与变量名称相关联。如果跳转跳过其他初始化，您可能会得到其他误报。如果分配发生在一个函数中，而内存在另一个函数中释放，则它不起作用。

但是，它提供了您在示例中要求的行为。正常编译时，不会出现任何警告。如果使用-DO_TAINT 编译，则在第二次分配给b 时会出现警告。

---

我确实制定了一个相当通用的解决方案，但它涉及使用开始/结束宏将整个函数括起来，并且依赖于 GCC 扩展 typeof 运算符。解决方案最终看起来像这样：

void foo (int *array, char *buf)
{
    TAINT_BEGIN2(array, buf);
    int b;

    puts(buf);
    b = array[0];
    printf("%d\n", b);

    free(array);
    free(buf);

    /* the compiler should raise an uninitialized warning here */
    puts(buf);
    b = array[0];
    printf("%d\n", b);

    TAINT_END;
}

这里，TAINT_BEGIN2 用于声明将获得污点处理的两个函数参数。不幸的是，宏有点乱，但很容易扩展：

#ifdef O_TAINT
volatile int taint_me;
#define TAINT(x, m) \
    if (taint_me) { goto taint_end_##x; } else {} x = m
#define TAINT1(x) \
    if (taint_me) { goto taint_end_##x; } else {} x = x##_taint
#define TAINT_BEGIN(v1) \
    typeof(v1) v1##_taint = v1; do { \
    typeof(v1##_taint) v1; TAINT1(v1)
#define TAINT_BEGIN2(v1, ...) \
    typeof(v1) v1##_taint = v1; TAINT_BEGIN(__VA_ARGS__); \
    typeof(v1##_taint) v1; TAINT1(v1)
#define TAINT_BEGIN3(v1, ...) \
    typeof(v1) v1##_taint = v1; TAINT_BEGIN2(__VA_ARGS__); \
    typeof(v1##_taint) v1; TAINT1(v1)
#define TAINT_END } while(0)
#define free(x) free(x); taint_end_##x: (void)0
#else
#define TAINT_BEGIN(x) (void)0
#define TAINT_BEGIN2(...) (void)0
#define TAINT_BEGIN3(...) (void)0
#define TAINT_END (void)0
#define TAINT1(x) (void)0
#define TAINT(x, m) x = m
#endif