Clang Project

clang_source_code/test/CodeGenCXX/global-init.cpp
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
7struct A {
8  A();
9  ~A();
10};
11
12struct B { B(); ~B(); };
13
14struct C { void *field; };
15
16struct D { ~D(); };
17
18// CHECK: @__dso_handle = external hidden global i8
19// CHECK: @c = global %struct.C zeroinitializer, align 8
20
21// PR6205: The casts should not require global initializers
22// CHECK: @_ZN6PR59741cE = external global %"struct.PR5974::C"
23// CHECK: @_ZN6PR59741aE = global %"struct.PR5974::A"* getelementptr inbounds (%"struct.PR5974::C", %"struct.PR5974::C"* @_ZN6PR59741cE, i32 0, i32 0)
24// 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
25
26// CHECK: call void @_ZN1AC1Ev(%struct.A* @a)
27// 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)
28A a;
29
30// CHECK: call void @_ZN1BC1Ev(%struct.B* @b)
31// 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)
32B b;
33
34// PR6205: this should not require a global initializer
35// CHECK-NOT: call void @_ZN1CC1Ev(%struct.C* @c)
36C c;
37
38// 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)
39D d;
40
41// <rdar://problem/7458115>
42namespace test1 {
43  int f();
44  const int x = f();   // This has side-effects and gets emitted immediately.
45  const int y = x - 1; // This gets deferred.
46  const int z = ~y;    // This also gets deferred, but gets "undeferred" before y.
47  int test() { return z; }
48// CHECK-LABEL:      define i32 @_ZN5test14testEv()
49
50  // All of these initializers end up delayed, so we check them later.
51}
52
53// <rdar://problem/8246444>
54namespace 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
65namespace test3 {
66  // Tested at the beginning of the file.
67  const char * const var = "string";
68  extern const char * const var;
69
70  const char *test() { return var; }
71}
72
73namespace 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, i8* bitcast (i64* @_ZGVN5test41xE
81  // CHECK: [[CALL:%.*]] = call i32 @_ZN5test43fooEv
82  // CHECK-NEXT: store i32 [[CALL]], i32* @_ZN5test41xE
83  // CHECK-NEXT: store i64 1, i64* @_ZGVN5test41xE
84  __attribute__((weak)) int x = foo();
85}
86
87namespace 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.
100namespace test5 {
101  static union {
102    unsigned bar[4096] __attribute__((aligned(128)));
103  };
104}
105
106namespace std { struct type_info; }
107
108namespace 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
153namespace 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  // CHECK: call void @llvm.memset{{.*}} @_ZN5test7L2c1E
172  // CHECK-NOT: @_ZN5test7L2c1E
173  // CHECK: @_ZN5test7L2c2E
174  // CHECK-NOT: @_ZN5test7L2c3E
175  // CHECK: @_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, i32* @_ZN5test1L1yE
193// CHECK-NEXT:   xor
194// CHECK-NEXT:   store i32 {{.*}}, i32* @_ZN5test1L1zE
195// CHECK:      define internal void [[TEST1_Y_INIT:@.*]]()
196// CHECK:        load i32, i32* @_ZN5test1L1xE
197// CHECK-NEXT:   sub
198// CHECK-NEXT:   store i32 {{.*}}, i32* @_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// rdar://problem/8090834: 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
207// CHECK-NOEXC: attributes [[NUW]] = { noinline nounwind{{.*}} }
208
209// PR21811: attach the appropriate attribute to the global init function
210// CHECK-FP: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUX:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" {
211// CHECK-FP: attributes [[NUX]] = { noinline nounwind {{.*}}"no-frame-pointer-elim-non-leaf"{{.*}} }
212
CodeThinker, Enjoy your reading code