1 // RUN: %clang_cc1 %s -triple=x86_64-pc-linuxs -emit-llvm -std=c++98 -o - | FileCheck -check-prefix=CHECK -check-prefix=CHECK98 %s 2 // RUN: %clang_cc1 %s -triple=x86_64-pc-linuxs -emit-llvm -std=c++11 -o - | FileCheck -check-prefix=CHECK -check-prefix=CHECK11 %s 3 4 // CHECK: @_ZZ1hvE1i = internal global i32 0, align 4 5 // CHECK: @base_req = global [4 x i8] c"foo\00", align 1 6 // CHECK: @base_req_uchar = global [4 x i8] c"bar\00", align 1 7 8 // CHECK: @_ZZN5test31BC1EvE1u = internal global { i8, [3 x i8] } { i8 97, [3 x i8] undef }, align 4 9 10 // CHECK: @_ZZ2h2vE1i = linkonce_odr global i32 0, comdat, align 4 11 // CHECK: @_ZGVZ2h2vE1i = linkonce_odr global i64 0, comdat, align 8{{$}} 12 // CHECK: @_ZZN5test1L6getvarEiE3var = internal constant [4 x i32] [i32 1, i32 0, i32 2, i32 4], align 16 13 // CHECK98: @_ZZN5test414useStaticLocalEvE3obj = linkonce_odr global %"struct.test4::HasVTable" zeroinitializer, comdat, align 8 14 // CHECK11: @_ZZN5test414useStaticLocalEvE3obj = linkonce_odr global { i8** } { i8** getelementptr inbounds ({ [3 x i8*] }, { [3 x i8*] }* @_ZTVN5test49HasVTableE, i32 0, inrange i32 0, i32 2) }, comdat, align 8 15 16 struct A { 17 A(); 18 ~A(); 19 }; 20 21 void f() { 22 // CHECK: load atomic i8, i8* bitcast (i64* @_ZGVZ1fvE1a to i8*) acquire, align 8 23 // CHECK: call i32 @__cxa_guard_acquire 24 // CHECK: call void @_ZN1AC1Ev 25 // CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A, %struct.A* @_ZZ1fvE1a, i32 0, i32 0), i8* @__dso_handle) 26 // CHECK: call void @__cxa_guard_release 27 static A a; 28 } 29 30 void g() { 31 // CHECK: call noalias nonnull i8* @_Znwm(i64 1) 32 // CHECK: call void @_ZN1AC1Ev( 33 static A& a = *new A; 34 } 35 36 int a(); 37 void h() { 38 static const int i = a(); 39 } 40 41 // CHECK: define linkonce_odr void @_Z2h2v() {{.*}} comdat { 42 inline void h2() { 43 static int i = a(); 44 } 45 46 void h3() { 47 h2(); 48 } 49 50 // PR6980: this shouldn't crash 51 namespace test0 { 52 struct A { A(); }; 53 __attribute__((noreturn)) int throw_exception(); 54 55 void test() { 56 throw_exception(); 57 static A r; 58 } 59 } 60 61 namespace test1 { 62 // CHECK-LABEL: define internal i32 @_ZN5test1L6getvarEi( 63 static inline int getvar(int index) { 64 static const int var[] = { 1, 0, 2, 4 }; 65 return var[index]; 66 } 67 68 void test() { (void) getvar(2); } 69 } 70 71 // Make sure we emit the initializer correctly for the following: 72 char base_req[] = { "foo" }; 73 unsigned char base_req_uchar[] = { "bar" }; 74 75 namespace union_static_local { 76 // CHECK-LABEL: define internal void @_ZZN18union_static_local4testEvEN1c4mainEv 77 // CHECK: call void @_ZN18union_static_local1fEPNS_1xE(%"union.union_static_local::x"* bitcast ({ [2 x i8*] }* @_ZZN18union_static_local4testEvE3foo to %"union.union_static_local::x"*)) 78 union x { long double y; const char *x[2]; }; 79 void f(union x*); 80 void test() { 81 static union x foo = { .x = { "a", "b" } }; 82 struct c { 83 static void main() { 84 f(&foo); 85 } 86 }; 87 c::main(); 88 } 89 } 90 91 // rdar://problem/11091093 92 // Static variables should be consistent across constructor 93 // or destructor variants. 94 namespace test2 { 95 struct A { 96 A(); 97 ~A(); 98 }; 99 100 struct B : virtual A { 101 B(); 102 ~B(); 103 }; 104 105 // If we ever implement this as a delegate ctor call, just change 106 // this to take variadic arguments or something. 107 extern int foo(); 108 B::B() { 109 static int x = foo(); 110 } 111 // CHECK-LABEL: define void @_ZN5test21BC2Ev 112 // CHECK: load atomic i8, i8* bitcast (i64* @_ZGVZN5test21BC1EvE1x to i8*) acquire, 113 // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test21BC1EvE1x) 114 // CHECK: [[T0:%.*]] = call i32 @_ZN5test23fooEv() 115 // CHECK: store i32 [[T0]], i32* @_ZZN5test21BC1EvE1x, 116 // CHECK: call void @__cxa_guard_release(i64* @_ZGVZN5test21BC1EvE1x) 117 118 // CHECK-LABEL: define void @_ZN5test21BC1Ev 119 // CHECK: load atomic i8, i8* bitcast (i64* @_ZGVZN5test21BC1EvE1x to i8*) acquire, 120 // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test21BC1EvE1x) 121 // CHECK: [[T0:%.*]] = call i32 @_ZN5test23fooEv() 122 // CHECK: store i32 [[T0]], i32* @_ZZN5test21BC1EvE1x, 123 // CHECK: call void @__cxa_guard_release(i64* @_ZGVZN5test21BC1EvE1x) 124 125 // This is just for completeness, because we actually emit this 126 // using a delegate dtor call. 127 B::~B() { 128 static int y = foo(); 129 } 130 // CHECK-LABEL: define void @_ZN5test21BD2Ev( 131 // CHECK: load atomic i8, i8* bitcast (i64* @_ZGVZN5test21BD1EvE1y to i8*) acquire, 132 // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test21BD1EvE1y) 133 // CHECK: [[T0:%.*]] = call i32 @_ZN5test23fooEv() 134 // CHECK: store i32 [[T0]], i32* @_ZZN5test21BD1EvE1y, 135 // CHECK: call void @__cxa_guard_release(i64* @_ZGVZN5test21BD1EvE1y) 136 137 // CHECK-LABEL: define void @_ZN5test21BD1Ev( 138 // CHECK: call void @_ZN5test21BD2Ev( 139 } 140 141 // This shouldn't error out. 142 namespace test3 { 143 struct A { 144 A(); 145 ~A(); 146 }; 147 148 struct B : virtual A { 149 B(); 150 ~B(); 151 }; 152 153 B::B() { 154 union U { char x; int i; }; 155 static U u = { 'a' }; 156 } 157 // CHECK-LABEL: define void @_ZN5test31BC2Ev( 158 // CHECK-LABEL: define void @_ZN5test31BC1Ev( 159 } 160 161 // We forgot to set the comdat when replacing the global with a different type. 162 namespace test4 { 163 struct HasVTable { 164 virtual void f(); 165 }; 166 inline HasVTable &useStaticLocal() { 167 static HasVTable obj; 168 return obj; 169 } 170 void useit() { 171 useStaticLocal(); 172 } 173 // CHECK: define linkonce_odr nonnull align 8 dereferenceable(8) %"struct.test4::HasVTable"* @_ZN5test414useStaticLocalEv() 174 // CHECK: ret %"struct.test4::HasVTable"*{{.*}} @_ZZN5test414useStaticLocalEvE3obj 175 } 176