1 // RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++2a %s -emit-llvm -o - | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s 2 // RUN: %clang_cc1 -triple x86_64-apple-darwin12 -std=c++2a %s -emit-llvm -o - | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s 3 4 // Check variable definitions/declarations. Note that on Darwin, typically the 5 // variable's symbol is marked internal, and only the _ZTW function is 6 // exported. Except: constinit variables do get exported, even on darwin. 7 8 // CHECK-DAG: @a = external thread_local global i32 9 // CHECK-DAG: @b = external thread_local global i32 10 // LINUX-DAG: @c ={{.*}} thread_local global i32 0, align 4 11 // DARWIN-DAG: @c = internal thread_local global i32 0, align 4 12 // LINUX-DAG: @d ={{.*}} thread_local global i32 0, align 4 13 // DARWIN-DAG: @d = internal thread_local global i32 0, align 4 14 // CHECK-DAG: @e = external thread_local global %struct.Destructed, align 4 15 // CHECK-DAG: @e2 ={{.*}} thread_local global %struct.Destructed zeroinitializer, align 4 16 // CHECK-DAG: @f ={{.*}} thread_local global i32 4, align 4 17 18 extern thread_local int a; 19 extern thread_local constinit int b; 20 21 // CHECK-LABEL: define{{.*}} i32 @_Z5get_av() 22 // CHECK: call {{(cxx_fast_tlscc )?}}i32* @_ZTW1a() 23 // CHECK: } 24 int get_a() { return a; } 25 26 // LINUX-LABEL: define linkonce_odr {{.*}} @_ZTW1a() 27 // LINUX: br i1 28 // LINUX: call void @_ZTH1a() 29 // LINUX: } 30 // DARWIN-NOT: define {{.*}}@_ZTW1a() 31 32 // CHECK-LABEL: define{{.*}} i32 @_Z5get_bv() 33 // CHECK-NOT: call 34 // CHECK: load i32, i32* @b 35 // CHECK-NOT: call 36 // CHECK: } 37 int get_b() { return b; } 38 39 // CHECK-NOT: define {{.*}} @_ZTW1b() 40 41 extern thread_local int c; 42 43 // CHECK-LABEL: define{{.*}} i32 @_Z5get_cv() 44 // LINUX: call {{(cxx_fast_tlscc )?}}i32* @_ZTW1c() 45 // CHECK: load i32, i32* % 46 // CHECK: } 47 int get_c() { return c; } 48 49 // Note: use of 'c' does not trigger initialization of 'd', because 'c' has a 50 // constant initializer. 51 // DARWIN-LABEL: define cxx_fast_tlscc {{.*}} @_ZTW1c() 52 // LINUX-LABEL: define weak_odr {{.*}} @_ZTW1c() 53 // CHECK-NOT: br i1 54 // CHECK-NOT: call 55 // CHECK: ret i32* @c 56 // CHECK: } 57 58 thread_local int c = 0; 59 60 // PR51079: We must assume an incomplete class type might have non-trivial 61 // destruction, and so speculatively call the thread wrapper. 62 63 // CHECK-LABEL: define {{.*}} @_Z6get_e3v( 64 // CHECK: call {{.*}}* @_ZTW2e3() 65 // CHECK-LABEL: } 66 extern thread_local constinit struct DestructedFwdDecl e3; 67 DestructedFwdDecl &get_e3() { return e3; } 68 69 int d_init(); 70 71 // CHECK: define {{.*}}[[D_INIT:@__cxx_global_var_init[^(]*]]( 72 // CHECK: call {{.*}} @_Z6d_initv() 73 thread_local int d = d_init(); 74 75 struct Destructed { 76 int n = 0; 77 ~Destructed(); 78 }; 79 80 extern thread_local constinit Destructed e; 81 // CHECK-LABEL: define{{.*}} i32 @_Z5get_ev() 82 // CHECK: call {{.*}}* @_ZTW1e() 83 // CHECK: } 84 int get_e() { return e.n; } 85 86 // CHECK: define {{.*}}[[E2_INIT:@__cxx_global_var_init[^(]*]]( 87 // LINUX: call {{.*}} @__cxa_thread_atexit({{.*}} @_ZN10DestructedD1Ev {{.*}} @e2 88 // DARWIN: call {{.*}} @_tlv_atexit({{.*}} @_ZN10DestructedD1Ev {{.*}} @e2 89 thread_local constinit Destructed e2; 90 91 thread_local constinit int f = 4; 92 93 // CHECK-LABEL: define {{.*}}__tls_init 94 // CHECK: call {{.*}} [[D_INIT]] 95 // CHECK: call {{.*}} [[E2_INIT]] 96 97 // Because the call wrapper may be called speculatively (and simply because 98 // it's required by the ABI), it must always be emitted for an external linkage 99 // variable, even if the variable has constant initialization and constant 100 // destruction. 101 struct NotDestructed { int n = 0; }; 102 thread_local constinit NotDestructed nd; 103 // CHECK-LABEL: define {{.*}} @_ZTW2nd 104