maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/static-member-variable-expl...

97 lines
2.7 KiB
C++
Raw Normal View History

Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
// RUN: %clang_cc1 %s -std=c++1y -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
Don't emit explicit specializations of static member variable declarations. llvm-svn: 90624
2009-12-05 07:50:01 +08:00
// CHECK: ; ModuleID
Add a separate llvm.global_ctors entry for linkonce_odr data initializers Summary: These typically come from static data members of class template specializations. This accomplishes two things: 1. May expose GlobalOpt optimizations for Itanium C++ ABI code. 2. Works toward fixing double initialization in the Microsoft C++ ABI. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1475 llvm-svn: 189051
2013-08-23 04:07:45 +08:00
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
extern "C" int foo();
template<typename T> struct A { static int a; };
template<typename T> int A<T>::a = foo();
Don't emit explicit specializations of static member variable declarations. llvm-svn: 90624
2009-12-05 07:50:01 +08:00
// CHECK-NOT: @_ZN1AIcE1aE
template<> int A<char>::a;
// CHECK: @_ZN1AIbE1aE = global i32 10
template<> int A<bool>::a = 10;
Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
// CHECK: @llvm.global_ctors = appending global [7 x { i32, void ()* }]
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
// 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:[^ ]*]] },
Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
// CHECK: { i32, void ()* } { i32 65535, void ()* @[[unordered5:[^ ]*]] },
// CHECK: { i32, void ()* } { i32 65535, void ()* @[[unordered6:[^ ]*]] },
Add a separate llvm.global_ctors entry for linkonce_odr data initializers Summary: These typically come from static data members of class template specializations. This accomplishes two things: 1. May expose GlobalOpt optimizations for Itanium C++ ABI code. 2. Works toward fixing double initialization in the Microsoft C++ ABI. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1475 llvm-svn: 189051
2013-08-23 04:07:45 +08:00
// CHECK: { i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }]
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
template int A<short>::a; // Unordered
int b = foo();
int c = foo();
int d = A<void>::a; // Unordered
Add a separate llvm.global_ctors entry for linkonce_odr data initializers Summary: These typically come from static data members of class template specializations. This accomplishes two things: 1. May expose GlobalOpt optimizations for Itanium C++ ABI code. 2. Works toward fixing double initialization in the Microsoft C++ ABI. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1475 llvm-svn: 189051
2013-08-23 04:07:45 +08:00
// An explicit specialization is ordered, and goes in __GLOBAL_I_a.
template<> struct A<int> { static int a; };
int A<int>::a = foo();
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
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
Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
namespace ns {
template <typename T> struct a {
static int i;
};
template<typename T> int a<T>::i = foo();
template struct a<int>;
struct b {
template <typename T> static T i;
};
Implement restriction that a partial specialization must actually specialize something, for variable templates. llvm-svn: 191278
2013-09-24 12:49:23 +08:00
template<typename T> T b::i = foo();
Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
template int b::i<int>;
}
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
// CHECK: define internal void @[[unordered1]]
Add a separate llvm.global_ctors entry for linkonce_odr data initializers Summary: These typically come from static data members of class template specializations. This accomplishes two things: 1. May expose GlobalOpt optimizations for Itanium C++ ABI code. 2. Works toward fixing double initialization in the Microsoft C++ ABI. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1475 llvm-svn: 189051
2013-08-23 04:07:45 +08:00
// CHECK: call i32 @foo()
// CHECK: store {{.*}} @_ZN1AIsE1aE
// CHECK: ret
Don't emit explicit specializations of static member variable declarations. llvm-svn: 90624
2009-12-05 07:50:01 +08:00
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
// CHECK: define internal void @[[unordered2]]
// CHECK: call i32 @foo()
// CHECK: store {{.*}} @_Z1xIsE
// CHECK: ret
// CHECK: define internal void @[[unordered3]]
// CHECK: call i32 @foo()
Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
// CHECK: store {{.*}} @_ZN2ns1aIiE1iE
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
// CHECK: ret
// CHECK: define internal void @[[unordered4]]
// CHECK: call i32 @foo()
Do not emit duplicate global initializers for template static data members inside namespaces A quirk of AST representation leads to class template static data member definitions being visited twice during Clang IRGen resulting in duplicate (benign) initializers. Discovered while investigating a possibly-related debug info bug tickled by the duplicate emission of these members & their associated debug info. With thanks to Richard Smith for help investigating, understanding, and helping with the fix. llvm-svn: 189996
2013-09-05 05:07:37 +08:00
// CHECK: store {{.*}} @_ZN2ns1b1iIiEE
// CHECK: ret
// CHECK: define internal void @[[unordered5]]
// CHECK: call i32 @foo()
// CHECK: store {{.*}} @_ZN1AIvE1aE
// CHECK: ret
// CHECK: define internal void @[[unordered6]]
// CHECK: call i32 @foo()
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
// CHECK: store {{.*}} @_Z1xIcE
// CHECK: ret
Add a separate llvm.global_ctors entry for linkonce_odr data initializers Summary: These typically come from static data members of class template specializations. This accomplishes two things: 1. May expose GlobalOpt optimizations for Itanium C++ ABI code. 2. Works toward fixing double initialization in the Microsoft C++ ABI. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1475 llvm-svn: 189051
2013-08-23 04:07:45 +08:00
// 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
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. llvm-svn: 189898
2013-09-04 08:54:24 +08:00
// CHECK: call
// CHECK: call
// CHECK: call
// CHECK: call
// CHECK: call
Add a separate llvm.global_ctors entry for linkonce_odr data initializers Summary: These typically come from static data members of class template specializations. This accomplishes two things: 1. May expose GlobalOpt optimizations for Itanium C++ ABI code. 2. Works toward fixing double initialization in the Microsoft C++ ABI. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1475 llvm-svn: 189051
2013-08-23 04:07:45 +08:00
// CHECK-NOT: call
// CHECK: ret