为什么在一个函数中声明的联合类型在另一个函数中使用无效？

Question

当我阅读 ISO/IEC 9899:1999（参见：6.5.2.3）时，我看到了一个这样的例子（强调我的）：

以下是不是有效片段（因为联合类型在函数f中不可见）：

struct t1 { int m; };
struct t2 { int m; };
int f(struct t1 * p1, struct t2 * p2)
{
      if (p1->m < 0)
            p2->m = -p2->m;
      return p1->m;
}
int g()
{
      union {
            struct t1 s1;
            struct t2 s2;
      } u;
      /* ... */
      return f(&u.s1, &u.s2);
}

我在测试时没有发现任何错误和警告。

我的问题是：为什么这个片段无效？

Answer 1

该示例试图预先说明该段落¹（强调我的）：

6.5.2.3 ¶6

为了简化联合的使用，我们做出了一项特殊保证： 如果一个并集包含多个共享一个共同首字母的结构 序列（见下文），如果联合对象当前包含一个 在这些结构中，允许检查共同的首字母 它们中的任何一个的一部分，在完成类型的声明的任何地方 工会的可见。两个结构共享一个共同的首字母 如果相应的成员具有兼容的类型（并且，对于 位域，相同的宽度）用于一个或多个初始的序列 成员。

由于f 在g 之前声明，而且未命名的联合类型是g 的本地类型，因此毫无疑问联合类型在f 中不可见。

该示例没有显示u 是如何初始化的，但假设最后写入成员是u.s2.m，该函数具有未定义的行为，因为它检查p1->m 而没有有效的通用初始序列保证。

如果在函数调用之前最后写入的是u.s1.m，那么反过来也是如此，那么访问p2->m 是未定义的行为。

注意f 本身并不是无效的。这是一个完全合理的函数定义。未定义的行为源于将 &u.s1 和 &u.s2 作为参数传递给它。这就是导致未定义行为的原因。

---

_{¹ - 我引用的是 C11 标准草案 n1570。但是规范应该是相同的，只需要向上/向下移动一两个段落。}

Answer 2

下面是严格的别名规则：C（或 C++）编译器做出的一个假设是，取消引用指向不同类型对象的指针永远不会引用相同的内存位置（即相互别名。）

这个功能

int f(struct t1* p1, struct t2* p2);

假设 p1 != p2 因为它们正式指向不同的类型。因此，优化者可能会假设p2->m = -p2->m; 对p1->m 没有影响；它可以先将p1->m的值读入一个寄存器，与0比较，如果小于0，则做p2->m = -p2->m;，最后原样返回寄存器值！

这里的联合是在二进制级别生成p1 == p2 的唯一方法，因为所有联合成员都有相同的地址。

另一个例子：

struct t1 { int m; };
struct t2 { int m; };

int f(struct t1* p1, struct t2* p2)
{
    if (p1->m < 0) p2->m = -p2->m;
    return p1->m;
}

int g()
{
    union {
        struct t1 s1;
        struct t2 s2;
    } u;
    u.s1.m = -1;
    return f(&u.s1, &u.s2);
}

g 必须返回什么？ +1按照常识（我们把f中的-1改为+1）。但是如果我们看一下 gcc 的 generate 程序集加上-O1 优化

f:
        cmp     DWORD PTR [rdi], 0
        js      .L3
.L2:
        mov     eax, DWORD PTR [rdi]
        ret
.L3:
        neg     DWORD PTR [rsi]
        jmp     .L2
g:
        mov     eax, 1
        ret

到目前为止，一切都被排除在外。但是当我们尝试使用-O2

f:
        mov     eax, DWORD PTR [rdi]
        test    eax, eax
        js      .L4
        ret
.L4:
        neg     DWORD PTR [rsi]
        ret
g:
        mov     eax, -1
        ret

返回值现在是硬编码的-1

这是因为一开始f将p1->m的值缓存在eax寄存器(mov eax, DWORD PTR [rdi])中，而在p2->m = -p2->m;(neg DWORD PTR [rsi])之后不再重读 ) - 它返回 eax 不变。

---

union 这里只用于 联合对象的所有非静态数据成员都具有相同的地址。 结果&u.s1 == &u.s2。

有人不懂汇编代码，可以在 c/c++ 中说明严格的别名如何影响 f 代码：

int f(struct t1* p1, struct t2* p2)
{
    int a = p1->m;
    if (a < 0) p2->m = -p2->m;
    return a; 
}

编译器缓存p1->m 本地变量a 中的值（当然实际上在寄存器中）并返回它，尽管p2->m = -p2->m; 更改p1->m。但编译器假定p1 内存不受影响，因为它假定p2 指向另一个不与p1 重叠的内存

因此，使用不同的编译器和不同的优化级别，相同的源代码可以返回不同的值（-1 或 +1）。所以和未定义的行为原样

Answer 3

通用初始序列规则的主要目的之一是允许函数可互换地对许多相似的结构进行操作。但是，要求编译器假定任何作用于结构的函数都可能更改任何其他共享公共初始序列的结构中的相应成员，这会损害有用的优化。

尽管大多数依赖于通用初始序列保证的代码都使用了一些易于识别的模式，例如

struct genericFoo {int size; short mode; };
struct fancyFoo {int size; short mode, biz, boz, baz; };
struct bigFoo {int size; short mode; char payload[5000]; };

union anyKindOfFoo {struct genericFoo genericFoo;
  struct fancyFoo fancyFoo;
  struct bigFoo bigFoo;};

...
if (readSharedMemberOfGenericFoo( myUnion->genericFoo ))
  accessThingAsFancyFoo( myUnion->fancyFoo );
return readSharedMemberOfGenericFoo( myUnion->genericFoo );

重新审视对作用于不同联合成员的函数的调用之间的联合，该标准的作者指出，被调用函数中联合类型的可见性应该是函数是否应该识别访问例如的可能性的决定因素。 FancyFoo 的字段 mode 可能会影响 genericFoo 的字段 mode。要求有一个包含所有类型结构的联合，这些结构的地址可能与该函数在同一编译单元中传递给readSharedMemberOfGeneric，这使得通用初始序列规则的用处不如其他规则，但至少允许某些模式像上面一样可用。

gcc 和 clang 的作者认为，将联合声明视为所涉及的类型可能涉及上述构造的指示对于优化来说是一个不切实际的障碍，并认为由于标准不需要它们要通过其他方式支持此类构造，他们根本不会支持它们。因此，需要以任何有意义的方式利用通用初始序列保证的代码的真正要求不是确保联合类型声明是可见的，而是确保使用-fno-strict-aliasing 标志调用clang 和gcc。在实际情况下还包括一个可见的联合声明不会受到伤害，但它既没有必要也不足以确保 gcc 和 clang 的正确行为。