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...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

126 lines
4.1 KiB
C++
Raw Normal View History

Revert "Don't use comdats for initializers on platforms that don't support it" On further investigation, COMDATs should work with .ctors, and the issue I was hitting probably reproduces with .init_array. This reverts commit r218287. llvm-svn: 218313
2014-09-24 00:20:01 +08:00
// RUN: %clang_cc1 %s -std=c++1y -triple=x86_64-pc-linux -emit-llvm -o - | FileCheck --check-prefix=ELF --check-prefix=ALL %s
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// RUN: %clang_cc1 %s -std=c++1y -triple=x86_64-apple-darwin -emit-llvm -o - | FileCheck --check-prefix=MACHO --check-prefix=ALL %s
// ALL: ; 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
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALLK-NOT: @_ZN1AIcE1aE
Don't emit explicit specializations of static member variable declarations. llvm-svn: 90624
2009-12-05 07:50:01 +08:00
template<> int A<char>::a;
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// ALL: @_ZN1AIbE1aE = global i32 10
Don't emit explicit specializations of static member variable declarations. llvm-svn: 90624
2009-12-05 07:50:01 +08:00
template<> int A<bool>::a = 10;
Don't use a global_ctors comdat for globals that aren't externally visible In particular, if you have two identical templates in different TUs in anonymous namespaces, we would use the same global_ctors comdat key for both. As a result, only one would be run. llvm-svn: 219806
2014-10-16 00:38:00 +08:00
// ALL: @llvm.global_ctors = appending global [8 x { i32, void ()*, i8* }]
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ELF: [{ i32, void ()*, i8* } { i32 65535, void ()* @[[unordered1:[^,]*]], i8* bitcast (i32* @_ZN1AIsE1aE to i8*) },
// MACHO: [{ i32, void ()*, i8* } { i32 65535, void ()* @[[unordered1:[^,]*]], i8* null },
// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered2:[^,]*]], i8* bitcast (i16* @_Z1xIsE to i8*) },
// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered2:[^,]*]], i8* null },
// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered3:[^,]*]], i8* bitcast (i32* @_ZN2ns1aIiE1iE to i8*) },
// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered3:[^,]*]], i8* null },
// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered4:[^,]*]], i8* bitcast (i32* @_ZN2ns1b1iIiEE to i8*) },
// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered4:[^,]*]], i8* null },
// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered5:[^,]*]], i8* bitcast (i32* @_ZN1AIvE1aE to i8*) },
// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered5:[^,]*]], i8* null },
// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered6:[^,]*]], i8* @_Z1xIcE },
// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered6:[^,]*]], i8* null },
Don't use a global_ctors comdat for globals that aren't externally visible In particular, if you have two identical templates in different TUs in anonymous namespaces, we would use the same global_ctors comdat key for both. As a result, only one would be run. llvm-svn: 219806
2014-10-16 00:38:00 +08:00
// ALL: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered7:[^,]*]], i8* null },
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_static_member_variable_explicit_specialization.cpp, i8* null }]
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
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
Include translation unit filename in global ctor symbol names. This makes it easier to see where a global ctor comes from, and it also makes ASan's init order analyzer output easier to understand. gcc does this too, but only in -fPIC mode for some reason. Don't do this for constructors with explicit init priority. Also prepend "sub_" before the 'I', that way regular constructors stay lexicographically after symbols with init priority (because ord('s') > ord('I')). gold seems to ignore the name of constructor symbols, and ld only looks at the symbol if it includes an init priority, which this patch doesn't change. Before: __GLOBAL_I_a Now: __GLOBAL_sub_I_myfile.cc llvm-svn: 208128
2014-05-07 04:32:45 +08:00
// An explicit specialization is ordered, and goes in __GLOBAL_sub_I_static_member_variable_explicit_specialization.cpp.
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
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>;
}
Don't use a global_ctors comdat for globals that aren't externally visible In particular, if you have two identical templates in different TUs in anonymous namespaces, we would use the same global_ctors comdat key for both. As a result, only one would be run. llvm-svn: 219806
2014-10-16 00:38:00 +08:00
namespace {
template<typename T> struct Internal { static int a; };
template<typename T> int Internal<T>::a = foo();
}
int *use_internal_a = &Internal<int>::a;
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered1]](
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_ZN1AIsE1aE
// ALL: ret
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered2]](
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_Z1xIsE
// ALL: ret
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered3]](
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_ZN2ns1aIiE1iE
// ALL: ret
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered4]](
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_ZN2ns1b1iIiEE
// ALL: ret
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered5]](
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_ZN1AIvE1aE
// ALL: ret
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered6]](
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_Z1xIcE
// ALL: ret
Make this test a bit stricter. The first function is named __cxx_global_var_init, which is a substring of the following functions @__cxx_global_var_init(1,2,3,etc). llvm-svn: 225191
2015-01-06 02:48:18 +08:00
// ALL: define internal void @[[unordered7]](
Don't use a global_ctors comdat for globals that aren't externally visible In particular, if you have two identical templates in different TUs in anonymous namespaces, we would use the same global_ctors comdat key for both. As a result, only one would be run. llvm-svn: 219806
2014-10-16 00:38:00 +08:00
// ALL: call i32 @foo()
// ALL: store {{.*}} @_ZN12_GLOBAL__N_18InternalIiE1aE
// ALL: ret
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: define internal void @_GLOBAL__sub_I_static_member_variable_explicit_specialization.cpp()
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
// We call unique stubs for every ordered dynamic initializer in the TU.
Don't use the third field of llvm.global_ctors for MachO. The field is defined as: If the third field is present, non-null, and points to a global variable or function, the initializer function will only run if the associated data from the current module is not discarded. And without COMDATs we can't implement that. llvm-svn: 218097
2014-09-19 09:54:22 +08:00
// ALL: call
// ALL: call
// ALL: call
// ALL: call
// ALL: call
// ALL: call
// ALL: call
// ALL: call
// ALL-NOT: call
// ALL: ret