Packed member warning: Use the typedef name for anonymous structures when it is available

[arphaman]

Summary

This patch improves the packed member warning by showing the name of the anonymous structure/union when it was defined with a typedef, e.g. the code below:

typedef struct {
  char c;
  int x;
} __attribute__((packed)) Foo;
int *foo(Foo *f) { return &f->x; }

Would now produce the following warning:

taking address of packed member 'x' of class or structure 'Foo' may result in an unaligned pointer value

[arphaman]

I had to reuploaded the diff as Phabricator seemed to have removed the 'lib' and 'test' paths prefixes from the filenames in the original diff.

[aaron.ballman]

lib/Sema/SemaChecking.cpp

11284 ↗

(On Diff #73076)

Please don't use auto here since the type is not spelled directly in the initialization.

test/Sema/address-packed.c

187 ↗

(On Diff #73076)

Can you add a test along the lines of:

struct S {
  union {
    char c;
    int x;
  } __attribute__((packed));
};

int *ugh(S *s) {
  return &s->x;   
}

[arphaman]

Update to the patch that follows Aaron's comments:

• Uses the explicit type name instead of auto.
• Expands the test by adding a scenario where an inner anonymous union is contained in a structure.

[aaron.ballman]

LGTM, thank you!

cfe/trunk/lib/Sema/SemaChecking.cpp

 
 void Sema::AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
                                          CharUnits Alignment) {
   MisalignedMembers.emplace_back(E, RD, MD, Alignment);
 }
 
 void Sema::DiagnoseMisalignedMembers() {
   for (MisalignedMember &m : MisalignedMembers) {
+    const NamedDecl *ND = m.RD;
+    if (ND->getName().empty()) {
+      if (const TypedefNameDecl *TD = m.RD->getTypedefNameForAnonDecl())
+        ND = TD;
+    }
     Diag(m.E->getLocStart(), diag::warn_taking_address_of_packed_member)
-        << m.MD << m.RD << m.E->getSourceRange();
+        << m.MD << ND << m.E->getSourceRange();
   }
   MisalignedMembers.clear();
 }
 
 void Sema::DiscardMisalignedMemberAddress(const Type *T, Expr *E) {
   if (!T->isPointerType())
     return;
   if (isa<UnaryOperator>(E) &&

cfe/trunk/test/Sema/address-packed.c

 struct __attribute__((packed, aligned(2))) AlignedTo2Bis {
   int x;
 };
 
 struct AlignedTo2Bis* g7(struct AlignedTo2 *s)
 {
     return (struct AlignedTo2Bis*)&s->x; // no-warning
 }
+
+typedef struct {
+  char c;
+  int x;
+} __attribute__((packed)) TypedefStructArguable;
+
+typedef union {
+  char c;
+  int x;
+} __attribute((packed)) TypedefUnionArguable;
+
+typedef TypedefStructArguable TypedefStructArguableTheSecond;
+
+int *typedef1(TypedefStructArguable *s) {
+    return &s->x; // expected-warning {{packed member 'x' of class or structure 'TypedefStructArguable'}}
+}
+
+int *typedef2(TypedefStructArguableTheSecond *s) {
+    return &s->x; // expected-warning {{packed member 'x' of class or structure 'TypedefStructArguable'}}
+}
+
+int *typedef3(TypedefUnionArguable *s) {
+    return &s->x; // expected-warning {{packed member 'x' of class or structure 'TypedefUnionArguable'}}
+}
+
+struct S6 {
+  union {
+    char c;
+    int x;
+  } __attribute__((packed));
+};
+
+int *anonymousInnerUnion(struct S6 *s) {
+  return &s->x; // expected-warning {{packed member 'x' of class or structure 'S6::(anonymous)'}}
+}