clang/test/CodeGenCXX/const-init-cxx11.cpp

   1 // RUN: %clang_cc1 -w -fmerge-all-constants -triple x86_64-elf-gnu -emit-llvm -o - %s -std=c++11 | FileCheck %s
   2 // RUN: %clang_cc1 -w -fmerge-all-constants -triple x86_64-elf-gnu -emit-llvm -o - %s -std=c++20 | FileCheck -check-prefix=CHECK20 %s
   3
   4 // FIXME: The padding in all these objects should be zero-initialized.
   5 namespace StructUnion {
   6   struct A {
   7     int n;
   8     double d;
   9     union U {
  10       constexpr U(int x) : x(x) {}
  11       constexpr U(const char *y) : y(y) {}
  12       int x;
  13       const char *y;
  14     } u;
  15
  16     constexpr A(int n, double d, int x) : n(n), d(d), u(x) {}
  17     constexpr A(int n, double d, const char *y) : n(n), d(d), u(y) {}
  18   };
  19
  20   // CHECK: @_ZN11StructUnion1aE ={{.*}} constant {{.*}} { i32 1, double 2.000000e+00, {{.*}} { i32 3, [4 x i8] undef } }
  21   extern constexpr A a(1, 2.0, 3);
  22
  23   // CHECK: @_ZN11StructUnion1bE ={{.*}} constant {{.*}} { i32 4, double 5.000000e+00, {{.*}} { ptr @{{.*}} } }
  24   extern constexpr A b(4, 5, "hello");
  25
  26   struct B {
  27     int n;
  28   };
  29
  30   // CHECK: @_ZN11StructUnion1cE ={{.*}} global {{.*}} zeroinitializer
  31   // CHECK: @_ZN11StructUnion2c2E ={{.*}} global {{.*}} zeroinitializer
  32   B c;
  33   B c2 = B();
  34
  35   // CHECK: @_ZN11StructUnion1dE ={{.*}} global {{.*}} zeroinitializer
  36   B d[10];
  37
  38   struct C {
  39     constexpr C() : c(0) {}
  40     int c;
  41   };
  42
  43   // CHECK: @_ZN11StructUnion1eE ={{.*}} global {{.*}} zeroinitializer
  44   C e[10];
  45
  46   struct D {
  47     constexpr D() : d(5) {}
  48     int d;
  49   };
  50
  51   // CHECK: @_ZN11StructUnion1fE ={{.*}} global {{.*}} { i32 5 }
  52   D f;
  53
  54   union E {
  55     int a;
  56     void *b = &f;
  57   };
  58
  59   // CHECK: @_ZN11StructUnion1gE ={{.*}} global {{.*}} @_ZN11StructUnion1fE
  60   E g;
  61
  62   // CHECK: @_ZN11StructUnion1hE ={{.*}} global {{.*}} @_ZN11StructUnion1fE
  63   E h = E();
  64 }
  65
  66 namespace BaseClass {
  67   template<typename T, unsigned> struct X : T {};
  68   struct C { char c = 1; };
  69   template<unsigned... Ns> struct Cs : X<C,Ns>... {};
  70   struct N { int n = 3; };
  71   struct D { double d = 4.0; };
  72
  73   template<typename ...Ts>
  74   struct Test : Ts... { constexpr Test() : Ts()..., n(5) {} int n; };
  75
  76   using Test1 = Test<N, C, Cs<1,2>, D, X<C,1>>;
  77   // CHECK: @_ZN9BaseClass2t1E ={{.*}} constant {{.*}} { i32 3, i8 1, i8 1, i8 1, double 4.000000e+00, i8 1, i32 5 }, align 8
  78   extern constexpr Test1 t1 = Test1();
  79
  80   struct DN : D, N {};
  81   struct DND : DN, X<D,0> {};
  82   struct DNN : DN, X<N,0> {};
  83   // CHECK: @_ZN9BaseClass3dndE ={{.*}} constant {{.*}} { double 4.000000e+00, i32 3, double 4.000000e+00 }
  84   extern constexpr DND dnd = DND();
  85   // Note, N subobject is laid out in DN subobject's tail padding.
  86   // CHECK: @_ZN9BaseClass3dnnE ={{.*}} constant {{.*}} { double 4.000000e+00, i32 3, i32 3 }
  87   extern constexpr DNN dnn = DNN();
  88
  89   struct E {};
  90   struct Test2 : X<E,0>, X<E,1>, X<E,2>, X<E,3> {};
  91   // CHECK: @_ZN9BaseClass2t2E ={{.*}} constant {{.*}} zeroinitializer, align 1
  92   extern constexpr Test2 t2 = Test2();
  93
  94   struct __attribute((packed)) PackedD { double y = 2; };
  95   struct Test3 : C, PackedD { constexpr Test3() {} };
  96   // CHECK: @_ZN9BaseClass2t3E ={{.*}} constant <{ i8, double }> <{ i8 1, double 2.000000e+00 }>
  97   extern constexpr Test3 t3 = Test3();
  98 }
  99
 100 namespace Array {
 101   // CHECK: @_ZN5Array3arrE ={{.*}} constant [2 x i32] [i32 4, i32 0]
 102   extern constexpr int arr[2] = { 4 };
 103
 104   // CHECK: @_ZN5Array1cE ={{.*}} constant [6 x [4 x i8]] [{{.*}} c"foo\00", [4 x i8] c"a\00\00\00", [4 x i8] c"bar\00", [4 x i8] c"xyz\00", [4 x i8] c"b\00\00\00", [4 x i8] c"123\00"]
 105   extern constexpr char c[6][4] = { "foo", "a", { "bar" }, { 'x', 'y', 'z' }, { "b" }, '1', '2', '3' };
 106
 107   // CHECK: @_ZN5Array2ucE ={{.*}} constant [4 x i8] c"foo\00"
 108   extern constexpr unsigned char uc[] = { "foo" };
 109
 110   struct C { constexpr C() : n(5) {} int n, m = 3 * n + 1; };
 111   // CHECK: @_ZN5Array5ctorsE ={{.*}} constant [3 x {{.*}}] [{{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }]
 112   extern const C ctors[3];
 113   constexpr C ctors[3];
 114
 115   // CHECK: @_ZN5Array1dE ={{.*}} constant {{.*}} { [2 x i32] [i32 1, i32 2], [3 x i32] [i32 3, i32 4, i32 5] }
 116   struct D { int n[2]; int m[3]; } extern constexpr d = { 1, 2, 3, 4, 5 };
 117
 118   struct E {
 119     char c[4];
 120     char d[4];
 121     constexpr E() : c("foo"), d("x") {}
 122   };
 123   // CHECK: @_ZN5Array1eE ={{.*}} constant {{.*}} { [4 x i8] c"foo\00", [4 x i8] c"x\00\00\00" }
 124   extern constexpr E e = E();
 125
 126   // PR13290
 127   struct F { constexpr F() : n(4) {} int n; };
 128   // CHECK: @_ZN5Array2f1E ={{.*}} global {{.*}} zeroinitializer
 129   F f1[1][1][0] = { };
 130   // CHECK: @_ZN5Array2f2E ={{.*}} global {{.* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4 .* i32 4}}
 131   F f2[2][2][2] = { };
 132 }
 133
 134 namespace MemberPtr {
 135   struct B1 {
 136     int a, b;
 137     virtual void f();
 138     void g();
 139   };
 140   struct B2 {
 141     int c, d;
 142     virtual void h();
 143     void i();
 144   };
 145   struct C : B1 {
 146     int e;
 147     virtual void j();
 148     void k();
 149   };
 150   struct D : C, B2 {
 151     int z;
 152     virtual void l();
 153     void m();
 154   };
 155
 156   // CHECK: @_ZN9MemberPtr2daE ={{.*}} constant i64 8
 157   // CHECK: @_ZN9MemberPtr2dbE ={{.*}} constant i64 12
 158   // CHECK: @_ZN9MemberPtr2dcE ={{.*}} constant i64 32
 159   // CHECK: @_ZN9MemberPtr2ddE ={{.*}} constant i64 36
 160   // CHECK: @_ZN9MemberPtr2deE ={{.*}} constant i64 16
 161   // CHECK: @_ZN9MemberPtr2dzE ={{.*}} constant i64 40
 162   extern constexpr int (D::*da) = &B1::a;
 163   extern constexpr int (D::*db) = &C::b;
 164   extern constexpr int (D::*dc) = &B2::c;
 165   extern constexpr int (D::*dd) = &D::d;
 166   extern constexpr int (D::*de) = &C::e;
 167   extern constexpr int (D::*dz) = &D::z;
 168
 169   // CHECK: @_ZN9MemberPtr2baE ={{.*}} constant i64 8
 170   // CHECK: @_ZN9MemberPtr2bbE ={{.*}} constant i64 12
 171   // CHECK: @_ZN9MemberPtr2bcE ={{.*}} constant i64 8
 172   // CHECK: @_ZN9MemberPtr2bdE ={{.*}} constant i64 12
 173   // CHECK: @_ZN9MemberPtr2beE ={{.*}} constant i64 16
 174   // CHECK: @_ZN9MemberPtr3b1zE ={{.*}} constant i64 40
 175   // CHECK: @_ZN9MemberPtr3b2zE ={{.*}} constant i64 16
 176   extern constexpr int (B1::*ba) = (int(B1::*))&B1::a;
 177   extern constexpr int (B1::*bb) = (int(B1::*))&C::b;
 178   extern constexpr int (B2::*bc) = (int(B2::*))&B2::c;
 179   extern constexpr int (B2::*bd) = (int(B2::*))&D::d;
 180   extern constexpr int (B1::*be) = (int(B1::*))&C::e;
 181   extern constexpr int (B1::*b1z) = (int(B1::*))&D::z;
 182   extern constexpr int (B2::*b2z) = (int(B2::*))&D::z;
 183
 184   // CHECK: @_ZN9MemberPtr2dfE ={{.*}} constant {{.*}} { i64 1, i64 0 }
 185   // CHECK: @_ZN9MemberPtr2dgE ={{.*}} constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 }
 186   // CHECK: @_ZN9MemberPtr2dhE ={{.*}} constant {{.*}} { i64 1, i64 24 }
 187   // CHECK: @_ZN9MemberPtr2diE ={{.*}} constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 24 }
 188   // CHECK: @_ZN9MemberPtr2djE ={{.*}} constant {{.*}} { i64 9, i64 0 }
 189   // CHECK: @_ZN9MemberPtr2dkE ={{.*}} constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 }
 190   // CHECK: @_ZN9MemberPtr2dlE ={{.*}} constant {{.*}} { i64 17, i64 0 }
 191   // CHECK: @_ZN9MemberPtr2dmE ={{.*}} constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 }
 192   extern constexpr void (D::*df)() = &C::f;
 193   extern constexpr void (D::*dg)() = &B1::g;
 194   extern constexpr void (D::*dh)() = &B2::h;
 195   extern constexpr void (D::*di)() = &D::i;
 196   extern constexpr void (D::*dj)() = &C::j;
 197   extern constexpr void (D::*dk)() = &C::k;
 198   extern constexpr void (D::*dl)() = &D::l;
 199   extern constexpr void (D::*dm)() = &D::m;
 200
 201   // CHECK: @_ZN9MemberPtr2bfE ={{.*}} constant {{.*}} { i64 1, i64 0 }
 202   // CHECK: @_ZN9MemberPtr2bgE ={{.*}} constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 }
 203   // CHECK: @_ZN9MemberPtr2bhE ={{.*}} constant {{.*}} { i64 1, i64 0 }
 204   // CHECK: @_ZN9MemberPtr2biE ={{.*}} constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 0 }
 205   // CHECK: @_ZN9MemberPtr2bjE ={{.*}} constant {{.*}} { i64 9, i64 0 }
 206   // CHECK: @_ZN9MemberPtr2bkE ={{.*}} constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 }
 207   // CHECK: @_ZN9MemberPtr3b1lE ={{.*}} constant {{.*}} { i64 17, i64 0 }
 208   // CHECK: @_ZN9MemberPtr3b1mE ={{.*}} constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 }
 209   // CHECK: @_ZN9MemberPtr3b2lE ={{.*}} constant {{.*}} { i64 17, i64 -24 }
 210   // CHECK: @_ZN9MemberPtr3b2mE ={{.*}} constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 -24 }
 211   extern constexpr void (B1::*bf)()  = (void(B1::*)())&C::f;
 212   extern constexpr void (B1::*bg)()  = (void(B1::*)())&B1::g;
 213   extern constexpr void (B2::*bh)()  = (void(B2::*)())&B2::h;
 214   extern constexpr void (B2::*bi)()  = (void(B2::*)())&D::i;
 215   extern constexpr void (B1::*bj)()  = (void(B1::*)())&C::j;
 216   extern constexpr void (B1::*bk)()  = (void(B1::*)())&C::k;
 217   extern constexpr void (B1::*b1l)() = (void(B1::*)())&D::l;
 218   extern constexpr void (B1::*b1m)() = (void(B1::*)())&D::m;
 219   extern constexpr void (B2::*b2l)() = (void(B2::*)())&D::l;
 220   extern constexpr void (B2::*b2m)() = (void(B2::*)())&D::m;
 221 }
 222
 223 namespace LiteralReference {
 224   struct Lit {
 225     constexpr Lit() : n(5) {}
 226     int n;
 227   };
 228
 229   // This creates a non-const temporary and binds a reference to it.
 230   // CHECK: @[[TEMP:.*]] = internal global {{.*}} { i32 5 }, align 4
 231   // CHECK: @_ZN16LiteralReference3litE ={{.*}} constant {{.*}} @[[TEMP]], align 8
 232   const Lit &lit = Lit();
 233
 234   // This creates a const temporary as part of the reference initialization.
 235   // CHECK: @[[TEMP:.*]] = internal constant {{.*}} { i32 5 }, align 4
 236   // CHECK: @_ZN16LiteralReference4lit2E ={{.*}} constant {{.*}} @[[TEMP]], align 8
 237   const Lit &lit2 = {};
 238
 239   struct A { int &&r1; const int &&r2; };
 240   struct B { A &&a1; const A &&a2; };
 241   B b = { { 0, 1 }, { 2, 3 } };
 242   // CHECK: @[[TEMP0:.*]] = internal global i32 0, align 4
 243   // CHECK: @[[TEMP1:.*]] = internal constant i32 1, align 4
 244   // CHECK: @[[TEMPA1:.*]] = internal global {{.*}} { ptr @[[TEMP0]], ptr @[[TEMP1]] }, align 8
 245   // CHECK: @[[TEMP2:.*]] = internal global i32 2, align 4
 246   // CHECK: @[[TEMP3:.*]] = internal constant i32 3, align 4
 247   // CHECK: @[[TEMPA2:.*]] = internal constant {{.*}} { ptr @[[TEMP2]], ptr @[[TEMP3]] }, align 8
 248   // CHECK: @_ZN16LiteralReference1bE ={{.*}} global {{.*}} { ptr @[[TEMPA1]], ptr @[[TEMPA2]] }, align 8
 249
 250   struct Subobj {
 251     int a, b, c;
 252   };
 253   // CHECK: @[[TEMP:.*]] = internal global {{.*}} { i32 1, i32 2, i32 3 }, align 4
 254   // CHECK: @_ZN16LiteralReference2soE ={{.*}} constant ptr getelementptr (i8, ptr @[[TEMP]], i64 4)
 255   constexpr int &&so = Subobj{ 1, 2, 3 }.b;
 256
 257   struct Dummy { int padding; };
 258   struct Derived : Dummy, Subobj {
 259     constexpr Derived() : Dummy{200}, Subobj{4, 5, 6} {}
 260   };
 261   using ConstDerived = const Derived;
 262   // CHECK: @[[TEMPCOMMA:.*]] = internal constant {{.*}} { i32 200, i32 4, i32 5, i32 6 }
 263   // CHECK: @_ZN16LiteralReference5commaE ={{.*}} constant {{.*}} getelementptr {{.*}} @[[TEMPCOMMA]]{{.*}}, i64 8)
 264   constexpr const int &comma = (1, (2, ConstDerived{}).b);
 265
 266   // CHECK: @[[TEMPDERIVED:.*]] = internal global {{.*}} { i32 200, i32 4, i32 5, i32 6 }
 267   // CHECK: @_ZN16LiteralReference4baseE ={{.*}} constant {{.*}} getelementptr {{.*}} @[[TEMPDERIVED]]{{.*}}, i64 4)
 268   constexpr Subobj &&base = Derived{};
 269
 270   // CHECK: @_ZN16LiteralReference7derivedE ={{.*}} constant {{.*}} @[[TEMPDERIVED]]
 271   constexpr Derived &derived = static_cast<Derived&>(base);
 272 }
 273
 274 namespace NonLiteralConstexpr {
 275   constexpr int factorial(int n) {
 276     return n ? factorial(n-1) * n : 1;
 277   }
 278   extern void f(int *p);
 279
 280   struct NonTrivialDtor {
 281     constexpr NonTrivialDtor() : n(factorial(5)), p(&n) {}
 282     ~NonTrivialDtor() {
 283       f(p);
 284     }
 285
 286     int n;
 287     int *p;
 288   };
 289   static_assert(!__is_literal(NonTrivialDtor), "");
 290   // CHECK: @_ZN19NonLiteralConstexpr3ntdE ={{.*}} global {{.*}} { i32 120, ptr @
 291   NonTrivialDtor ntd;
 292
 293   struct VolatileMember {
 294     constexpr VolatileMember() : n(5) {}
 295     volatile int n;
 296   };
 297   static_assert(!__is_literal(VolatileMember), "");
 298   // CHECK: @_ZN19NonLiteralConstexpr2vmE ={{.*}} global {{.*}} { i32 5 }
 299   VolatileMember vm;
 300
 301   struct Both {
 302     constexpr Both() : n(10) {}
 303     ~Both();
 304     volatile int n;
 305   };
 306   // CHECK: @_ZN19NonLiteralConstexpr1bE ={{.*}} global {{.*}} { i32 10 }
 307   Both b;
 308
 309   void StaticVars() {
 310     // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE3ntd = {{.*}} { i32 120, ptr @
 311     // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE3ntd =
 312     static NonTrivialDtor ntd;
 313     // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE2vm = {{.*}} { i32 5 }
 314     // CHECK-NOT: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE2vm =
 315     static VolatileMember vm;
 316     // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE1b = {{.*}} { i32 10 }
 317     // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE1b =
 318     static Both b;
 319   }
 320 }
 321
 322 // PR12067
 323 namespace VirtualMembers {
 324   struct A {
 325     constexpr A(double d) : d(d) {}
 326     virtual void f();
 327     double d;
 328   };
 329   struct B : A {
 330     constexpr B() : A(2.0), c{'h', 'e', 'l', 'l', 'o'} {}
 331     constexpr B(int n) : A(n), c{'w', 'o', 'r', 'l', 'd'} {}
 332     virtual void g();
 333     char c[5];
 334   };
 335   struct C {
 336     constexpr C() : n(64) {}
 337     int n;
 338   };
 339   struct D : C, A, B {
 340     constexpr D() : A(1.0), B(), s(5) {}
 341     short s;
 342   };
 343   struct E : D, B {
 344     constexpr E() : B(3), c{'b','y','e'} {}
 345     char c[3];
 346   };
 347   // CHECK: @_ZN14VirtualMembers1eE ={{.*}} global { ptr, double, i32, ptr, double, [5 x i8], i16, ptr, double, [5 x i8], [3 x i8] } { ptr getelementptr inbounds ({ [3 x ptr], [4 x ptr], [4 x ptr] }, ptr @_ZTVN14VirtualMembers1EE, i32 0, inrange i32 0, i32 2), double 1.000000e+00, i32 64, ptr getelementptr inbounds ({ [3 x ptr], [4 x ptr], [4 x ptr] }, ptr @_ZTVN14VirtualMembers1EE, i32 0, inrange i32 1, i32 2), double 2.000000e+00, [5 x i8] c"hello", i16 5, ptr getelementptr inbounds ({ [3 x ptr], [4 x ptr], [4 x ptr] }, ptr @_ZTVN14VirtualMembers1EE, i32 0, inrange i32 2, i32 2), double 3.000000e+00, [5 x i8] c"world", [3 x i8] c"bye" }
 348   E e;
 349
 350   struct nsMemoryImpl {
 351     virtual void f();
 352   };
 353   // CHECK: @_ZN14VirtualMembersL13sGlobalMemoryE = internal global %"struct.VirtualMembers::nsMemoryImpl" { ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTVN14VirtualMembers12nsMemoryImplE, i32 0, inrange i32 0, i32 2) }
 354   __attribute__((used))
 355   static nsMemoryImpl sGlobalMemory;
 356
 357   template<class T>
 358   struct TemplateClass {
 359     constexpr TemplateClass() : t{42} {}
 360     virtual void templateMethod() {}
 361
 362     T t;
 363   };
 364   // CHECK: @_ZN14VirtualMembers1tE ={{.*}} global { ptr, i32 } { ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTVN14VirtualMembers13TemplateClassIiEE, i32 0, inrange i32 0, i32 2), i32 42 }
 365   TemplateClass<int> t;
 366 }
 367
 368 namespace PR13273 {
 369   struct U {
 370     int t;
 371     U() = default;
 372   };
 373
 374   struct S : U {
 375     S() = default;
 376   };
 377
 378   // CHECK: @_ZN7PR132731sE = {{.*}} zeroinitializer
 379   extern const S s {};
 380 }
 381
 382 namespace ArrayTemporary {
 383   struct A { const int (&x)[3]; };
 384   struct B { const A (&x)[2]; };
 385   // CHECK: @[[A1:_ZGRN14ArrayTemporary1bE.*]] = internal constant [3 x i32] [i32 1, i32 2, i32 3]
 386   // CHECK: @[[A2:_ZGRN14ArrayTemporary1bE.*]] = internal constant [3 x i32] [i32 4, i32 5, i32 6]
 387   // CHECK: @[[ARR:_ZGRN14ArrayTemporary1bE.*]] = internal constant [2 x {{.*}}] [{{.*}} { ptr @[[A1]] }, {{.*}} { ptr @[[A2]] }]
 388   // CHECK: @[[B:_ZGRN14ArrayTemporary1bE.*]] = internal global {{.*}} { ptr @[[ARR]] }
 389   // CHECK: @_ZN14ArrayTemporary1bE ={{.*}} constant ptr @[[B]]
 390   B &&b = { { { { 1, 2, 3 } }, { { 4, 5, 6 } } } };
 391 }
 392
 393 namespace UnemittedTemporaryDecl {
 394   constexpr int &&ref = 0;
 395   extern constexpr int &ref2 = ref;
 396   // CHECK: @_ZGRN22UnemittedTemporaryDecl3refE_ = internal global i32 0
 397
 398   // FIXME: This declaration should not be emitted -- it isn't odr-used.
 399   // CHECK: @_ZN22UnemittedTemporaryDecl3refE
 400
 401   // CHECK: @_ZN22UnemittedTemporaryDecl4ref2E ={{.*}} constant ptr @_ZGRN22UnemittedTemporaryDecl3refE_
 402 }
 403
 404 namespace DR2126 {
 405   struct A { int &&b; };
 406   constexpr const A &a = {42};
 407   // CHECK: @_ZGRN6DR21261aE0_ = internal global i32 42
 408   // FIXME: This is unused and need not be emitted.
 409   // CHECK: @_ZGRN6DR21261aE_ = internal constant {{.*}} { ptr @_ZGRN6DR21261aE0_ }
 410   // CHECK: @_ZN6DR21261rE ={{.*}} constant ptr @_ZGRN6DR21261aE0_
 411   int &r = a.b;
 412
 413   // Dynamically initialized: the temporary object bound to 'b' could be
 414   // modified (eg, by placement 'new') before the initializer of 's' runs.
 415   constexpr A &&b = {42};
 416   // CHECK: @_ZN6DR21261sE ={{.*}} global ptr null
 417   int &s = b.b;
 418 }
 419
 420 // CHECK: @_ZZN12LocalVarInit3aggEvE1a = internal constant {{.*}} i32 101
 421 // CHECK: @_ZZN12LocalVarInit4ctorEvE1a = internal constant {{.*}} i32 102
 422 // CHECK: @__const._ZN12LocalVarInit8mutable_Ev.a = private unnamed_addr constant {{.*}} i32 103
 423 // CHECK: @_ZGRN33ClassTemplateWithStaticDataMember1SIvE1aE_ = linkonce_odr constant i32 5, comdat
 424 // CHECK: @_ZN33ClassTemplateWithStaticDataMember3useE ={{.*}} constant ptr @_ZGRN33ClassTemplateWithStaticDataMember1SIvE1aE_
 425 // CHECK: @_ZGRN39ClassTemplateWithHiddenStaticDataMember1SIvE1aE_ = linkonce_odr hidden constant i32 5, comdat
 426 // CHECK: @_ZN39ClassTemplateWithHiddenStaticDataMember3useE ={{.*}} constant ptr @_ZGRN39ClassTemplateWithHiddenStaticDataMember1SIvE1aE_
 427 // CHECK: @.str.[[STR:[0-9]+]] ={{.*}} constant [9 x i8] c"12345678\00"
 428 // CHECK-NEXT: @e = global %struct.PR69979 { ptr @.str.[[STR]] }
 429 // CHECK: @_ZGRZN20InlineStaticConstRef3funEvE1i_ = linkonce_odr constant i32 10, comdat
 430 // CHECK20: @_ZZN12LocalVarInit4dtorEvE1a = internal constant {{.*}} i32 103
 431
 432 // Constant initialization tests go before this point,
 433 // dynamic initialization tests go after.
 434
 435 // We must emit a constant initializer for NonLiteralConstexpr::ntd, but also
 436 // emit an initializer to register its destructor.
 437 // CHECK: define {{.*}}cxx_global_var_init{{.*}}
 438 // CHECK-NOT: NonLiteralConstexpr
 439 // CHECK: call {{.*}}cxa_atexit(ptr @_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev, ptr @_ZN19NonLiteralConstexpr3ntdE
 440 // CHECK-NEXT: ret void
 441
 442 // We don't need to emit any dynamic initialization for NonLiteralConstexpr::vm.
 443 // CHECK-NOT: NonLiteralConstexpr2vm
 444
 445 // We must emit a constant initializer for NonLiteralConstexpr::b, but also
 446 // emit an initializer to register its destructor.
 447 // CHECK: define {{.*}}cxx_global_var_init{{.*}}
 448 // CHECK-NOT: NonLiteralConstexpr
 449 // CHECK: call {{.*}}cxa_atexit(ptr @_ZN19NonLiteralConstexpr4BothD1Ev, ptr @_ZN19NonLiteralConstexpr1bE
 450 // CHECK-NEXT: ret void
 451
 452 // CHECK: define {{.*}}NonLiteralConstexpr10StaticVars
 453 // CHECK-NOT: }
 454 // CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev
 455 // CHECK-NOT: }
 456 // CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr4BothD1Ev
 457
 458 // PR12848: Don't emit dynamic initializers for local constexpr variables.
 459 namespace LocalVarInit {
 460   constexpr int f(int n) { return n; }
 461   struct Agg { int k; };
 462   struct Ctor { constexpr Ctor(int n) : k(n) {} int k; };
 463   struct Mutable { constexpr Mutable(int n) : k(n) {} mutable int k; };
 464
 465   // CHECK: define {{.*}} @_ZN12LocalVarInit6scalarEv
 466   // CHECK-NOT: call
 467   // CHECK: store i32 100,
 468   // CHECK-NOT: call
 469   // CHECK: ret i32 100
 470   int scalar() { constexpr int a = { f(100) }; return a; }
 471
 472   // CHECK: define {{.*}} @_ZN12LocalVarInit3aggEv
 473   // CHECK-NOT: call
 474   // CHECK: ret i32 101
 475   int agg() { constexpr Agg a = { f(101) }; return a.k; }
 476
 477   // CHECK: define {{.*}} @_ZN12LocalVarInit4ctorEv
 478   // CHECK-NOT: call
 479   // CHECK: ret i32 102
 480   int ctor() { constexpr Ctor a = { f(102) }; return a.k; }
 481
 482   // CHECK: define {{.*}} @_ZN12LocalVarInit8mutable_Ev
 483   // CHECK-NOT: call
 484   // CHECK: call {{.*}}memcpy{{.*}} @__const._ZN12LocalVarInit8mutable_Ev.a
 485   // CHECK-NOT: call
 486   // Can't fold return value due to 'mutable'.
 487   // CHECK-NOT: ret i32 103
 488   // CHECK: }
 489   int mutable_() { constexpr Mutable a = { f(103) }; return a.k; }
 490
 491 #if __cplusplus >= 202002L
 492   // CHECK20: define {{.*}} @_ZN12LocalVarInit4dtorEv
 493   // CHECK20-NOT: call
 494   // CHECK20: ret i32 103
 495   struct Dtor { constexpr Dtor(int n) : k(n) {} constexpr ~Dtor() {} int k; };
 496   int dtor() { constexpr Dtor a = { f(103) }; return a.k; }
 497 #endif
 498 }
 499
 500 namespace CrossFuncLabelDiff {
 501   // Make sure we refuse to constant-fold the variable b.
 502   constexpr long a(bool x) { return x ? 0 : (long)&&lbl + (0 && ({lbl: 0;})); }
 503   void test() { static long b = (long)&&lbl - a(false); lbl: return; }
 504   // CHECK: sub nsw i64 ptrtoint (ptr blockaddress(@_ZN18CrossFuncLabelDiff4testEv, {{.*}}) to i64),
 505   // CHECK: store i64 {{.*}}, ptr @_ZZN18CrossFuncLabelDiff4testEvE1b, align 8
 506 }
 507
 508 // PR12012
 509 namespace VirtualBase {
 510   struct B {};
 511   struct D : virtual B {};
 512   D d;
 513   // CHECK: call {{.*}}@_ZN11VirtualBase1DC1Ev
 514
 515   template<typename T> struct X : T {
 516     constexpr X() : T() {}
 517   };
 518   X<D> x;
 519   // CHECK: call {{.*}}@_ZN11VirtualBase1XINS_1DEEC1Ev
 520 }
 521
 522 // PR12145
 523 namespace Unreferenced {
 524   int n;
 525   constexpr int *p = &n;
 526   // We must not emit a load of 'p' here, since it's not odr-used.
 527   int q = *p;
 528   // CHECK-NOT: _ZN12Unreferenced1pE
 529   // CHECK: = load i32, ptr @_ZN12Unreferenced1nE
 530   // CHECK-NEXT: store i32 {{.*}}, ptr @_ZN12Unreferenced1qE
 531   // CHECK-NOT: _ZN12Unreferenced1pE
 532
 533   // Technically, we are not required to substitute variables of reference types
 534   // initialized by constant expressions, because the special case for odr-use
 535   // of variables in [basic.def.odr]p2 only applies to objects. But we do so
 536   // anyway.
 537
 538   constexpr int &r = n;
 539   // CHECK-NOT: _ZN12Unreferenced1rE
 540   int s = r;
 541
 542   const int t = 1;
 543   const int &rt = t;
 544   int f(int);
 545   int u = f(rt);
 546   // CHECK: call noundef i32 @_ZN12Unreferenced1fEi(i32 noundef 1)
 547 }
 548
 549 namespace InitFromConst {
 550   template<typename T> void consume(T);
 551
 552   const bool b = true;
 553   const int n = 5;
 554   constexpr double d = 4.3;
 555
 556   struct S { int n = 7; S *p = 0; };
 557   constexpr S s = S();
 558   const S &r = s;
 559   constexpr const S *p = &r;
 560   constexpr int S::*mp = &S::n;
 561   constexpr int a[3] = { 1, 4, 9 };
 562
 563   void test() {
 564     // CHECK: call void @_ZN13InitFromConst7consumeIbEEvT_(i1 noundef zeroext true)
 565     consume(b);
 566
 567     // CHECK: call void @_ZN13InitFromConst7consumeIiEEvT_(i32 noundef 5)
 568     consume(n);
 569
 570     // CHECK: call void @_ZN13InitFromConst7consumeIdEEvT_(double noundef 4.300000e+00)
 571     consume(d);
 572
 573     // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(ptr noundef nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) @_ZN13InitFromConstL1sE)
 574     consume<const S&>(s);
 575
 576     // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(ptr noundef nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) @_ZN13InitFromConstL1sE)
 577     consume<const S&>(r);
 578
 579     // CHECK: call void @_ZN13InitFromConst7consumeIPKNS_1SEEEvT_(ptr noundef @_ZN13InitFromConstL1sE)
 580     consume(p);
 581
 582     // CHECK: call void @_ZN13InitFromConst7consumeIMNS_1SEiEEvT_(i64 0)
 583     consume(mp);
 584
 585     // CHECK: call void @_ZN13InitFromConst7consumeIPKiEEvT_(ptr noundef @_ZN13InitFromConstL1aE)
 586     consume(a);
 587   }
 588 }
 589
 590 namespace Null {
 591   decltype(nullptr) null();
 592   // CHECK: call {{.*}} @_ZN4Null4nullEv(
 593   int *p = null();
 594   struct S {};
 595   // CHECK: call {{.*}} @_ZN4Null4nullEv(
 596   int S::*q = null();
 597 }
 598
 599 namespace InlineStaticConstRef {
 600   inline const int &fun() {
 601     static const int &i = 10;
 602     return i;
 603     // CHECK: ret ptr @_ZGRZN20InlineStaticConstRef3funEvE1i_
 604   }
 605   const int &use = fun();
 606 }
 607
 608 namespace ClassTemplateWithStaticDataMember {
 609   template <typename T>
 610   struct S {
 611     static const int &a;
 612   };
 613   template <typename T>
 614   const int &S<T>::a = 5;
 615   const int &use = S<void>::a;
 616 }
 617
 618 namespace ClassTemplateWithHiddenStaticDataMember {
 619   template <typename T>
 620   struct S {
 621     __attribute__((visibility("hidden"))) static const int &a;
 622   };
 623   template <typename T>
 624   const int &S<T>::a = 5;
 625   const int &use = S<void>::a;
 626 }
 627
 628 namespace ClassWithStaticConstexprDataMember {
 629 struct X {
 630   static constexpr const char &p = 'c';
 631 };
 632
 633 // CHECK: @_ZGRN34ClassWithStaticConstexprDataMember1X1pE_
 634 const char *f() { return &X::p; }
 635 }
 636
 637 struct PR69979 {
 638   const char (&d)[9];
 639 } e {"12345678"};
 640
 641 // VirtualMembers::TemplateClass::templateMethod() must be defined in this TU,
 642 // not just declared.
 643 // CHECK: define linkonce_odr void @_ZN14VirtualMembers13TemplateClassIiE14templateMethodEv(ptr {{[^,]*}} %this)