1 // RUN: %clang_cc1 %std_cxx98-14 -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - |FileCheck %s --check-prefixes=CHECK,PRE17 2 // RUN: %clang_cc1 %std_cxx98-14 -triple=x86_64-apple-darwin10 -emit-llvm %s -o - |FileCheck %s --check-prefixes=CHECK-NOEXC,PRE17 3 // RUN: %clang_cc1 %std_cxx98-14 -triple=x86_64-apple-darwin10 -emit-llvm -mframe-pointer=non-leaf %s -o - \ 4 // RUN: | FileCheck -check-prefix CHECK-FP %s 5 // RUN: %clang_cc1 %std_cxx98-14 -triple=x86_64-apple-darwin10 -emit-llvm %s -o - -fno-builtin \ 6 // RUN: | FileCheck -check-prefix CHECK-NOBUILTIN %s 7 // RUN: %clang_cc1 %std_cxx17- -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - | FileCheck %s 8 9 struct A { 10 A(); 11 ~A(); 12 }; 13 14 struct B { B(); ~B(); }; 15 16 struct C { void *field; }; 17 18 struct D { ~D(); }; 19 20 // CHECK: @__dso_handle = external hidden global i8 21 // CHECK: @c ={{.*}} global %struct.C zeroinitializer, align 8 22 23 // PR6205: The casts should not require global initializers 24 // CHECK: @_ZN6PR59741cE = external global %"struct.PR5974::C" 25 // CHECK: @_ZN6PR59741aE ={{.*}} global ptr @_ZN6PR59741cE 26 // CHECK: @_ZN6PR59741bE ={{.*}} global ptr getelementptr (i8, ptr @_ZN6PR59741cE, i64 4), align 8 27 28 // CHECK: call void @_ZN1AC1Ev(ptr {{[^,]*}} @a) 29 // CHECK: call i32 @__cxa_atexit(ptr @_ZN1AD1Ev, ptr @a, ptr @__dso_handle) 30 A a; 31 32 // CHECK: call void @_ZN1BC1Ev(ptr {{[^,]*}} @b) 33 // CHECK: call i32 @__cxa_atexit(ptr @_ZN1BD1Ev, ptr @b, ptr @__dso_handle) 34 B b; 35 36 // PR6205: this should not require a global initializer 37 // CHECK-NOT: call void @_ZN1CC1Ev(ptr @c) 38 C c; 39 40 // CHECK: call i32 @__cxa_atexit(ptr @_ZN1DD1Ev, ptr @d, ptr @__dso_handle) 41 D d; 42 43 namespace test1 { 44 int f(); 45 const int x = f(); // This has side-effects and gets emitted immediately. 46 const int y = x - 1; // This gets deferred. 47 const int z = ~y; // This also gets deferred, but gets "undeferred" before y. test()48 int test() { return z; } 49 // CHECK-LABEL: define{{.*}} i32 @_ZN5test14testEv() 50 51 // All of these initializers end up delayed, so we check them later. 52 } 53 54 namespace test2 { 55 struct allocator { allocator(); ~allocator(); }; 56 struct A { A(const allocator &a = allocator()); ~A(); }; 57 58 A a; 59 // CHECK: call void @_ZN5test29allocatorC1Ev( 60 // CHECK: invoke void @_ZN5test21AC1ERKNS_9allocatorE( 61 // CHECK: call void @_ZN5test29allocatorD1Ev( 62 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN5test21AD1Ev, {{.*}} @_ZN5test21aE 63 } 64 65 namespace test3 { 66 // Tested at the beginning of the file. 67 const char * const var = "string"; 68 extern const char * const var; 69 test()70 const char *test() { return var; } 71 } 72 73 namespace test4 { 74 struct A { 75 A(); 76 }; 77 extern int foo(); 78 79 // This needs an initialization function and guard variables. 80 // CHECK: load i8, ptr @_ZGVN5test41xE 81 // CHECK: store i8 1, ptr @_ZGVN5test41xE 82 // CHECK-NEXT: [[CALL:%.*]] = call noundef i32 @_ZN5test43fooEv 83 // CHECK-NEXT: store i32 [[CALL]], ptr @_ZN5test41xE 84 __attribute__((weak)) int x = foo(); 85 } 86 87 namespace PR5974 { 88 struct A { int a; }; 89 struct B { int b; }; 90 struct C : A, B { int c; }; 91 92 extern C c; 93 94 // These should not require global initializers. 95 A* a = &c; 96 B* b = &c; 97 } 98 99 // PR9570: the indirect field shouldn't crash IR gen. 100 namespace test5 { 101 static union { 102 unsigned bar[4096] __attribute__((aligned(128))); 103 }; 104 } 105 106 namespace std { struct type_info; } 107 108 namespace test6 { 109 struct A { virtual ~A(); }; 110 struct B : A {}; 111 extern A *p; 112 113 // We must emit a dynamic initializer for 'q', because it could throw. 114 B *const q = &dynamic_cast<B&>(*p); 115 // CHECK: call void @__cxa_bad_cast() 116 // CHECK: store {{.*}} @_ZN5test6L1qE 117 118 // We don't need to emit 'r' at all, because it has internal linkage, is 119 // unused, and its initialization has no side-effects. 120 B *const r = dynamic_cast<B*>(p); 121 // CHECK-NOT: call void @__cxa_bad_cast() 122 // CHECK-NOT: store {{.*}} @_ZN5test6L1rE 123 124 // This can throw, so we need to emit it. 125 const std::type_info *const s = &typeid(*p); 126 // CHECK: store {{.*}} @_ZN5test6L1sE 127 128 // This can't throw, so we don't. 129 const std::type_info *const t = &typeid(p); 130 // CHECK-NOT: @_ZN5test6L1tE 131 132 extern B *volatile v; 133 // CHECK: store {{.*}} @_ZN5test6L1wE 134 B *const w = dynamic_cast<B*>(v); 135 136 // CHECK: load volatile 137 // CHECK: store {{.*}} @_ZN5test6L1xE 138 const int x = *(volatile int*)0x1234; 139 140 namespace { 141 int a = int(); 142 volatile int b = int(); 143 int c = a; 144 int d = b; 145 // CHECK-NOT: store {{.*}} @_ZN5test6{{[A-Za-z0-9_]*}}1aE 146 // CHECK-NOT: store {{.*}} @_ZN5test6{{[A-Za-z0-9_]*}}1bE 147 // CHECK-NOT: store {{.*}} @_ZN5test6{{[A-Za-z0-9_]*}}1cE 148 // CHECK: load volatile {{.*}} @_ZN5test6{{[A-Za-z0-9_]*}}1bE 149 // CHECK: store {{.*}} @_ZN5test6{{[A-Za-z0-9_]*}}1dE 150 } 151 } 152 153 namespace test7 { 154 struct A { A(); }; 155 struct B { ~B(); int n; }; 156 struct C { C() = default; C(const C&); int n; }; 157 struct D {}; 158 159 // CHECK: call void @_ZN5test71AC1Ev({{.*}}@_ZN5test7L1aE) 160 const A a = A(); 161 162 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN5test71BD1Ev{{.*}} @_ZN5test7L2b1E 163 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN5test71BD1Ev{{.*}} @_ZGRN5test72b2E 164 // CHECK: call void @_ZN5test71BD1Ev( 165 // CHECK: store {{.*}} @_ZN5test7L2b3E 166 const B b1 = B(); 167 const B &b2 = B(); 168 const int b3 = B().n; 169 170 // CHECK-NOT: @_ZN5test7L2c1E 171 // PRE17: call void @llvm.memset{{.*}} @_ZN5test7L2c1E 172 // CHECK-NOT: @_ZN5test7L2c1E 173 // CHECK: @_ZN5test7L2c2E 174 // CHECK-NOT: @_ZN5test7L2c3E 175 // PRE17: @_ZN5test7L2c4E 176 const C c1 = C(); 177 const C c2 = static_cast<const C&>(C()); 178 const int c3 = C().n; 179 const int c4 = C(C()).n; 180 181 // CHECK-NOT: @_ZN5test7L1dE 182 const D d = D(); 183 184 // CHECK: store {{.*}} @_ZN5test71eE 185 int f(), e = f(); 186 } 187 188 189 // At the end of the file, we check that y is initialized before z. 190 191 // CHECK: define internal void [[TEST1_Z_INIT:@.*]]() 192 // CHECK: load i32, ptr @_ZN5test1L1yE 193 // CHECK-NEXT: xor 194 // CHECK-NEXT: store i32 {{.*}}, ptr @_ZN5test1L1zE 195 // CHECK: define internal void [[TEST1_Y_INIT:@.*]]() 196 // CHECK: load i32, ptr @_ZN5test1L1xE 197 // CHECK-NEXT: sub 198 // CHECK-NEXT: store i32 {{.*}}, ptr @_ZN5test1L1yE 199 200 // CHECK: define internal void @_GLOBAL__sub_I_global_init.cpp() #{{[0-9]+}} section "__TEXT,__StaticInit,regular,pure_instructions" { 201 // CHECK: call void [[TEST1_Y_INIT]] 202 // CHECK: call void [[TEST1_Z_INIT]] 203 204 // this should be nounwind 205 // CHECK-NOEXC: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUW:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" { 206 // CHECK-NOEXC: attributes [[NUW]] = { noinline nounwind{{.*}} } 207 208 // Make sure we mark global initializers with the no-builtins attribute. 209 // CHECK-NOBUILTIN: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUW:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" { 210 // CHECK-NOBUILTIN: attributes [[NUW]] = { noinline nounwind{{.*}}"no-builtins"{{.*}} } 211 212 // PR21811: attach the appropriate attribute to the global init function 213 // CHECK-FP: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUX:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" { 214 // CHECK-FP: attributes [[NUX]] = { noinline nounwind {{.*}}"frame-pointer"="non-leaf"{{.*}} } 215