CodeGen: Make constant emission of arrays and structs more aggressive.

[bkramer]

Summary

The limitation to POD types stems from the times when our constant emission
logic was way less sophisticated and much more buggy. Emit all constant
initializers as LLVM constants.

This reuses the logic for static vars, so assert that we don't accidentally
introduce a static initializer. I tried to cover the issues mentioned in the
commit with additional test cases.

[rsmith]

lib/CodeGen/CGDecl.cpp

890–894

There are still cases that isConstantInitializer gets wrong. For instance, we don't check that the array filler is a constant for an array InitListExpr:

struct X { X(); constexpr X(int) {} }; X x[3] = { 3 };

(You can see that there's a problem here because we emit dynamic initialization code but no -Wglobal-constructors warning.)

(Unrelated to your change) The bitfield case is still broken; this asserts:

struct X { long n : 3; }; int k; X x = { (long)&k };

lib/CodeGen/CGDecl.cpp

CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
 
   llvm::Value *DeclPtr;
   if (Ty->isConstantSizeType()) {
     bool NRVO = getLangOpts().ElideConstructors &&
       D.isNRVOVariable();
 
     // If this value is an array or struct with a statically determinable
     // constant initializer, there are optimizations we can do.
-    //
-    // TODO: We should constant-evaluate the initializer of any variable,
-    // as long as it is initialized by a constant expression. Currently,
-    // isConstantInitializer produces wrong answers for structs with
-    // reference or bitfield members, and a few other cases, and checking
-    // for POD-ness protects us from some of these.
     if (D.getInit() && (Ty->isArrayType() || Ty->isRecordType()) &&
         (D.isConstexpr() ||
-         ((Ty.isPODType(getContext()) ||
-           getContext().getBaseElementType(Ty)->isObjCObjectPointerType()) &&
-          D.getInit()->isConstantInitializer(getContext(), false)))) {
-
+         D.getInit()->isConstantInitializer(getContext(), false))) {
       // If the variable's a const type, and it's neither an NRVO
       // candidate nor a __block variable and has no mutable members,
       // emit it as a global instead.
       if (CGM.getCodeGenOpts().MergeAllConstants && !NRVO && !isByRef &&
           CGM.isTypeConstant(Ty, true)) {
         EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);
+        assert(cast<llvm::GlobalVariable>(LocalDeclMap[&D])->isConstant() &&
+               "Constant initializer not emitted as constant!");
 
         emission.Address = nullptr; // signal this condition to later callbacks
         assert(emission.wasEmittedAsGlobal());
         return emission;
       }
 
       // Otherwise, tell the initialization code that we're in this case.
       emission.IsConstantAggregate = true;

test/CodeGenCXX/const-init-cxx11.cpp

 struct X {
   static constexpr const char &p = 'c';
 };
 
 // CHECK: @_ZGRN34ClassWithStaticConstexprDataMember1X1pE_
 const char *f() { return &X::p; }
 }
 
+namespace ConstExprArray {
+  class C {
+    int x;
+  public:
+    constexpr C(int x) : x(x) {}
+  };
+  void f(const C *);
+  void g() {
+// CHECK-LABEL: _ZN14ConstExprArray1gEv
+// CHECK: call void @_ZN14ConstExprArray1fEPKNS_1CE{{.*}}@_ZZN14ConstExprArray1gEvE2Cs
+    const C Cs[] = {1, 2, 3, 4};
+    f(Cs);
+  }
+}
+
 // VirtualMembers::TemplateClass::templateMethod() must be defined in this TU,
 // not just declared.
 // CHECK: define linkonce_odr void @_ZN14VirtualMembers13TemplateClassIiE14templateMethodEv(%"struct.VirtualMembers::TemplateClass"* %this)

test/CodeGenCXX/const-init.cpp

 void FoldableAddrLabelDiff() { static long x = (long)&&a-(long)&&b; a:b:return;}
 
 // CHECK: @i = constant i32* bitcast (float* @PR9558 to i32*)
 int &i = reinterpret_cast<int&>(PR9558);
 
 int arr[2];
 // CHECK: @pastEnd = constant i32* bitcast (i8* getelementptr (i8* bitcast ([2 x i32]* @arr to i8*), i64 8) to i32*)
 int &pastEnd = arr[2];
+
+struct RefMember {
+  int &Ref;
+};
+
+RefMember initRefMember() {
+  // CHECK: {{.*}}RefMemberInit{{.*}} = {{.*}}constant{{.*}}@arr
+  RefMember RefMemberInit = { arr[0] };
+  return RefMemberInit;
+}
+
+struct BitFieldMember {
+  int a : 1;
+  int b : 3;
+};
+
+BitFieldMember initBitFieldMember() {
+  // CHECK: {{.*}}BitFieldMemberInit{{.*}} = {{.*}}constant{{.*}}i8 5
+  BitFieldMember BitFieldMemberInit = { 1, 2 };
+  return BitFieldMemberInit;
+}

test/CodeGenCXX/member-init-anon-union.cpp

 // CHECK-LABEL: define internal void @__cxx_global_var_init
 // CHECK-NOT: }
 // CHECK: call {{.*}}@"[[CONSTRUCT_GLOBAL:.*]]C1Ev"
 
 
 int g() {
   union {
     int a;
-    int b = 81;
+    int b = make_a();
   };
   // CHECK-LABEL: define {{.*}}_Z1gv
   // CHECK-NOT: }
   // CHECK: call {{.*}}@"[[CONSTRUCT_LOCAL:.*]]C1Ev"
   return b;
 }
 
 struct A {

 B b2(0);
 
 // CHECK: define {{.*}}@"[[CONSTRUCT_GLOBAL]]C2Ev"
 // CHECK-NOT: }
 // CHECK: call {{.*}}@_Z6make_a
 
 // CHECK: define {{.*}}@"[[CONSTRUCT_LOCAL]]C2Ev"
 // CHECK-NOT: }
-// CHECK: store i32 81
+// CHECK: call {{.*}}@_Z6make_a
+// CHECK: store i32
 
 // CHECK-LABEL: define {{.*}} @_ZN1BC2Ev(
 // CHECK: call void @_ZN1AC1Ev(
 // CHECK: store i32 123,
 // CHECK: }
 
 // CHECK-LABEL: define {{.*}} @_ZN1BC2Ei(
 // CHECK-NOT: call void @_ZN1AC1Ev(
 // CHECK-NOT: store i32 123,
 // CHECK: store i32 %
 // CHECK-NOT: call void @_ZN1AC1Ev(
 // CHECK-NOT: store i32 123,
 // CHECK: }

test/CodeGenCXX/microsoft-interface.cpp

 // RUN: %clang_cc1 -std=c++11 -fms-extensions -Wno-microsoft -triple=i386-pc-windows-gnu -emit-llvm %s -o - | FileCheck %s
 
 __interface I {
   int test() {
     return 1;
   }
 };
 
 struct S : I {
+  mutable int i; // Prevent constant folding.
   virtual int test() override {
     return I::test();
   }
 };
 
 int fn() {
   S s;
   return s.test();