Order initializers of static data members of explicit specializations

I tried to implement this properly in r189051, but I didn't have enough
test coverage.  Richard kindly provided more test cases than I could
possibly imagine and now we should have the correct condition.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@189898 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/CGDeclCXX.cpp b/lib/CodeGen/CGDeclCXX.cpp
index bf5e37733b4fc7f52619f1515efa197318dee3d6..868820a08135147dce6b4db30bbd39beaf4aade0 100644 (file)
--- a/lib/CodeGen/CGDeclCXX.cpp
+++ b/lib/CodeGen/CGDeclCXX.cpp
@@ -276,12 +276,13 @@ CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
     OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size());
     PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
     DelayedCXXInitPosition.erase(D);
-  } else if (D->getInstantiatedFromStaticDataMember()) {
+  } else if (D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
+             D->getTemplateSpecializationKind() != TSK_Undeclared) {
     // C++ [basic.start.init]p2:
-    //   Defnitions of explicitly specialized class template static data members
-    //   have ordered initialization. Other class template static data members
-    //   (i.e., implicitly or explicitly instantiated specializations) have
-    //   unordered initialization.
+    //   Definitions of explicitly specialized class template static data
+    //   members have ordered initialization. Other class template static data
+    //   members (i.e., implicitly or explicitly instantiated specializations)
+    //   have unordered initialization.
     //
     // As a consequence, we can put them into their own llvm.global_ctors entry.
     // This should allow GlobalOpt to fire more often, and allow us to implement

diff --git a/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp b/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp
index e499efd2d037995d75dbd0490019c0c818c9fb52..a069e8bd7242b9c7b97fd8351a6c0d01caf04ee0 100644 (file)
--- a/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp
+++ b/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp
@@ -1,7 +1,10 @@
 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 // CHECK: ; ModuleID
 
-template<typename> struct A { static int a; };
+extern "C" int foo();
+
+template<typename T> struct A { static int a; };
+template<typename T> int A<T>::a = foo();
 
 // CHECK-NOT: @_ZN1AIcE1aE
 template<> int A<char>::a;
@@ -9,28 +12,60 @@ template<> int A<char>::a;
 // CHECK: @_ZN1AIbE1aE = global i32 10
 template<> int A<bool>::a = 10;
 
-// CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()* }]
-// CHECK: [{ i32, void ()* } { i32 65535, void ()* @__cxx_global_var_init },
+// CHECK: @llvm.global_ctors = appending global [5 x { i32, void ()* }]
+// CHECK: [{ i32, void ()* } { i32 65535, void ()* @[[unordered1:[^ ]*]] },
+// CHECK:  { i32, void ()* } { i32 65535, void ()* @[[unordered2:[^ ]*]] },
+// CHECK:  { i32, void ()* } { i32 65535, void ()* @[[unordered3:[^ ]*]] },
+// CHECK:  { i32, void ()* } { i32 65535, void ()* @[[unordered4:[^ ]*]] },
 // CHECK:  { i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }]
 
-extern "C" int foo();
-template<> int A<short>::a = foo();  // Separate global_ctor entry
-int b = foo();  // Goes in _GLOBAL__I_a
-int c = foo();  // Goes in _GLOBAL__I_a
+template int A<short>::a;  // Unordered
+int b = foo();
+int c = foo();
+int d = A<void>::a; // Unordered
 
 // An explicit specialization is ordered, and goes in __GLOBAL_I_a.
 template<> struct A<int> { static int a; };
 int A<int>::a = foo();
 
-// CHECK: define internal void @__cxx_global_var_init()
+template<typename T> struct S { static T x; static T y; };
+template<> int S<int>::x = foo();
+template<> int S<int>::y = S<int>::x;
+
+template<typename T> T x = foo();
+template short x<short>;  // Unordered
+template<> int x<int> = foo();
+int e = x<char>; // Unordered
+
+// CHECK: define internal void @[[unordered1]]
 // CHECK: call i32 @foo()
 // CHECK: store {{.*}} @_ZN1AIsE1aE
 // CHECK: ret
 
+// CHECK: define internal void @[[unordered2]]
+// CHECK: call i32 @foo()
+// CHECK: store {{.*}} @_Z1xIsE
+// CHECK: ret
+
+// CHECK: define internal void @[[unordered3]]
+// CHECK: call i32 @foo()
+// CHECK: store {{.*}} @_ZN1AIvE1aE
+// CHECK: ret
+
+// CHECK: define internal void @[[unordered4]]
+// CHECK: call i32 @foo()
+// CHECK: store {{.*}} @_Z1xIcE
+// CHECK: ret
+
 // CHECK: define internal void @_GLOBAL__I_a()
 //   We call unique stubs for every ordered dynamic initializer in the TU.
 // CHECK: call
 // CHECK: call
 // CHECK: call
+// CHECK: call
+// CHECK: call
+// CHECK: call
+// CHECK: call
+// CHECK: call
 // CHECK-NOT: call
 // CHECK: ret