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
   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"{{.*}} }