503 lines · cpp
1// RUN: %clang_cc1 -std=c++11 -triple x86_64-none-linux-gnu -fmerge-all-constants -emit-llvm -o - %s | FileCheck -check-prefixes=X86,CHECK %s2// RUN: %clang_cc1 -std=c++11 -triple amdgcn-amd-amdhsa -DNO_TLS -fmerge-all-constants -emit-llvm -o - %s | FileCheck -check-prefixes=AMDGCN,CHECK %s3 4namespace std {5 typedef decltype(sizeof(int)) size_t;6 7 // libc++'s implementation8 template <class _E>9 class initializer_list10 {11 const _E* __begin_;12 size_t __size_;13 14 initializer_list(const _E* __b, size_t __s)15 : __begin_(__b),16 __size_(__s)17 {}18 19 public:20 typedef _E value_type;21 typedef const _E& reference;22 typedef const _E& const_reference;23 typedef size_t size_type;24 25 typedef const _E* iterator;26 typedef const _E* const_iterator;27 28 initializer_list() : __begin_(nullptr), __size_(0) {}29 30 size_t size() const {return __size_;}31 const _E* begin() const {return __begin_;}32 const _E* end() const {return __begin_ + __size_;}33 };34}35 36struct destroyme1 {37 ~destroyme1();38};39struct destroyme2 {40 ~destroyme2();41};42struct witharg1 {43 witharg1(const destroyme1&);44 ~witharg1();45};46struct wantslist1 {47 wantslist1(std::initializer_list<destroyme1>);48 ~wantslist1();49};50// X86: @_ZGR15globalInitList1_ = internal constant [3 x i32] [i32 1, i32 2, i32 3]51// X86: @globalInitList1 ={{.*}} global %{{[^ ]+}} { ptr @_ZGR15globalInitList1_, i{{32|64}} 3 }52// AMDGCN: @_ZGR15globalInitList1_ = internal addrspace(1) constant [3 x i32] [i32 1, i32 2, i32 3]53// AMDGCN: @globalInitList1 ={{.*}} addrspace(1) global %{{[^ ]+}} { ptr addrspacecast (ptr addrspace(1) @_ZGR15globalInitList1_ to ptr), i{{32|64}} 3 }54std::initializer_list<int> globalInitList1 = {1, 2, 3};55 56#ifndef NO_TLS57namespace thread_local_global_array {58// FIXME: We should be able to constant-evaluate this even though the59// initializer is not a constant expression (pointers to thread_local60// objects aren't really a problem).61//62// X86: @_ZN25thread_local_global_array1xE ={{.*}} thread_local global63// X86: @_ZGRN25thread_local_global_array1xE_ = internal thread_local constant [4 x i32] [i32 1, i32 2, i32 3, i32 4]64std::initializer_list<int> thread_local x = {1, 2, 3, 4};65}66#endif67 68// X86: @globalInitList2 ={{.*}} global %{{[^ ]+}} zeroinitializer69// X86: @_ZGR15globalInitList2_ = internal global [2 x %[[WITHARG:[^ ]*]]] zeroinitializer70// AMDGCN: @globalInitList2 ={{.*}} addrspace(1) global %{{[^ ]+}} zeroinitializer71// AMDGCN: @_ZGR15globalInitList2_ = internal addrspace(1) global [2 x %[[WITHARG:[^ ]*]]] zeroinitializer72 73// X86: @_ZN15partly_constant1kE ={{.*}} global i32 0, align 474// X86: @_ZN15partly_constant2ilE ={{.*}} global {{.*}} null, align 875// X86: @[[PARTLY_CONSTANT_OUTER:_ZGRN15partly_constant2ilE_]] = internal global {{.*}} zeroinitializer, align 876// X86: @[[PARTLY_CONSTANT_INNER:_ZGRN15partly_constant2ilE0_]] = internal global [3 x {{.*}}] zeroinitializer, align 877// X86: @[[PARTLY_CONSTANT_FIRST:_ZGRN15partly_constant2ilE1_]] = internal constant [3 x i32] [i32 1, i32 2, i32 3], align 478// X86: @[[PARTLY_CONSTANT_SECOND:_ZGRN15partly_constant2ilE2_]] = internal global [2 x i32] zeroinitializer, align 479// X86: @[[PARTLY_CONSTANT_THIRD:_ZGRN15partly_constant2ilE3_]] = internal constant [4 x i32] [i32 5, i32 6, i32 7, i32 8], align 480// AMDGCN: @_ZN15partly_constant1kE ={{.*}} addrspace(1) global i32 0, align 481// AMDGCN: @_ZN15partly_constant2ilE ={{.*}} addrspace(1) global {{.*}} null, align 882// AMDGCN: @[[PARTLY_CONSTANT_OUTER:_ZGRN15partly_constant2ilE_]] = internal addrspace(1) global {{.*}} zeroinitializer, align 883// AMDGCN: @[[PARTLY_CONSTANT_INNER:_ZGRN15partly_constant2ilE0_]] = internal addrspace(1) global [3 x {{.*}}] zeroinitializer, align 884// AMDGCN: @[[PARTLY_CONSTANT_FIRST:_ZGRN15partly_constant2ilE1_]] = internal addrspace(1) constant [3 x i32] [i32 1, i32 2, i32 3], align 485// AMDGCN: @[[PARTLY_CONSTANT_SECOND:_ZGRN15partly_constant2ilE2_]] = internal addrspace(1) global [2 x i32] zeroinitializer, align 486// AMDGCN: @[[PARTLY_CONSTANT_THIRD:_ZGRN15partly_constant2ilE3_]] = internal addrspace(1) constant [4 x i32] [i32 5, i32 6, i32 7, i32 8], align 487 88// X86: @[[REFTMP1:.*]] = private constant [2 x i32] [i32 42, i32 43], align 489// X86: @[[REFTMP2:.*]] = private constant [3 x %{{.*}}] [%{{.*}} { i32 1 }, %{{.*}} { i32 2 }, %{{.*}} { i32 3 }], align 490// AMDGCN: @[[REFTMP1:.*]] = private addrspace(4) constant [2 x i32] [i32 42, i32 43], align 491// AMDGCN: @[[REFTMP2:.*]] = private addrspace(4) constant [3 x %{{.*}}] [%{{.*}} { i32 1 }, %{{.*}} { i32 2 }, %{{.*}} { i32 3 }], align 492 93// CHECK: appending global94 95// thread_local initializer:96// X86-LABEL: define internal void @__cxx_global_var_init97// X86: [[ADDR:%.*]] = call {{.*}} ptr @llvm.threadlocal.address.p0(ptr {{.*}} @_ZN25thread_local_global_array1xE)98// X86: store ptr @_ZGRN25thread_local_global_array1xE_, ptr [[ADDR]], align 899// X86: store i64 4, ptr getelementptr inbounds nuw ({{.*}}, ptr @_ZN25thread_local_global_array1xE, i32 0, i32 1), align 8100 101// CHECK-LABEL: define internal void @__cxx_global_var_init102// X86: call void @_ZN8witharg1C1ERK10destroyme1(ptr {{[^,]*}} @_ZGR15globalInitList2_103// X86: call void @_ZN8witharg1C1ERK10destroyme1(ptr {{[^,]*}} getelementptr inbounds (%[[WITHARG]], ptr @_ZGR15globalInitList2_, i{{32|64}} 1)104// AMDGCN: call void @_ZN8witharg1C1ERK10destroyme1(ptr {{[^,]*}} addrspacecast ({{[^@]+}} @_ZGR15globalInitList2_ {{[^)]+}}105// AMDGCN: call void @_ZN8witharg1C1ERK10destroyme1(ptr {{[^,]*}} getelementptr inbounds (%[[WITHARG]], ptr addrspacecast ({{[^@]+}} @_ZGR15globalInitList2_ {{[^)]+}}), i{{32|64}} 1106// CHECK: call i32 @__cxa_atexit107// X86: store ptr @_ZGR15globalInitList2_, ptr @globalInitList2, align 8108// X86: store i64 2, ptr getelementptr inbounds nuw (%{{.*}}, ptr @globalInitList2, i32 0, i32 1), align 8109// AMDGCN: store ptr addrspacecast ({{[^@]+}} @_ZGR15globalInitList2_ {{[^)]+}}),110// AMDGCN: ptr addrspacecast ({{[^@]+}} @globalInitList2 {{[^)]+}}), align 8111// AMDGCN: store i64 2, ptr getelementptr inbounds nuw (%{{.*}}, ptr addrspacecast ({{[^@]+}} @globalInitList2 {{[^)]+}}), i32 0, i32 1), align 8112// CHECK: call void @_ZN10destroyme1D1Ev113// CHECK-NEXT: call void @_ZN10destroyme1D1Ev114// CHECK-NEXT: ret void115std::initializer_list<witharg1> globalInitList2 = {116 witharg1(destroyme1()), witharg1(destroyme1())117};118 119void fn1(int i) {120 // CHECK-LABEL: define{{.*}} void @_Z3fn1i121 // temporary array122 // X86: [[array:%[^ ]+]] = alloca [3 x i32]123 // AMDGCN: [[alloca:%[^ ]+]] = alloca [3 x i32], align 4, addrspace(5)124 // AMDGCN: [[array:%[^ ]+]] ={{.*}} addrspacecast ptr addrspace(5) [[alloca]] to ptr125 // CHECK: store i32 1, ptr126 // CHECK-NEXT: getelementptr127 // CHECK-NEXT: store128 // CHECK-NEXT: getelementptr129 // CHECK-NEXT: load130 // CHECK-NEXT: store131 // init the list132 // CHECK-NEXT: getelementptr133 // CHECK-NEXT: store ptr134 // CHECK-NEXT: getelementptr135 // CHECK-NEXT: store i{{32|64}} 3136 std::initializer_list<int> intlist{1, 2, i};137}138 139void fn2() {140 // CHECK-LABEL: define{{.*}} void @_Z3fn2v141 void target(std::initializer_list<destroyme1>);142 // objects should be destroyed before dm2, after call returns143 // CHECK: call void @_Z6targetSt16initializer_listI10destroyme1E144 target({ destroyme1(), destroyme1() });145 // CHECK: call void @_ZN10destroyme1D1Ev146 destroyme2 dm2;147 // CHECK: call void @_ZN10destroyme2D1Ev148}149 150void fn3() {151 // CHECK-LABEL: define{{.*}} void @_Z3fn3v152 // objects should be destroyed after dm2153 auto list = { destroyme1(), destroyme1() };154 destroyme2 dm2;155 // CHECK: call void @_ZN10destroyme2D1Ev156 // CHECK: call void @_ZN10destroyme1D1Ev157}158 159void fn4() {160 // CHECK-LABEL: define{{.*}} void @_Z3fn4v161 void target(std::initializer_list<witharg1>);162 // objects should be destroyed before dm2, after call returns163 // CHECK: call void @_ZN8witharg1C1ERK10destroyme1164 // CHECK: call void @_Z6targetSt16initializer_listI8witharg1E165 target({ witharg1(destroyme1()), witharg1(destroyme1()) });166 // CHECK: call void @_ZN8witharg1D1Ev167 // CHECK: call void @_ZN10destroyme1D1Ev168 destroyme2 dm2;169 // CHECK: call void @_ZN10destroyme2D1Ev170}171 172void fn5() {173 // CHECK-LABEL: define{{.*}} void @_Z3fn5v174 // temps should be destroyed before dm2175 // objects should be destroyed after dm2176 // CHECK: call void @_ZN8witharg1C1ERK10destroyme1177 auto list = { witharg1(destroyme1()), witharg1(destroyme1()) };178 // CHECK: call void @_ZN10destroyme1D1Ev179 destroyme2 dm2;180 // CHECK: call void @_ZN10destroyme2D1Ev181 // CHECK: call void @_ZN8witharg1D1Ev182}183 184void fn6() {185 // CHECK-LABEL: define{{.*}} void @_Z3fn6v186 void target(const wantslist1&);187 // objects should be destroyed before dm2, after call returns188 // CHECK: call void @_ZN10wantslist1C1ESt16initializer_listI10destroyme1E189 // CHECK: call void @_Z6targetRK10wantslist1190 target({ destroyme1(), destroyme1() });191 // CHECK: call void @_ZN10wantslist1D1Ev192 // CHECK: call void @_ZN10destroyme1D1Ev193 destroyme2 dm2;194 // CHECK: call void @_ZN10destroyme2D1Ev195}196void fn7() {197 // CHECK-LABEL: define{{.*}} void @_Z3fn7v198 // temps should be destroyed before dm2199 // object should be destroyed after dm2200 // CHECK: call void @_ZN10wantslist1C1ESt16initializer_listI10destroyme1E201 wantslist1 wl = { destroyme1(), destroyme1() };202 // CHECK: call void @_ZN10destroyme1D1Ev203 destroyme2 dm2;204 // CHECK: call void @_ZN10destroyme2D1Ev205 // CHECK: call void @_ZN10wantslist1D1Ev206}207 208void fn8() {209 // CHECK-LABEL: define{{.*}} void @_Z3fn8v210 void target(std::initializer_list<std::initializer_list<destroyme1>>);211 // objects should be destroyed before dm2, after call returns212 // CHECK: call void @_Z6targetSt16initializer_listIS_I10destroyme1EE213 std::initializer_list<destroyme1> inner;214 target({ inner, { destroyme1() } });215 // CHECK: call void @_ZN10destroyme1D1Ev216 // Only one destroy loop, since only one inner init list is directly inited.217 // CHECK-NOT: call void @_ZN10destroyme1D1Ev218 destroyme2 dm2;219 // CHECK: call void @_ZN10destroyme2D1Ev220}221 222void fn9() {223 // CHECK-LABEL: define{{.*}} void @_Z3fn9v224 // objects should be destroyed after dm2225 std::initializer_list<destroyme1> inner;226 std::initializer_list<std::initializer_list<destroyme1>> list =227 { inner, { destroyme1() } };228 destroyme2 dm2;229 // CHECK: call void @_ZN10destroyme2D1Ev230 // CHECK: call void @_ZN10destroyme1D1Ev231 // Only one destroy loop, since only one inner init list is directly inited.232 // CHECK-NOT: call void @_ZN10destroyme1D1Ev233 // CHECK: ret void234}235 236void fn10(int i) {237 // CHECK-LABEL: define{{.*}} void @_Z4fn10i238 // CHECK: alloca [3 x i32]239 // CHECK-X86: call noalias nonnull align 16 ptr @_Znw{{[jm]}}240 // CHECK-AMDGPU: call noalias nonnull align 8 ptr @_Znw{{[jm]}}241 // CHECK: store i32 %242 // CHECK: store i32 2243 // CHECK: store i32 3244 // CHECK: store ptr245 (void) new std::initializer_list<int> {i, 2, 3};246}247 248void fn11() {249 // CHECK-LABEL: define{{.*}} void @_Z4fn11v250 (void) new std::initializer_list<destroyme1> {destroyme1(), destroyme1()};251 // CHECK: call void @_ZN10destroyme1D1Ev252 destroyme2 dm2;253 // CHECK: call void @_ZN10destroyme2D1Ev254}255 256namespace PR12178 {257 struct string {258 string(int);259 ~string();260 };261 262 struct pair {263 string a;264 int b;265 };266 267 struct map {268 map(std::initializer_list<pair>);269 };270 271 map m{ {1, 2}, {3, 4} };272}273 274namespace rdar13325066 {275 struct X { ~X(); };276 277 // CHECK-LABEL: define{{.*}} void @_ZN12rdar133250664loopERNS_1XES1_278 void loop(X &x1, X &x2) {279 // CHECK: br label280 // CHECK: br i1281 // CHECK: br label282 // CHECK: call void @_ZN12rdar133250661XD1Ev283 // CHECK: br label284 // CHECK: br label285 // CHECK: call void @_ZN12rdar133250661XD1Ev286 // CHECK: br i1287 // CHECK: br label288 // CHECK: ret void289 for (X x : { x1, x2 }) { }290 }291}292 293namespace dtors {294 struct S {295 S();296 ~S();297 };298 void z();299 300 // CHECK-LABEL: define{{.*}} void @_ZN5dtors1fEv(301 void f() {302 // CHECK: call void @_ZN5dtors1SC1Ev(303 // CHECK: call void @_ZN5dtors1SC1Ev(304 std::initializer_list<S>{ S(), S() };305 306 // Destruction loop for underlying array.307 // CHECK: br label308 // CHECK: call void @_ZN5dtors1SD1Ev(309 // CHECK: br i1310 311 // CHECK: call void @_ZN5dtors1zEv(312 z();313 314 // CHECK-NOT: call void @_ZN5dtors1SD1Ev(315 }316 317 // CHECK-LABEL: define{{.*}} void @_ZN5dtors1gEv(318 void g() {319 // CHECK: call void @_ZN5dtors1SC1Ev(320 // CHECK: call void @_ZN5dtors1SC1Ev(321 auto x = std::initializer_list<S>{ S(), S() };322 323 // Destruction loop for underlying array.324 // CHECK: br label325 // CHECK: call void @_ZN5dtors1SD1Ev(326 // CHECK: br i1327 328 // CHECK: call void @_ZN5dtors1zEv(329 z();330 331 // CHECK-NOT: call void @_ZN5dtors1SD1Ev(332 }333 334 // CHECK-LABEL: define{{.*}} void @_ZN5dtors1hEv(335 void h() {336 // CHECK: call void @_ZN5dtors1SC1Ev(337 // CHECK: call void @_ZN5dtors1SC1Ev(338 std::initializer_list<S> x = { S(), S() };339 340 // CHECK-NOT: call void @_ZN5dtors1SD1Ev(341 342 // CHECK: call void @_ZN5dtors1zEv(343 z();344 345 // Destruction loop for underlying array.346 // CHECK: br label347 // CHECK: call void @_ZN5dtors1SD1Ev(348 // CHECK: br i1349 }350}351 352namespace partly_constant {353 int k;354 std::initializer_list<std::initializer_list<int>> &&il = { { 1, 2, 3 }, { 4, k }, { 5, 6, 7, 8 } };355 // First init list.356 // CHECK-NOT: @[[PARTLY_CONSTANT_FIRST]],357 // CHECK: store ptr {{.*}}@[[PARTLY_CONSTANT_FIRST]]{{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}358 // CHECK: store i64 3, ptr getelementptr inbounds nuw ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}, i32 0, i32 1)359 // CHECK-NOT: @[[PARTLY_CONSTANT_FIRST]],360 //361 // Second init list array (non-constant).362 // CHECK: store i32 4, ptr {{.*}}@[[PARTLY_CONSTANT_SECOND]]{{.*}}363 // CHECK: load i32, ptr {{.*}}@_ZN15partly_constant1kE364 // CHECK: store i32 {{.*}}, ptr getelementptr inbounds ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_SECOND]]{{.*}}, i64 1)365 //366 // Second init list.367 // CHECK: store ptr {{.*}}@[[PARTLY_CONSTANT_SECOND]]{{.*}}, ptr getelementptr inbounds ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}, i64 1)368 // CHECK: store i64 2, ptr getelementptr inbounds nuw ({{.*}}, ptr getelementptr inbounds ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}, i64 1), i32 0, i32 1)369 //370 // Third init list.371 // CHECK-NOT: @[[PARTLY_CONSTANT_THIRD]],372 // CHECK: store ptr {{.*}}@[[PARTLY_CONSTANT_THIRD]]{{.*}}, ptr getelementptr inbounds ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}, i64 2)373 // CHECK: store i64 4, ptr getelementptr inbounds nuw ({{.*}}, ptr getelementptr inbounds ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}, i64 2), i32 0, i32 1)374 // CHECK-NOT: @[[PARTLY_CONSTANT_THIRD]],375 //376 // Outer init list.377 // CHECK: store ptr {{.*}}@[[PARTLY_CONSTANT_INNER]]{{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_OUTER]]{{.*}}378 // CHECK: store i64 3, ptr getelementptr inbounds nuw ({{.*}}, ptr {{.*}}@[[PARTLY_CONSTANT_OUTER]]{{.*}}, i32 0, i32 1)379 //380 // 'il' reference.381 // CHECK: store ptr {{.*}}@[[PARTLY_CONSTANT_OUTER]]{{.*}}, ptr {{.*}}@_ZN15partly_constant2ilE{{.*}}, align 8382}383namespace nested {384 struct A { A(); ~A(); };385 struct B { const A &a; ~B(); };386 struct C { std::initializer_list<B> b; ~C(); };387 void f();388 // CHECK-LABEL: define{{.*}} void @_ZN6nested1gEv(389 void g() {390 // CHECK: call void @_ZN6nested1AC1Ev(391 // CHECK-NOT: call392 // CHECK: call void @_ZN6nested1AC1Ev(393 // CHECK-NOT: call394 const C &c { { { A() }, { A() } } };395 396 // CHECK: call void @_ZN6nested1fEv(397 // CHECK-NOT: call398 f();399 400 // CHECK: call void @_ZN6nested1CD1Ev(401 // CHECK-NOT: call402 403 // Destroy B[2] array.404 // FIXME: This isn't technically correct: reverse construction order would405 // destroy the second B then the second A then the first B then the first A.406 // CHECK: call void @_ZN6nested1BD1Ev(407 // CHECK-NOT: call408 // CHECK: br409 410 // CHECK-NOT: call411 // CHECK: call void @_ZN6nested1AD1Ev(412 // CHECK-NOT: call413 // CHECK: call void @_ZN6nested1AD1Ev(414 // CHECK-NOT: call415 // CHECK: }416 }417}418 419namespace DR1070 {420 struct A {421 A(std::initializer_list<int>);422 };423 struct B {424 int i;425 A a;426 };427 B b = {1};428 struct C {429 std::initializer_list<int> a;430 B b;431 std::initializer_list<double> c;432 };433 C c = {};434}435 436namespace ArrayOfInitList {437 struct S {438 S(std::initializer_list<int>);439 };440 S x[1] = {};441}442 443namespace PR20445 {444 struct vector { vector(std::initializer_list<int>); };445 struct MyClass { explicit MyClass(const vector &v); };446 template<int x> void f() { new MyClass({42, 43}); }447 template void f<0>();448 // CHECK-LABEL: define {{.*}} @_ZN7PR204451fILi0EEEvv(449 // CHECK: store ptr {{.*}}@[[REFTMP1]]{{.*}}450 // CHECK: call void @_ZN7PR204456vectorC1ESt16initializer_listIiE(451 // CHECK: call void @_ZN7PR204457MyClassC1ERKNS_6vectorE(452}453 454namespace ConstExpr {455 class C {456 int x;457 public:458 constexpr C(int x) : x(x) {}459 };460 void f(std::initializer_list<C>);461 void g() {462 // CHECK-LABEL: _ZN9ConstExpr1gEv463 // CHECK: store ptr {{.*}}@[[REFTMP2]]{{.*}}464 // CHECK: call void @_ZN9ConstExpr1fESt16initializer_listINS_1CEE465 f({C(1), C(2), C(3)});466 }467}468 469namespace B19773010 {470 template <class T1, class T2> struct pair {471 T1 first;472 T2 second;473 constexpr pair() : first(), second() {}474 constexpr pair(T1 a, T2 b) : first(a), second(b) {}475 };476 477 enum E { ENUM_CONSTANT };478 struct testcase {479 testcase(std::initializer_list<pair<const char *, E>>);480 };481 void f1() {482 // CHECK-LABEL: @_ZN9B197730102f1Ev483 testcase a{{"", ENUM_CONSTANT}};484 // X86: store ptr @.ref.tmp{{.*}}, ptr %{{.*}}, align 8485 // AMDGCN: store ptr addrspacecast{{.*}} @.ref.tmp{{.*}}{{.*}}, ptr %{{.*}}, align 8486 }487 void f2() {488 // CHECK-LABEL: @_ZN9B197730102f2Ev489 // X86: store ptr @_ZGRZN9B197730102f2EvE1p_, ptr getelementptr inbounds (%"class.std::initializer_list.10", ptr @_ZZN9B197730102f2EvE1p, i64 1), align 16490 // AMDGCN: store ptr addrspacecast{{.*}} @_ZGRZN9B197730102f2EvE1p_{{.*}}, ptr getelementptr inbounds (%"class.std::initializer_list.10", ptr addrspacecast{{.*}}@_ZZN9B197730102f2EvE1p{{.*}}, i64 1), align 8491 static std::initializer_list<pair<const char *, E>> a, p[2] =492 {a, {{"", ENUM_CONSTANT}}};493 }494 495 void PR22940_helper(const pair<void*, int>&) { }496 void PR22940() {497 // CHECK-LABEL: @_ZN9B197730107PR22940Ev498 // CHECK: call {{.*}} @_ZN9B197730104pairIPviEC{{.}}Ev(499 // CHECK: call {{.*}} @_ZN9B1977301014PR22940_helperERKNS_4pairIPviEE(500 PR22940_helper(pair<void*, int>());501 }502}503