考虑以下简单示例：

struct __attribute__ ((__packed__)) {
 int code[1];
 int place_holder[100];
} s;

void test(int n)
{
 int i;

 for (i = 0; i < n; i++) {
  s.code[i] = 1;
 }
}

for 循环正在写入字段code，其大小为 1。之后的下一个字段code is place_holder.
我希望在这种情况下n > 1，写入code数组会溢出并且1将被写入place_holder.

但是，当编译时-O2（在 gcc 4.9.4 上，但也可能在其他版本上）发生了一些有趣的事情。
编译器识别出代码可能溢出数组code, and 将循环展开限制为 1 次迭代.

编译时很容易看出-fdump-tree-all并查看最后一个树通道（“t.optimized”）：

;; Function test (test, funcdef_no=0, decl_uid=1366, symbol_order=1)

Removing basic block 5
test (int n)
{
  <bb 2>:
  # DEBUG i => 0
  # DEBUG i => 0
  if (n_4(D) > 0)
    goto <bb 3>;
  else
    goto <bb 4>;

  <bb 3>:
  s.code[0] = 1;
  # DEBUG i => 1
  # DEBUG i => 1

  <bb 4>:
  return;

}

因此，在这种情况下，编译器将循环完全展开为一次迭代。

我的问题是：

1. 从 C 规范的角度来看，从一个结构成员（故意）溢出到下一个是非法或未定义的行为吗？
   假设我知道内存中的结构布局，并且知道在故意溢出时我在做什么code array.
2. 在这种情况下有没有办法阻止 gcc 展开循环？我知道我可以完全阻止循环展开，但是我仍然对其他情况下的循环展开感兴趣。我还怀疑编译器正在进行的分析可能会影响除循环展开之外的传递。
   gcc 假设我在访问数组时不会溢出，所以我真正寻找的是告诉编译器不要采用这种假设的方法（通过提供一些编译器选项）。

我知道编写从一个字段溢出到另一个字段的代码是一种不好的做法，而且我不打算编写这样的代码。
我还知道将数组（可能大小为零）作为last结构体字段允许它溢出，编译器很好地支持这一点，而在这种情况下数组code不是最后一个字段。
所以这不是一个“如何修复代码”的问题，而是一个理解编译器假设并影响它们的问题。

当我观察已经以这种方式编写的现有代码并对其进行调试以找出其行为与原始开发人员期望的行为不同的原因时，出现了这些问题。
风险在于代码中的其他地方也存在此类问题。静态分析工具可以帮助找出答案，但我也想知道是否有一种方法可以使编译器容忍此类代码并仍然生成我们期望的结果。

Update

我对上面的问题（1）得到了明确的答案，但对问题（2）却没有得到明确的答案。

• gcc 可以通过某些编译选项允许将此作为​​扩展吗？
• 有没有办法至少在 gcc 识别它时收到警告？ （并且它通过优化来清楚地识别它）。
  这对于在大型现有代码库中识别此类情况非常重要。

从 C 规范的角度来看，从一个结构成员（故意）溢出到下一个是非法或未定义的行为吗？

这是未定义的行为。这arr[i]运算符是语法糖*(arr + i)。所以数组访问归结为二进制+指针算术运算符，C17 6.5.6 加法运算符，来自 §7 和 §8：

就这些运算符而言，指向不是元素元素的对象的指针 数组的行为与指向长度为 1 的数组的第一个元素的指针相同 对象的类型作为其元素类型。

当一个整数类型的表达式与指针相加或相减时， 结果具有指针操作数的类型。 /--/
如果两个指针 操作数和结果指向同一个数组对象的元素，或者指向最后一个元素 数组对象的元素，求值不得产生溢出；否则， 行为未定义。 如果结果指向数组对象的最后一个元素，则它 不得用作所求值的一元 * 运算符的操作数。

正如您所注意到的，优化编译器可能会利用这些规则来生成更快的代码。

在这种情况下有没有办法阻止 gcc 展开循环？

有一个可以使用的特殊例外规则，C17 6.3.2.3/7：

当指向对象的指针转换为指向字符类型的指针时， 结果指向对象的最低寻址字节。连续递增 结果，直到对象的大小，产生指向对象的剩余字节的指针。

此外，严格别名不适用于字符类型，因为 C17 6.5 §7 中的另一个特殊规则

对象的存储值只能由具有以下之一的左值表达式访问 以下类型： ... 字符类型。

这两种特殊规则和谐共存。因此，假设我们在指针转换期间不会弄乱对齐等，这意味着我们可以这样做：

unsigned char* i;
for(i = (unsigned char*)&mystruct; i < (unsigned char*)(&mystruct + 1); i++)
{
  do_something(*i);
}

然而，这可能会读取填充字节等，因此它是“实现定义的”。但理论上，您可以按字节访问结构体字节，并且只要按字节计算结构体偏移量，您就可以以这种方式迭代结构体（或任何其他对象）的多个成员。

据我所知，这个看起来非常有问题的代码应该是明确定义的：

#include <stdint.h>
#include <string.h>
#include <stdio.h>

struct __attribute__ ((__packed__)) {
 int code[1];
 int place_holder[100];
} s;

void test(int val, int n)
{
  for (unsigned char* i = (unsigned char*)&s; 
       i < (unsigned char*)&s + n*sizeof(int); 
       i += _Alignof(int)) 
  {
    if((uintptr_t)i % _Alignof(int) == 0) // not really necessary, just defensive prog.
    {
      memcpy(i, &val, sizeof(int));
      printf("Writing %d to address %p\n", val, (void*)i);
    }
  }
}

int main (void)
{
  test(42, 3);
  printf("%d %d %d\n", s.code[0], s.place_holder[0], s.place_holder[1]);
}

这在 gcc 和 clang (x86) 上运行良好。至于效率如何，那就是另一个故事了。但请不要编写这样的代码。