Unnamed bitfields don't block constant evaluation of constexpr constructors

[jordan_rose]

Summary

C++14 [dcl.constexpr]p4 states that in the body of a constexpr constructor,

every non-variant non-static data member and base class sub-object shall be initialized

However, [class.bit]p2 notes that

Unnamed bit-fields are not members and cannot be initialized.

Therefore, we should make sure to filter them out of the check that all fields are initialized.

Fixing this makes the constant evaluator a bit smarter, and specifically allows constexpr constructors to avoid tripping -Wglobal-constructors when the type contains unnamed bitfields.

[aaron.ballman]

Aside from some minor nits, LGTM!

test/SemaCXX/constant-expression-cxx11.cpp

1924

Can remove the spurious newline.

test/SemaCXX/warn-global-constructors.cpp

130

Does this namespace require a name? If so, can it be named different than the struct declared within it?

148

Please ensure the file retains its newline.

[jordan_rose]

Thanks, Aaron!

test/SemaCXX/warn-global-constructors.cpp

130

I'm just trying to keep from having my test cases collide with the rest of the file and any future additions. I'll change it. (There's no PR or Radar for this at the moment; I just came across it while working on something else.)

[jordan_rose]

Landed in rL316408.

lib/AST/ExprConstant.cpp

       for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
              End = CD->bases_end(); I != End; ++I, ++BaseIndex) {
         if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
                                      Value.getStructBase(BaseIndex)))
           return false;
       }
     }
     for (const auto *I : RD->fields()) {
+      if (I->isUnnamedBitfield())
+        continue;
+
       if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
                                    Value.getStructField(I->getFieldIndex())))
         return false;
     }
   }
 
   if (Value.isLValue()) {
     LValue LVal;

test/SemaCXX/constant-expression-cxx11.cpp

     struct X {
       int x : 1;
       constexpr static int f(int x) {
         return X{x}.x;
       }
     };
     static_assert(X::f(3) == -1, "3 should truncate to -1");
   }
+
+
+  struct HasUnnamedBitfield {
+    unsigned a;
+    unsigned : 20;
+    unsigned b;
+
+    constexpr HasUnnamedBitfield() : a(), b() {}
+    constexpr HasUnnamedBitfield(unsigned a, unsigned b) : a(a), b(b) {}
+  };
+
+  void testUnnamedBitfield() {
+    const HasUnnamedBitfield zero{};
+    int a = 1 / zero.b; // expected-error {{division by zero is undefined}}
+    const HasUnnamedBitfield oneZero{1, 0};
+    int b = 1 / oneZero.b; // expected-error {{division by zero is undefined}}
+  }
 }
 
 namespace ZeroSizeTypes {
   constexpr int (*p1)[0] = 0, (*p2)[0] = 0;
   constexpr int k = p2 - p1;
   // expected-error@-1 {{constexpr variable 'k' must be initialized by a constant expression}}
   // expected-note@-2 {{subtraction of pointers to type 'int [0]' of zero size}}
 

test/SemaCXX/warn-global-constructors.cpp

namespace pr19253 {
   E e;
 }
 
 namespace pr20420 {
 // No warning is expected. This used to crash.
 void *array_storage[1];
 const int &global_reference = *(int *)array_storage;
 }
+
+namespace HasUnnamedBitfield {
+  struct HasUnnamedBitfield {
+    unsigned a;
+    unsigned : 20;
+    unsigned b;
+
+    constexpr HasUnnamedBitfield() : a(), b() {}
+    constexpr HasUnnamedBitfield(unsigned a, unsigned b) : a(a), b(b) {}
+    explicit HasUnnamedBitfield(unsigned a) {}
+  };
+
+  const HasUnnamedBitfield zeroConst{};
+  HasUnnamedBitfield zeroMutable{};
+  const HasUnnamedBitfield explicitConst{1, 2};
+  HasUnnamedBitfield explicitMutable{1, 2};
+  const HasUnnamedBitfield nonConstexprConst{1}; // expected-warning {{global constructor}}
+  HasUnnamedBitfield nonConstexprMutable{1}; // expected-warning {{global constructor}}
+}
 No newline at end of file