位域溢出

Question

我可以相信每次访问位字段时 C 编译器都会对 2^n 取模吗？ 或者是否有任何编译器/优化，其中像下面这样的代码不会打印出溢出？

struct {
  uint8_t foo:2;
} G;

G.foo = 3;
G.foo++;

if(G.foo == 0) {
  printf("Overflow\n");
}

提前致谢，弗洛里安

Answer 1

是的，您可以相信 C 编译器会在此处执行正确的操作，只要使用 uint8_t 所具有的无符号类型声明位字段即可。来自 C99 标准 §6.2.6.1/3：

存储在无符号位域和无符号字符类型对象中的值应使用纯二进制表示法表示。⁴⁰⁾

从 §6.7.2.1/9 开始：

位字段被解释为由指定位数组成的有符号或无符号整数类型。¹⁰⁴⁾如果值 0 或 1 存储到类型_Bool，位字段的值应等于存储的值。

从§6.2.5/9（强调我的）：

有符号整数类型的非负值范围是相应无符号整数类型的子范围，并且每个类型中相同值的表示是相同的。³¹⁾ A涉及无符号操作数的计算永远不会溢出，因为无法由结果无符号整数类型表示的结果会以比结果类型可以表示的最大值大 1 的数为模进行缩减。

所以是的，您可以确保任何符合标准的编译器都会将 G.foo 溢出到 0，而不会产生任何其他不需要的副作用。

Answer 2

不会。编译器为该字段分配 2 位，递增 3 会得到 100b，而放入 2 位时会得到 0。

Answer 3

是的。我们可以从汇编中得到答案。
这是我在 Ubuntu 16.04、64 位、gcc 中编写的示例。

#include <stdio.h>

typedef unsigned int uint32_t;

struct {
  uint32_t foo1:8;
  uint32_t foo2:24;
} G;

int main() {
    G.foo1 = 0x12;
    G.foo2 = 0xffffff; // G is 0xfffff12
    printf("G.foo1=0x%02x, G.foo2=0x%06x, G=0x%08x\n", G.foo1, G.foo2, *(uint32_t *)&G);
    G.foo2++; // G.foo2 overflow
    printf("G.foo1=0x%02x, G.foo2=0x%06x, G=0x%08x\n", G.foo1, G.foo2, *(uint32_t *)&G);
    G.foo1 += (0xff-0x12+1); // // G.foo1 overflow
    printf("G.foo1=0x%02x, G.foo2=0x%06x, G=0x%08x\n", G.foo1, G.foo2, *(uint32_t *)&G);
    return 0;
}

使用gcc -S <.c file> 编译它。您可以获取汇编文件.s。这里我展示了G.foo2++;的汇编，并写了一些注释。

movl    G(%rip), %eax
shrl    $8, %eax    #  0xfffff12-->0x00ffffff
addl    $1, %eax    # 0x00ffffff+1=0x01000000
andl    $16777215, %eax # 16777215=0xffffff, so eax still 0x01000000
sall    $8, %eax    # 0x01000000-->0x00000000
movl    %eax, %edx  # edx high-24bit is fool2
movl    G(%rip), %eax   # G.foo2, tmp123
movzbl  %al, %eax   # so eax=0x00000012
orl     %edx, %eax  # eax=0x00000012 | 0x00000000 = 0x00000012
movl    %eax, G(%rip)   # write to G

我们可以看到，编译器会使用移位指令来确保你所说的。（注：这里G的内存布局是：

----------------------------------
|     foo2-24bit     | foo1-8bit |
----------------------------------

当然，前面提到的结果是：

G.foo1=0x12, G.foo2=0xffffff, G=0xffffff12
G.foo1=0x12, G.foo2=0x000000, G=0x00000012
G.foo1=0x00, G.foo2=0x000000, G=0x00000000

Answer 4

简短的回答：是的，您可以相信模 2^n 会发生。

在你的程序中，
G.foo++; 实际上相当于 G.foo = (unsigned int)G.foo + 1。

无符号整型算术总是产生 2^（无符号整型的大小（以位为单位））结果。然后，权重最小的两位存储在 G.foo 中，产生零。