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