为什么即使有“if”语句，我的程序也不检查位域成员的值？

Question

我编写了这个程序作为 C++ 中位域成员比较行为的测试用例（我想同样的行为也会在 C 中表现出来）：

#include <cstdint>
#include <cstdio>

union Foo
{
    int8_t bar;
    struct
    {
#if __BYTE_ORDER == __LITTLE_ENDIAN
        int8_t baz : 1;
        int8_t quux : 7;
#elif __BYTE_ORDER == __BIG_ENDIAN
        int8_t quux : 7;
        int8_t baz : 1;
#endif
    };
};

int main()
{
    Foo foo;
    scanf("%d", &foo.bar);
    if (foo.baz == 1)
        printf("foo.baz == 1\n");
    else
        printf("foo.baz != 1\n");
}

在我将其1作为输入编译并运行后，我得到以下输出：

foo.baz != 1
*** stack smashing detected ***: terminated
fish: “./a.out” terminated by signal SIGABRT (Abort)

人们会期望foo.baz == 1检查将被评估为真，因为baz它始终是匿名位字段中的最低有效位。然而，从程序输出中可以看出，似乎发生了相反的情况（令人欣慰的是，每个程序调用始终相同）。

对我来说更奇怪的是，为程序生成的 AMD64 汇编代码（使用 GCC 10.2 编译器）甚至不包含单个比较或跳转指令！

.LC0:
        .string "%d"
.LC1:
        .string "foo.baz != 1"
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rsi, rax
        mov     edi, OFFSET FLAT:.LC0
        mov     eax, 0
        call    scanf
        mov     edi, OFFSET FLAT:.LC1
        call    puts
        mov     eax, 0
        leave
        ret

似乎if语句的 C++ 代码以某种方式得到了优化（或类似的东西），即使我使用默认设置编译了程序（即我没有打开任何级别的优化或类似的东西）。

有趣的是，锵10.0.1（当没有优化运行）似乎生成的代码与一个cmp指令（还有一个jne和jmp一个）：

main:                                   # @main
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     dword ptr [rbp - 4], 0
        lea     rax, [rbp - 8]
        movabs  rdi, offset .L.str
        mov     rsi, rax
        mov     al, 0
        call    scanf
        mov     cl, byte ptr [rbp - 8]
        shl     cl, 7
        sar     cl, 7
        movsx   edx, cl
        cmp     edx, 1
        jne     .LBB0_2
        movabs  rdi, offset .L.str.1
        mov     al, 0
        call    printf
        jmp     .LBB0_3
.LBB0_2:
        movabs  rdi, offset .L.str.2
        mov     al, 0
        call    printf
.LBB0_3:
        mov     eax, dword ptr [rbp - 4]
        add     rsp, 16
        pop     rbp
        ret
.L.str:
        .asciz  "%d"

.L.str.1:
        .asciz  "foo.baz == 1\n"

.L.str.2:
        .asciz  "foo.baz != 1\n"

这两个printf字符串似乎也存在于数据段中（与 GCC 情况下只有第二个字符串存在不同）。我不能确定（因为我不太精通汇编）但这似乎是正确生成的代码（与 GCC 生成的代码不同）。

但是，一旦我尝试-O1使用 Clang进行任何类型的优化（甚至）编译，比较/跳转就消失了（以及foo.baz == 1字符串），并且生成的代码似乎与 GCC 生成的代码非常相似：

（与-O1）

main:                                   # @main
        push    rax
        mov     rsi, rsp
        mov     edi, offset .L.str
        xor     eax, eax
        call    scanf
        mov     edi, offset .Lstr
        call    puts
        xor     eax, eax
        pop     rcx
        ret
.L.str:
        .asciz  "%d"

.Lstr:
        .asciz  "foo.baz != 1"

（您可能需要使用编译器资源管理器自行检查不同编译器版本生成的汇编代码。）

我对这种不直观的行为感到非常困惑。唯一想到的解释是包含有符号整数类型和联合的位域的一些奇怪的未定义行为的相互作用。让我这么想的是，在我用它们的无符号对应物替换有符号整数类型之后，程序的输出变得完全符合人们的预期（1作为输入）：

foo.baz == 1
*** stack smashing detected ***: terminated
fish: “./a.out” terminated by signal SIGABRT (Abort)

自然地，由于堆栈粉碎（就像以前一样）导致程序崩溃是不应该发生的，这导致了我的第二个问题：为什么会发生这种情况？

这是修改后的程序：

#include <cstdint>
#include <cstdio>

union Foo
{
    uint8_t bar;
    struct
    {
#if __BYTE_ORDER == __LITTLE_ENDIAN
        uint8_t baz : 1;
        uint8_t quux : 7;
#elif __BYTE_ORDER == __BIG_ENDIAN
        uint8_t quux : 7;
        uint8_t baz : 1;
#endif
    };
};

int main()
{
    Foo foo;
    scanf("%d", &foo.bar);
    if (foo.baz == 1)
        printf("foo.baz == 1\n");
    else
        printf("foo.baz != 1\n");
}

...以及 GCC 生成的汇编代码：

.LC0:
        .string "%d"
.LC1:
        .string "foo.baz == 1"
.LC2:
        .string "foo.baz != 1"
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rsi, rax
        mov     edi, OFFSET FLAT:.LC0
        mov     eax, 0
        call    scanf
        movzx   eax, BYTE PTR [rbp-1]
        and     eax, 1
        test    al, al
        je      .L2
        mov     edi, OFFSET FLAT:.LC1
        call    puts
        jmp     .L3
.L2:
        mov     edi, OFFSET FLAT:.LC2
        call    puts
.L3:
        mov     eax, 0
        leave
        ret

Answer 1

堆栈粉碎与成员访问无关。

scanf("%d", &foo.bar);

的%d格式转换指定为一个INT。通常为 4 个字节。但你的bar是：

int8_t bar;

只有一个字节。

因此，scanf最终将一个 4 字节的 int 值写入一个 1 字节bar，并在附近破坏了三个额外的字节。

这是你的堆栈粉碎。

Answer 2

答案是微不足道的。

你的baz结构成员是 1 位长，它是signed. 因此，这将永远是1。唯一可能的值是0和-1。

编译器知道这一点，所以条件foo.baz == 1永远不会是事实。无需生成条件代码。

所以我担心这不是编译器的错误，只是程序员的错误:)

所以如果我们把代码改成：

int main()
{
    union Foo foo;
    int x;
    scanf("%d", &x);
    foo.bar = x;
    if (foo.baz == -1)
        printf("foo.baz == -1\n");
    else
        printf("foo.baz != -1\n");
}

编译器开始生成条件指令。

https://godbolt.org/z/fzKMo5

顺便说一句，您的字节序检查在这里没有任何意义，因为字节序定义了字节顺序而不是位顺序

与代码生成问题无关的是使用了错误的scanf转换说明符。