Address of bitfield in anonymous struct doesn't error.

[jacobly]

Summary

struct A {
  struct {
    int B : 1;
  }
}
int A::*addr_anon_bitfield() {
    return &A::B;
}

This code does not error, but instead returns a member pointer to a full int that starts at the beginning of the byte the bitfield starts on.

[jacobly]

This comment was removed by jacobly.

[jacobly]

I don't have commit access, could someone commit this for me?

[rsmith]

The change to test/SemaCXX/anonymous-struct.cpp appeared to be unrelated to the rest of the patch, so I committed it separately as r300266.

Thank you!

cfe/trunk/lib/Sema/SemaExpr.cpp

Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
 
   MarkDeclRefReferenced(E);
 
   if (getLangOpts().ObjCWeak && isa<VarDecl>(D) &&
       Ty.getObjCLifetime() == Qualifiers::OCL_Weak &&
       !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getLocStart()))
       recordUseOfEvaluatedWeak(E);
 
-  if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
+  FieldDecl *FD = dyn_cast<FieldDecl>(D);
+  if (IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(D))
+    FD = IFD->getAnonField();
+  if (FD) {
     UnusedPrivateFields.remove(FD);
     // Just in case we're building an illegal pointer-to-member.
     if (FD->isBitField())
       E->setObjectKind(OK_BitField);
   }
 
   // C++ [expr.prim]/8: The expression [...] is a bit-field if the identifier
   // designates a bit-field.

cfe/trunk/test/Sema/expr-address-of.c

 void f6(register int x) {
   int * dummy0 = &x; // expected-error {{address of register variable requested}}
 }
 
 char* f7() {
   register struct {char* x;} t1 = {"Hello"};
   char* dummy1 = &(t1.x[0]);
 
-  struct {int a : 10;} t2;
+  struct {int a : 10; struct{int b : 10;};} t2;
   int* dummy2 = &(t2.a); // expected-error {{address of bit-field requested}}
+  int* dummy3 = &(t2.b); // expected-error {{address of bit-field requested}}
 
   void* t3 = &(*(void*)0);
 }
 
 void f8() {
   void *dummy0 = &f8(); // expected-error {{cannot take the address of an rvalue of type 'void'}}
 
   extern void v;
   void *dummy1 = &(1 ? v : f8()); // expected-error {{cannot take the address of an rvalue of type 'void'}}
 
   void *dummy2 = &(f8(), v); // expected-error {{cannot take the address of an rvalue of type 'void'}}
 
   void *dummy3 = &({ ; }); // expected-error {{cannot take the address of an rvalue of type 'void'}}
 }

cfe/trunk/test/SemaCXX/ptrtomember.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
 
 struct  S {
   int i;
 
   int mem(int);
 };
 
 int foo(int S::* ps, S *s)
 {
     return (s->*ps)(1); // expected-error {{called object type 'int' is not a function or function pointer}}
 }
 
 struct S2 {
   int bitfield : 1;
+  struct {
+    int anon_bitfield : 1;
+  };
 };
 
 int S2::*pf = &S2::bitfield; // expected-error {{address of bit-field requested}}
+int S2::*anon_pf = &S2::anon_bitfield; // expected-error {{address of bit-field requested}}
 
 struct S3 {
   void m();
 };
 
 void f3(S3* p, void (S3::*m)()) {
     p->*m; // expected-error {{reference to non-static member function must be called}}
     (void)(p->*m); // expected-error {{reference to non-static member function must be called}}
     (void)(void*)(p->*m); // expected-error {{reference to non-static member function must be called}} expected-error {{cannot cast from type 'void' to pointer type 'void *'}}
     (void)reinterpret_cast<void*>(p->*m); // expected-error {{reference to non-static member function must be called}} expected-error {{reinterpret_cast from 'void' to 'void *' is not allowed}}
     if (p->*m) {} // expected-error {{reference to non-static member function must be called}} expected-error {{value of type 'void' is not contextually convertible to 'bool'}}
     if (!(p->*m)) {} // expected-error {{reference to non-static member function must be called}} expected-error {{invalid argument type 'void' to unary expression}}
     if (p->m) {}; // expected-error {{reference to non-static member function must be called}} expected-error {{value of type 'void' is not contextually convertible to 'bool'}}
     if (!p->m) {}; // expected-error {{reference to non-static member function must be called}} expected-error {{invalid argument type 'void' to unary expression}}
 }