Mangling of member-expressions involving anonymous unions.

[tm]

Summary

When mangling member-expressions, mangle only access to first named member,
ignoring unnamed ones in anonymous unions. This fixes crash reported in bug
report 15542, and results in behaviour consistent with GCC.

[rsmith]

If I reduce to a valid testcase (dropping one layer of the union), then EDG mangles your x.implicit_this(y) callee as:

_ZNK5test61XIiE13implicit_thisINS_1YEEEDTclfp_L_ZNS1_4__C11mEEEET_

whereas GCC and Clang with this patch mangle it as

_ZNK5test61XIiE13implicit_thisINS_1YEEEDTclfp_dtdefpT1mEET_

The difference is the argument to f; EDG uses

L_ZNS1_4__C11mEE

which is <external-name> test6::X<int>::__C1::m, which doesn't seem very good. I think GCC's mangling is the best option here, but please also suggest this on the cxx-abi-dev mailing list.

lib/AST/ItaniumMangle.cpp

2538

Please use

if (isa<IndirectFieldDecl>(ME->getMemberDecl()))

... to more directly express the intent here.

test/CodeGenCXX/mangle-exprs.cpp

225–226

This is, strictly speaking, ill-formed; you cannot define a type within an anonymous union. Please also add a test case with only one layer of anonymous union so that we test the non-extension case. Please also add a test with an anonymous struct (maybe to this multi-layer case).

234–238

These are both ill-formed. You can't use this-> (or (*this).) in a trailing return type because the class type is not yet complete (but it appears we don't diagnose it in this case). Please use a type other than X in this check.

[tm]

I have updated tests to include an anonymous union, an anonymous struct and
combinations of those two. In addition, dependency on non-diagnosed incomplete
type in member-expression has been removed.

End condition is now made more explicit using IndirectFieldDecl, but this
requires additional check ensuring that we are in fact dealing with an
anonymous union / struct (so that we don't break non-anonymous case). Did you
have something simpler in mind here?

[tm]

Indeed, something like "if (!member) return mangleExpression(base)", would be
really nice, but the problem is that we need a member name from outermost
MemberExpr generated from IndirectFieldDecl, and isArrow from innermost
MemberExpr generated from IndirectFieldDecl.

I updated the code to skip over all bases whose types are anonymous structs or
unions, though I will mention that first version that relied on empty
identifiers would also work.

[rsmith]

This was committed as r222402.

lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleMemberExpr(const Expr *base,
                                       bool isArrow,
                                       NestedNameSpecifier *qualifier,
                                       NamedDecl *firstQualifierLookup,
                                       DeclarationName member,
                                       unsigned arity) {
   // <expression> ::= dt <expression> <unresolved-name>
   //              ::= pt <expression> <unresolved-name>
   if (base) {
+
+    // Ignore member expressions involving anonymous unions.
+    while (const auto *RT = base->getType()->getAs<RecordType>()) {
+      if (!RT->getDecl()->isAnonymousStructOrUnion())
+        break;
+      const auto *ME = dyn_cast<MemberExpr>(base);
+      if (!ME)
+        break;
+      base = ME->getBase();
+      isArrow = ME->isArrow();
+    }
+
     if (base->isImplicitCXXThis()) {
       // Note: GCC mangles member expressions to the implicit 'this' as
       // *this., whereas we represent them as this->. The Itanium C++ ABI
       // does not specify anything here, so we follow GCC.
       Out << "dtdefpT";
     } else {
       Out << (isArrow ? "pt" : "dt");
       mangleExpression(base);

test/CodeGenCXX/mangle-exprs.cpp

 
 }
 
 namespace test5 {
   template <typename T> void a(decltype(noexcept(T()))) {}
   template void a<int>(decltype(noexcept(int())));
   // CHECK: void @_ZN5test51aIiEEvDTnxcvT__EE(
 }
+
+namespace test6 {
+  struct X {
+    int i;
+  };
+
+  struct Y {
+    union {
+      int i;
+    };
+  };
+
+  struct Z {
+    union {
+      X ua;
+      Y ub;
+    };
+
+    struct {
+      X s;
+    };
+
+    union {
+      union {
+        struct {
+          struct {
+            X uuss;
+          };
+        };
+      };
+    };
+  };
+
+  Z z, *zp;
+
+  template<typename T>
+  void f1(decltype(T(z.ua.i))) {}
+  template void f1<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f1IiEEvDTcvT_dtdtL_ZNS_1zEE2ua1iE
+
+  template<typename T>
+  void f2(decltype(T(z.ub.i))) {}
+  template void f2<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f2IiEEvDTcvT_dtdtL_ZNS_1zEE2ub1iE
+
+  template<typename T>
+  void f3(decltype(T(z.s.i))) {}
+  template void f3<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f3IiEEvDTcvT_dtdtL_ZNS_1zEE1s1iE
+
+  template<typename T>
+  void f4(decltype(T(z.uuss.i))) {}
+  template void f4<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f4IiEEvDTcvT_dtdtL_ZNS_1zEE4uuss1iE
+
+  template<typename T>
+  void f5(decltype(T(zp->ua.i))) {}
+  template void f5<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f5IiEEvDTcvT_dtptL_ZNS_2zpEE2ua1iE
+
+  template<typename T>
+  void f6(decltype(T(zp->ub.i))) {}
+  template void f6<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f6IiEEvDTcvT_dtptL_ZNS_2zpEE2ub1iE
+
+  template<typename T>
+  void f7(decltype(T(zp->s.i))) {}
+  template void f7<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f7IiEEvDTcvT_dtptL_ZNS_2zpEE1s1iE
+
+  template<typename T>
+  void f8(decltype(T(zp->uuss.i))) {}
+  template void f8<int>(int);
+  // CHECK-LABEL: define weak_odr void @_ZN5test62f8IiEEvDTcvT_dtptL_ZNS_2zpEE4uuss1iE
+}
+