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/cxx11-thread-local.cpp

343 lines
12 KiB
C++
Raw Normal View History

[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
Add -femulated-tls flag to select the emulated TLS model. This will be used for old targets like Android that do not support ELF TLS models. Differential Revision: http://reviews.llvm.org/D10524 llvm-svn: 243441
2015-07-29 00:27:56 +08:00
// RUN: %clang_cc1 -std=c++11 -femulated-tls -emit-llvm %s -o - \
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// RUN: -triple x86_64-linux-gnu 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-apple-darwin12 | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
int f();
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
int g();
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-DAG: @a = thread_local global i32 0
// DARWIN-DAG: @a = internal thread_local global i32 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
thread_local int a = f();
extern thread_local int b;
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @c = global i32 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
int c = b;
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @_ZL1d = internal thread_local global i32 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
static thread_local int d = g();
struct U { static thread_local int m; };
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-DAG: @_ZN1U1mE = thread_local global i32 0
// DARWIN-DAG: @_ZN1U1mE = internal thread_local global i32 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
thread_local int U::m = f();
Fix use-after-free when a C++ thread_local variable gets replaced (because its type changes when the initializer is attached). Don't hold onto the GlobalVariable*; recompute it from the VarDecl* instead. llvm-svn: 254359
2015-12-01 09:10:48 +08:00
namespace MismatchedInitType {
// Check that we don't crash here when we're forced to create a new global
// variable (with a different type) when we add the initializer.
union U {
int a;
float f;
constexpr U() : f(0.0) {}
};
static thread_local U u;
void *p = &u;
}
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
template<typename T> struct V { static thread_local int m; };
template<typename T> thread_local int V<T>::m = g();
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
template<typename T> struct W { static thread_local int m; };
template<typename T> thread_local int W<T>::m = 123;
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
struct Dtor { ~Dtor(); };
template<typename T> struct X { static thread_local Dtor m; };
template<typename T> thread_local Dtor X<T>::m;
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @e = global
void *e = V<int>::m + W<int>::m + &X<int>::m;
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
template thread_local int V<float>::m;
template thread_local int W<float>::m;
template thread_local Dtor X<float>::m;
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
extern template thread_local int V<char>::m;
extern template thread_local int W<char>::m;
extern template thread_local Dtor X<char>::m;
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
void *e2 = V<char>::m + W<char>::m + &X<char>::m;
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @_ZN1VIiE1mE = linkonce_odr thread_local global i32 0
// CHECK-DAG: @_ZN1WIiE1mE = linkonce_odr thread_local global i32 123
// CHECK-DAG: @_ZN1XIiE1mE = linkonce_odr thread_local global {{.*}}
// CHECK-DAG: @_ZN1VIfE1mE = weak_odr thread_local global i32 0
// CHECK-DAG: @_ZN1WIfE1mE = weak_odr thread_local global i32 123
// CHECK-DAG: @_ZN1XIfE1mE = weak_odr thread_local global {{.*}}
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @_ZZ1fvE1n = internal thread_local global i32 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @_ZGVZ1fvE1n = internal thread_local global i8 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @_ZZ8tls_dtorvE1s = internal thread_local global
// CHECK-DAG: @_ZGVZ8tls_dtorvE1s = internal thread_local global i8 0
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-DAG: @_ZZ8tls_dtorvE1t = internal thread_local global
// CHECK-DAG: @_ZGVZ8tls_dtorvE1t = internal thread_local global i8 0
// CHECK-DAG: @_ZZ8tls_dtorvE1u = internal thread_local global
// CHECK-DAG: @_ZGVZ8tls_dtorvE1u = internal thread_local global i8 0
// CHECK-DAG: @_ZGRZ8tls_dtorvE1u_ = internal thread_local global
// CHECK-DAG: @_ZGVN1VIiE1mE = linkonce_odr thread_local global i64 0
// CHECK-DAG: @__tls_guard = internal thread_local global i8 0
// CHECK-DAG: @llvm.global_ctors = appending global {{.*}} @[[GLOBAL_INIT:[^ ]*]]
// LINUX-DAG: @_ZTH1a = alias void (), void ()* @__tls_init
// DARWIN-DAG: @_ZTH1a = internal alias void (), void ()* @__tls_init
// CHECK-DAG: @_ZTHL1d = internal alias void (), void ()* @__tls_init
// LINUX-DAG: @_ZTHN1U1mE = alias void (), void ()* @__tls_init
// DARWIN-DAG: @_ZTHN1U1mE = internal alias void (), void ()* @__tls_init
// CHECK-DAG: @_ZTHN1VIiE1mE = linkonce_odr alias void (), void ()* @[[V_M_INIT:[^, ]*]]
// CHECK-NOT: @_ZTHN1WIiE1mE =
// CHECK-DAG: @_ZTHN1XIiE1mE = linkonce_odr alias void (), void ()* @[[X_M_INIT:[^, ]*]]
// CHECK-DAG: @_ZTHN1VIfE1mE = weak_odr alias void (), void ()* @[[VF_M_INIT:[^, ]*]]
// CHECK-NOT: @_ZTHN1WIfE1mE =
// CHECK-DAG: @_ZTHN1XIfE1mE = weak_odr alias void (), void ()* @[[XF_M_INIT:[^, ]*]]
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// Individual variable initialization functions:
// CHECK: define {{.*}} @[[A_INIT:.*]]()
// CHECK: call i32 @_Z1fv()
// CHECK-NEXT: store i32 {{.*}}, i32* @a, align 4
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define i32 @_Z1fv()
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
int f() {
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: %[[GUARD:.*]] = load i8, i8* @_ZGVZ1fvE1n, align 1
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
// CHECK: %[[NEED_INIT:.*]] = icmp eq i8 %[[GUARD]], 0
// CHECK: br i1 %[[NEED_INIT]]
// CHECK: %[[CALL:.*]] = call i32 @_Z1gv()
// CHECK: store i32 %[[CALL]], i32* @_ZZ1fvE1n, align 4
// CHECK: store i8 1, i8* @_ZGVZ1fvE1n
// CHECK: br label
static thread_local int n = g();
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* @_ZZ1fvE1n, align 4
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
return n;
}
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: define {{.*}} @[[C_INIT:.*]]()
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// LINUX: call i32* @_ZTW1b()
// DARWIN: call cxx_fast_tlscc i32* @_ZTW1b()
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: load i32, i32* %{{.*}}, align 4
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK-NEXT: store i32 %{{.*}}, i32* @c, align 4
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX-LABEL: define weak_odr hidden i32* @_ZTW1b()
// LINUX: br i1 icmp ne (void ()* @_ZTH1b, void ()* null),
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// not null:
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX: call void @_ZTH1b()
// LINUX: br label
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// finally:
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX: ret i32* @b
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// DARWIN-LABEL: declare cxx_fast_tlscc i32* @_ZTW1b()
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// There is no definition of the thread wrapper on Darwin for external TLV.
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: define {{.*}} @[[D_INIT:.*]]()
// CHECK: call i32 @_Z1gv()
// CHECK-NEXT: store i32 %{{.*}}, i32* @_ZL1d, align 4
// CHECK: define {{.*}} @[[U_M_INIT:.*]]()
// CHECK: call i32 @_Z1fv()
// CHECK-NEXT: store i32 %{{.*}}, i32* @_ZN1U1mE, align 4
// CHECK: define {{.*}} @[[E_INIT:.*]]()
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// LINUX: call i32* @_ZTWN1VIiE1mE()
// DARWIN: call cxx_fast_tlscc i32* @_ZTWN1VIiE1mE()
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: load i32, i32* %{{.*}}, align 4
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX: call {{.*}}* @_ZTWN1XIiE1mE()
// DARWIN: call cxx_fast_tlscc {{.*}}* @_ZTWN1XIiE1mE()
// CHECK: store {{.*}} @e
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// LINUX-LABEL: define weak_odr hidden i32* @_ZTWN1VIiE1mE()
// DARWIN-LABEL: define weak_odr hidden cxx_fast_tlscc i32* @_ZTWN1VIiE1mE()
[TLS on Darwin] use CXX_FAST_TLS calling convention for tls_init. This makes sure we don't generate a lot of code to spill/reload CSRs when calling tls_init from the access functions. This helps performance when tls_init is not inlined into the access functions. llvm-svn: 263854
2016-03-19 07:35:21 +08:00
// LINUX: call void @_ZTHN1VIiE1mE()
// DARWIN: call cxx_fast_tlscc void @_ZTHN1VIiE1mE()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: ret i32* @_ZN1VIiE1mE
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-LABEL: define weak_odr hidden i32* @_ZTWN1WIiE1mE()
// DARWIN-LABEL: define weak_odr hidden cxx_fast_tlscc i32* @_ZTWN1WIiE1mE()
// CHECK-NOT: call
// CHECK: ret i32* @_ZN1WIiE1mE
// LINUX-LABEL: define weak_odr hidden {{.*}}* @_ZTWN1XIiE1mE()
// DARWIN-LABEL: define weak_odr hidden cxx_fast_tlscc {{.*}}* @_ZTWN1XIiE1mE()
// LINUX: call void @_ZTHN1XIiE1mE()
// DARWIN: call cxx_fast_tlscc void @_ZTHN1XIiE1mE()
// CHECK: ret {{.*}}* @_ZN1XIiE1mE
[CodeGen][Darwin] Set the calling-convention of thread-local variable initialization functions to 'cxx_fast_tlscc'. This fixes a bug where instructions calling initialization functions for thread-local static members of c++ template classes were using calling convention 'cxx_fast_tlscc' while the called functions weren't annotated with the calling convention. rdar://problem/40447463 Differential Revision: https://reviews.llvm.org/D47354 llvm-svn: 333447
2018-05-30 02:28:49 +08:00
// LINUX: define internal void @[[VF_M_INIT]]()
// DARWIN: define internal cxx_fast_tlscc void @[[VF_M_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-SAME: comdat($_ZN1VIfE1mE)
// DARWIN-NOT: comdat
// CHECK: load i8, i8* bitcast (i64* @_ZGVN1VIfE1mE to i8*)
// CHECK: %[[VF_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
// CHECK: br i1 %[[VF_M_INITIALIZED]],
// need init:
// CHECK: call i32 @_Z1gv()
// CHECK: store i32 %{{.*}}, i32* @_ZN1VIfE1mE, align 4
// CHECK: store i64 1, i64* @_ZGVN1VIfE1mE
// CHECK: br label
[CodeGen][Darwin] Set the calling-convention of thread-local variable initialization functions to 'cxx_fast_tlscc'. This fixes a bug where instructions calling initialization functions for thread-local static members of c++ template classes were using calling convention 'cxx_fast_tlscc' while the called functions weren't annotated with the calling convention. rdar://problem/40447463 Differential Revision: https://reviews.llvm.org/D47354 llvm-svn: 333447
2018-05-30 02:28:49 +08:00
// LINUX: define internal void @[[XF_M_INIT]]()
// DARWIN: define internal cxx_fast_tlscc void @[[XF_M_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-SAME: comdat($_ZN1XIfE1mE)
// DARWIN-NOT: comdat
// CHECK: load i8, i8* bitcast (i64* @_ZGVN1XIfE1mE to i8*)
// CHECK: %[[XF_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
// CHECK: br i1 %[[XF_M_INITIALIZED]],
// need init:
// LINUX: call {{.*}}__cxa_thread_atexit
// DARWIN: call {{.*}}_tlv_atexit
// CHECK: store i64 1, i64* @_ZGVN1XIfE1mE
// CHECK: br label
// LINUX: declare i32 @__cxa_thread_atexit(void (i8*)*, i8*, i8*)
// DARWIN: declare i32 @_tlv_atexit(void (i8*)*, i8*, i8*)
// DARWIN: declare cxx_fast_tlscc i32* @_ZTWN1VIcE1mE()
// LINUX: define weak_odr hidden i32* @_ZTWN1VIcE1mE()
// LINUX-NOT: comdat
// LINUX: br i1 icmp ne (void ()* @_ZTHN1VIcE1mE,
// LINUX: call void @_ZTHN1VIcE1mE()
// LINUX: ret i32* @_ZN1VIcE1mE
// DARWIN: declare cxx_fast_tlscc i32* @_ZTWN1WIcE1mE()
// LINUX: define weak_odr hidden i32* @_ZTWN1WIcE1mE()
// LINUX-NOT: comdat
// LINUX: br i1 icmp ne (void ()* @_ZTHN1WIcE1mE,
// LINUX: call void @_ZTHN1WIcE1mE()
// LINUX: ret i32* @_ZN1WIcE1mE
// DARWIN: declare cxx_fast_tlscc {{.*}}* @_ZTWN1XIcE1mE()
// LINUX: define weak_odr hidden {{.*}}* @_ZTWN1XIcE1mE()
// LINUX-NOT: comdat
// LINUX: br i1 icmp ne (void ()* @_ZTHN1XIcE1mE,
// LINUX: call void @_ZTHN1XIcE1mE()
// LINUX: ret {{.*}}* @_ZN1XIcE1mE
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
struct S { S(); ~S(); };
struct T { ~T(); };
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define void @_Z8tls_dtorv()
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
void tls_dtor() {
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i8, i8* @_ZGVZ8tls_dtorvE1s
[CodeGenCXX] Treat 'this' as noalias in constructors This is currently a clang extension and a resolution of the defect report in the C++ Standard. Differential Revision: https://reviews.llvm.org/D46441 llvm-svn: 344150
2018-10-11 00:14:51 +08:00
// CHECK: call void @_ZN1SC1Ev(%struct.S* noalias @_ZZ8tls_dtorvE1s)
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX: call i32 @__cxa_thread_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZZ8tls_dtorvE1s{{.*}} @__dso_handle
// DARWIN: call i32 @_tlv_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZZ8tls_dtorvE1s{{.*}} @__dso_handle
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
// CHECK: store i8 1, i8* @_ZGVZ8tls_dtorvE1s
static thread_local S s;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i8, i8* @_ZGVZ8tls_dtorvE1t
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
// CHECK-NOT: _ZN1T
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX: call i32 @__cxa_thread_atexit({{.*}}@_ZN1TD1Ev {{.*}}@_ZZ8tls_dtorvE1t{{.*}} @__dso_handle
// DARWIN: call i32 @_tlv_atexit({{.*}}@_ZN1TD1Ev {{.*}}@_ZZ8tls_dtorvE1t{{.*}} @__dso_handle
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
// CHECK: store i8 1, i8* @_ZGVZ8tls_dtorvE1t
static thread_local T t;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i8, i8* @_ZGVZ8tls_dtorvE1u
[CodeGenCXX] Treat 'this' as noalias in constructors This is currently a clang extension and a resolution of the defect report in the C++ Standard. Differential Revision: https://reviews.llvm.org/D46441 llvm-svn: 344150
2018-10-11 00:14:51 +08:00
// CHECK: call void @_ZN1SC1Ev(%struct.S* noalias @_ZGRZ8tls_dtorvE1u_)
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX: call i32 @__cxa_thread_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZGRZ8tls_dtorvE1u_{{.*}} @__dso_handle
// DARWIN: call i32 @_tlv_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZGRZ8tls_dtorvE1u_{{.*}} @__dso_handle
CodeGen support for function-local static thread_local variables with non-constant constructors or non-trivial destructors. Plus bugfixes for thread_local references bound to temporaries (the temporaries themselves are lifetime-extended to become thread_local), and the corresponding case for std::initializer_list. llvm-svn: 179496
2013-04-15 07:01:42 +08:00
// CHECK: store i8 1, i8* @_ZGVZ8tls_dtorvE1u
static thread_local const S &u = S();
}
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
Add testcase omitted from r181998. llvm-svn: 182043
2013-05-17 03:52:25 +08:00
// CHECK: define {{.*}} @_Z7PR15991v(
int PR15991() {
thread_local int n;
auto l = [] { return n; };
return l();
}
PR19254: If a thread_local data member of a class is accessed via member access syntax, don't forget to run its initializer. llvm-svn: 204869
2014-03-27 06:48:22 +08:00
struct PR19254 {
static thread_local int n;
int f();
};
// CHECK: define {{.*}} @_ZN7PR192541fEv(
int PR19254::f() {
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX: call void @_ZTHN7PR192541nE(
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// DARWIN: call cxx_fast_tlscc i32* @_ZTWN7PR192541nE(
PR19254: If a thread_local data member of a class is accessed via member access syntax, don't forget to run its initializer. llvm-svn: 204869
2014-03-27 06:48:22 +08:00
return this->n;
}
CodeGen: Assign linkage to thread-wrappers correctly We would sometimes incorrectly give a thread-wrapper external linkage instead of internal linkage if we had only CodeGen'd it's declaration, not it's definition. This fixes PR19655. llvm-svn: 207988
2014-05-06 02:54:23 +08:00
namespace {
thread_local int anon_i{1};
}
void set_anon_i() {
anon_i = 2;
}
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// LINUX-LABEL: define internal i32* @_ZTWN12_GLOBAL__N_16anon_iE()
// DARWIN-LABEL: define internal cxx_fast_tlscc i32* @_ZTWN12_GLOBAL__N_16anon_iE()
CodeGen: Assign linkage to thread-wrappers correctly We would sometimes incorrectly give a thread-wrapper external linkage instead of internal linkage if we had only CodeGen'd it's declaration, not it's definition. This fixes PR19655. llvm-svn: 207988
2014-05-06 02:54:23 +08:00
[CodeGen][Darwin] Set the calling-convention of thread-local variable initialization functions to 'cxx_fast_tlscc'. This fixes a bug where instructions calling initialization functions for thread-local static members of c++ template classes were using calling convention 'cxx_fast_tlscc' while the called functions weren't annotated with the calling convention. rdar://problem/40447463 Differential Revision: https://reviews.llvm.org/D47354 llvm-svn: 333447
2018-05-30 02:28:49 +08:00
// LINUX: define internal void @[[V_M_INIT]]()
// DARWIN: define internal cxx_fast_tlscc void @[[V_M_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-SAME: comdat($_ZN1VIiE1mE)
// DARWIN-NOT: comdat
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i8, i8* bitcast (i64* @_ZGVN1VIiE1mE to i8*)
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: %[[V_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
// CHECK: br i1 %[[V_M_INITIALIZED]],
// need init:
// CHECK: call i32 @_Z1gv()
// CHECK: store i32 %{{.*}}, i32* @_ZN1VIiE1mE, align 4
// CHECK: store i64 1, i64* @_ZGVN1VIiE1mE
// CHECK: br label
[CodeGen][Darwin] Set the calling-convention of thread-local variable initialization functions to 'cxx_fast_tlscc'. This fixes a bug where instructions calling initialization functions for thread-local static members of c++ template classes were using calling convention 'cxx_fast_tlscc' while the called functions weren't annotated with the calling convention. rdar://problem/40447463 Differential Revision: https://reviews.llvm.org/D47354 llvm-svn: 333447
2018-05-30 02:28:49 +08:00
// LINUX: define internal void @[[X_M_INIT]]()
// DARWIN: define internal cxx_fast_tlscc void @[[X_M_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// LINUX-SAME: comdat($_ZN1XIiE1mE)
// DARWIN-NOT: comdat
// CHECK: load i8, i8* bitcast (i64* @_ZGVN1XIiE1mE to i8*)
// CHECK: %[[X_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
// CHECK: br i1 %[[X_M_INITIALIZED]],
// need init:
// LINUX: call {{.*}}__cxa_thread_atexit
// DARWIN: call {{.*}}_tlv_atexit
// CHECK: store i64 1, i64* @_ZGVN1XIiE1mE
// CHECK: br label
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: define {{.*}}@[[GLOBAL_INIT:.*]]()
// CHECK: call void @[[C_INIT]]()
// CHECK: call void @[[E_INIT]]()
// CHECK: define {{.*}}@__tls_init()
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i8, i8* @__tls_guard
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: %[[NEED_TLS_INIT:.*]] = icmp eq i8 %{{.*}}, 0
// CHECK: br i1 %[[NEED_TLS_INIT]],
// init:
[TLS] move setting tls_guard in tls_init. We used to emit the store prior to branch in the entry block. To make it more efficient, this commit moves it to the init block. We still mark as initialized before initializing anything else. llvm-svn: 252777
2015-11-12 03:19:26 +08:00
// CHECK: store i8 1, i8* @__tls_guard
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-NOT: call void @[[V_M_INIT]]()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: call void @[[A_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-NOT: call void @[[V_M_INIT]]()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: call void @[[D_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-NOT: call void @[[V_M_INIT]]()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: call void @[[U_M_INIT]]()
Improve handling of instantiated thread_local variables in Itanium C++ ABI. * Do not initialize these variables when initializing the rest of the thread_locals in the TU; they have unordered initialization so they can be initialized by themselves. This fixes a rejects-valid bug: we would make the per-variable initializer function internal, but put it in a comdat keyed off the variable, resulting in link errors when the comdat is selected from a different TU (as the per TU TLS init function tries to call an init function that does not exist). * On Darwin, when we decide that we're not going to emit a thread wrapper function at all, demote its linkage to External. Fixes a verifier failure on explicit instantiation of a thread_local variable on Darwin. llvm-svn: 291865
2017-01-13 08:43:31 +08:00
// CHECK-NOT: call void @[[V_M_INIT]]()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LIUNX: define weak_odr hidden i32* @_ZTW1a() {
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// DARWIN: define cxx_fast_tlscc i32* @_ZTW1a()
[TLS on Darwin] use CXX_FAST_TLS calling convention for tls_init. This makes sure we don't generate a lot of code to spill/reload CSRs when calling tls_init from the access functions. This helps performance when tls_init is not inlined into the access functions. llvm-svn: 263854
2016-03-19 07:35:21 +08:00
// LINUX: call void @_ZTH1a()
// DARWIN: call cxx_fast_tlscc void @_ZTH1a()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: ret i32* @a
// CHECK: }
[CodeGen] Attach attributes to thread local wrapper function. This commit is a follow-up to r251734, r251476, and r249735, which fixes a bug where function attributes were not attached to thread local wrapper functions. rdar://problem/20828324 llvm-svn: 257865
2016-01-15 11:34:06 +08:00
// LINUX: declare extern_weak void @_ZTH1b() [[ATTR:#[0-9]+]]
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// LINUX-LABEL: define internal i32* @_ZTWL1d()
// DARWIN-LABEL: define internal cxx_fast_tlscc i32* @_ZTWL1d()
[TLS on Darwin] use CXX_FAST_TLS calling convention for tls_init. This makes sure we don't generate a lot of code to spill/reload CSRs when calling tls_init from the access functions. This helps performance when tls_init is not inlined into the access functions. llvm-svn: 263854
2016-03-19 07:35:21 +08:00
// LINUX: call void @_ZTHL1d()
// DARWIN: call cxx_fast_tlscc void @_ZTHL1d()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: ret i32* @_ZL1d
[TLS on Darwin] change how we handle globals with linkonce or weak linkage. This is about how we handle static member of a template. Before this commit, we use internal linkage for the IR thread-local variable, which is inefficient. With this commit, we will start to follow Itanium C++ ABI. rdar://problem/23415206 Reviewed by John McCall. llvm-svn: 252814
2015-11-12 06:42:31 +08:00
// LINUX-LABEL: define weak_odr hidden i32* @_ZTWN1U1mE()
[TLS on Darwin] use CXX_FAST_TLS calling convention for access functions. Also set nounwind attribute. rdar://problem/9001553 llvm-svn: 255860
2015-12-17 08:42:36 +08:00
// DARWIN-LABEL: define cxx_fast_tlscc i32* @_ZTWN1U1mE()
[TLS on Darwin] use CXX_FAST_TLS calling convention for tls_init. This makes sure we don't generate a lot of code to spill/reload CSRs when calling tls_init from the access functions. This helps performance when tls_init is not inlined into the access functions. llvm-svn: 263854
2016-03-19 07:35:21 +08:00
// LINUX: call void @_ZTHN1U1mE()
// DARWIN: call cxx_fast_tlscc void @_ZTHN1U1mE()
Implement CodeGen for C++11 thread_local, following the Itanium ABI specification as discussed on cxx-abi-dev. llvm-svn: 179858
2013-04-20 00:42:07 +08:00
// CHECK: ret i32* @_ZN1U1mE
[CodeGen] Attach attributes to thread local wrapper function. This commit is a follow-up to r251734, r251476, and r249735, which fixes a bug where function attributes were not attached to thread local wrapper functions. rdar://problem/20828324 llvm-svn: 257865
2016-01-15 11:34:06 +08:00
// LINUX: attributes [[ATTR]] = { {{.+}} }