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 %s 2 // RUN: %clang_cc1 -std=c++11 -triple amdgcn-amd-amdhsa -DNO_TLS -fmerge-all-constants -emit-llvm -o - %s | FileCheck -check-prefixes=AMDGCN,CHECK %s 3 4 namespace std { 5 typedef decltype(sizeof(int)) size_t; 6 7 // libc++'s implementation 8 template <class _E> 9 class initializer_list 10 { 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 36 struct destroyme1 { 37 ~destroyme1(); 38 }; 39 struct destroyme2 { 40 ~destroyme2(); 41 }; 42 struct witharg1 { 43 witharg1(const destroyme1&); 44 ~witharg1(); 45 }; 46 struct 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 } 54 std::initializer_list<int> globalInitList1 = {1, 2, 3}; 55 56 #ifndef NO_TLS 57 namespace thread_local_global_array { 58 // FIXME: We should be able to constant-evaluate this even though the 59 // initializer is not a constant expression (pointers to thread_local 60 // objects aren't really a problem). 61 // 62 // X86: @_ZN25thread_local_global_array1xE ={{.*}} thread_local global 63 // X86: @_ZGRN25thread_local_global_array1xE_ = internal thread_local constant [4 x i32] [i32 1, i32 2, i32 3, i32 4] 64 std::initializer_list<int> thread_local x = {1, 2, 3, 4}; 65 } 66 #endif 67 68 // X86: @globalInitList2 ={{.*}} global %{{[^ ]+}} zeroinitializer 69 // X86: @_ZGR15globalInitList2_ = internal global [2 x %[[WITHARG:[^ ]*]]] zeroinitializer 70 // AMDGCN: @globalInitList2 ={{.*}} addrspace(1) global %{{[^ ]+}} zeroinitializer 71 // AMDGCN: @_ZGR15globalInitList2_ = internal addrspace(1) global [2 x %[[WITHARG:[^ ]*]]] zeroinitializer 72 73 // X86: @_ZN15partly_constant1kE ={{.*}} global i32 0, align 4 74 // X86: @_ZN15partly_constant2ilE ={{.*}} global {{.*}} null, align 8 75 // X86: @[[PARTLY_CONSTANT_OUTER:_ZGRN15partly_constant2ilE_]] = internal global {{.*}} zeroinitializer, align 8 76 // X86: @[[PARTLY_CONSTANT_INNER:_ZGRN15partly_constant2ilE0_]] = internal global [3 x {{.*}}] zeroinitializer, align 8 77 // X86: @[[PARTLY_CONSTANT_FIRST:_ZGRN15partly_constant2ilE1_]] = internal constant [3 x i32] [i32 1, i32 2, i32 3], align 4 78 // X86: @[[PARTLY_CONSTANT_SECOND:_ZGRN15partly_constant2ilE2_]] = internal global [2 x i32] zeroinitializer, align 4 79 // X86: @[[PARTLY_CONSTANT_THIRD:_ZGRN15partly_constant2ilE3_]] = internal constant [4 x i32] [i32 5, i32 6, i32 7, i32 8], align 4 80 // AMDGCN: @_ZN15partly_constant1kE ={{.*}} addrspace(1) global i32 0, align 4 81 // AMDGCN: @_ZN15partly_constant2ilE ={{.*}} addrspace(1) global {{.*}} null, align 8 82 // AMDGCN: @[[PARTLY_CONSTANT_OUTER:_ZGRN15partly_constant2ilE_]] = internal addrspace(1) global {{.*}} zeroinitializer, align 8 83 // AMDGCN: @[[PARTLY_CONSTANT_INNER:_ZGRN15partly_constant2ilE0_]] = internal addrspace(1) global [3 x {{.*}}] zeroinitializer, align 8 84 // AMDGCN: @[[PARTLY_CONSTANT_FIRST:_ZGRN15partly_constant2ilE1_]] = internal addrspace(1) constant [3 x i32] [i32 1, i32 2, i32 3], align 4 85 // AMDGCN: @[[PARTLY_CONSTANT_SECOND:_ZGRN15partly_constant2ilE2_]] = internal addrspace(1) global [2 x i32] zeroinitializer, align 4 86 // AMDGCN: @[[PARTLY_CONSTANT_THIRD:_ZGRN15partly_constant2ilE3_]] = internal addrspace(1) constant [4 x i32] [i32 5, i32 6, i32 7, i32 8], align 4 87 88 // X86: @[[REFTMP1:.*]] = private constant [2 x i32] [i32 42, i32 43], align 4 89 // X86: @[[REFTMP2:.*]] = private constant [3 x %{{.*}}] [%{{.*}} { i32 1 }, %{{.*}} { i32 2 }, %{{.*}} { i32 3 }], align 4 90 // AMDGCN: @[[REFTMP1:.*]] = private addrspace(4) constant [2 x i32] [i32 42, i32 43], align 4 91 // AMDGCN: @[[REFTMP2:.*]] = private addrspace(4) constant [3 x %{{.*}}] [%{{.*}} { i32 1 }, %{{.*}} { i32 2 }, %{{.*}} { i32 3 }], align 4 92 93 // CHECK: appending global 94 95 // thread_local initializer: 96 // X86-LABEL: define internal void @__cxx_global_var_init 97 // X86: [[ADDR:%.*]] = call {{.*}} ptr @llvm.threadlocal.address.p0(ptr {{.*}} @_ZN25thread_local_global_array1xE) 98 // X86: store ptr @_ZGRN25thread_local_global_array1xE_, ptr [[ADDR]], align 8 99 // X86: store i64 4, ptr getelementptr inbounds nuw ({{.*}}, ptr @_ZN25thread_local_global_array1xE, i32 0, i32 1), align 8 100 101 // CHECK-LABEL: define internal void @__cxx_global_var_init 102 // 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}} 1 106 // CHECK: call i32 @__cxa_atexit 107 // X86: store ptr @_ZGR15globalInitList2_, ptr @globalInitList2, align 8 108 // X86: store i64 2, ptr getelementptr inbounds nuw (%{{.*}}, ptr @globalInitList2, i32 0, i32 1), align 8 109 // AMDGCN: store ptr addrspacecast ({{[^@]+}} @_ZGR15globalInitList2_ {{[^)]+}}), 110 // AMDGCN: ptr addrspacecast ({{[^@]+}} @globalInitList2 {{[^)]+}}), align 8 111 // AMDGCN: store i64 2, ptr getelementptr inbounds nuw (%{{.*}}, ptr addrspacecast ({{[^@]+}} @globalInitList2 {{[^)]+}}), i32 0, i32 1), align 8 112 // CHECK: call void @_ZN10destroyme1D1Ev 113 // CHECK-NEXT: call void @_ZN10destroyme1D1Ev 114 // CHECK-NEXT: ret void 115 std::initializer_list<witharg1> globalInitList2 = { 116 witharg1(destroyme1()), witharg1(destroyme1()) 117 }; 118 119 void fn1(int i) { 120 // CHECK-LABEL: define{{.*}} void @_Z3fn1i 121 // temporary array 122 // 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 ptr 125 // CHECK: store i32 1, ptr 126 // CHECK-NEXT: getelementptr 127 // CHECK-NEXT: store 128 // CHECK-NEXT: getelementptr 129 // CHECK-NEXT: load 130 // CHECK-NEXT: store 131 // init the list 132 // CHECK-NEXT: getelementptr 133 // CHECK-NEXT: store ptr 134 // CHECK-NEXT: getelementptr 135 // CHECK-NEXT: store i{{32|64}} 3 136 std::initializer_list<int> intlist{1, 2, i}; 137 } 138 139 void fn2() { 140 // CHECK-LABEL: define{{.*}} void @_Z3fn2v 141 void target(std::initializer_list<destroyme1>); 142 // objects should be destroyed before dm2, after call returns 143 // CHECK: call void @_Z6targetSt16initializer_listI10destroyme1E 144 target({ destroyme1(), destroyme1() }); 145 // CHECK: call void @_ZN10destroyme1D1Ev 146 destroyme2 dm2; 147 // CHECK: call void @_ZN10destroyme2D1Ev 148 } 149 150 void fn3() { 151 // CHECK-LABEL: define{{.*}} void @_Z3fn3v 152 // objects should be destroyed after dm2 153 auto list = { destroyme1(), destroyme1() }; 154 destroyme2 dm2; 155 // CHECK: call void @_ZN10destroyme2D1Ev 156 // CHECK: call void @_ZN10destroyme1D1Ev 157 } 158 159 void fn4() { 160 // CHECK-LABEL: define{{.*}} void @_Z3fn4v 161 void target(std::initializer_list<witharg1>); 162 // objects should be destroyed before dm2, after call returns 163 // CHECK: call void @_ZN8witharg1C1ERK10destroyme1 164 // CHECK: call void @_Z6targetSt16initializer_listI8witharg1E 165 target({ witharg1(destroyme1()), witharg1(destroyme1()) }); 166 // CHECK: call void @_ZN8witharg1D1Ev 167 // CHECK: call void @_ZN10destroyme1D1Ev 168 destroyme2 dm2; 169 // CHECK: call void @_ZN10destroyme2D1Ev 170 } 171 172 void fn5() { 173 // CHECK-LABEL: define{{.*}} void @_Z3fn5v 174 // temps should be destroyed before dm2 175 // objects should be destroyed after dm2 176 // CHECK: call void @_ZN8witharg1C1ERK10destroyme1 177 auto list = { witharg1(destroyme1()), witharg1(destroyme1()) }; 178 // CHECK: call void @_ZN10destroyme1D1Ev 179 destroyme2 dm2; 180 // CHECK: call void @_ZN10destroyme2D1Ev 181 // CHECK: call void @_ZN8witharg1D1Ev 182 } 183 184 void fn6() { 185 // CHECK-LABEL: define{{.*}} void @_Z3fn6v 186 void target(const wantslist1&); 187 // objects should be destroyed before dm2, after call returns 188 // CHECK: call void @_ZN10wantslist1C1ESt16initializer_listI10destroyme1E 189 // CHECK: call void @_Z6targetRK10wantslist1 190 target({ destroyme1(), destroyme1() }); 191 // CHECK: call void @_ZN10wantslist1D1Ev 192 // CHECK: call void @_ZN10destroyme1D1Ev 193 destroyme2 dm2; 194 // CHECK: call void @_ZN10destroyme2D1Ev 195 } 196 void fn7() { 197 // CHECK-LABEL: define{{.*}} void @_Z3fn7v 198 // temps should be destroyed before dm2 199 // object should be destroyed after dm2 200 // CHECK: call void @_ZN10wantslist1C1ESt16initializer_listI10destroyme1E 201 wantslist1 wl = { destroyme1(), destroyme1() }; 202 // CHECK: call void @_ZN10destroyme1D1Ev 203 destroyme2 dm2; 204 // CHECK: call void @_ZN10destroyme2D1Ev 205 // CHECK: call void @_ZN10wantslist1D1Ev 206 } 207 208 void fn8() { 209 // CHECK-LABEL: define{{.*}} void @_Z3fn8v 210 void target(std::initializer_list<std::initializer_list<destroyme1>>); 211 // objects should be destroyed before dm2, after call returns 212 // CHECK: call void @_Z6targetSt16initializer_listIS_I10destroyme1EE 213 std::initializer_list<destroyme1> inner; 214 target({ inner, { destroyme1() } }); 215 // CHECK: call void @_ZN10destroyme1D1Ev 216 // Only one destroy loop, since only one inner init list is directly inited. 217 // CHECK-NOT: call void @_ZN10destroyme1D1Ev 218 destroyme2 dm2; 219 // CHECK: call void @_ZN10destroyme2D1Ev 220 } 221 222 void fn9() { 223 // CHECK-LABEL: define{{.*}} void @_Z3fn9v 224 // objects should be destroyed after dm2 225 std::initializer_list<destroyme1> inner; 226 std::initializer_list<std::initializer_list<destroyme1>> list = 227 { inner, { destroyme1() } }; 228 destroyme2 dm2; 229 // CHECK: call void @_ZN10destroyme2D1Ev 230 // CHECK: call void @_ZN10destroyme1D1Ev 231 // Only one destroy loop, since only one inner init list is directly inited. 232 // CHECK-NOT: call void @_ZN10destroyme1D1Ev 233 // CHECK: ret void 234 } 235 236 void fn10(int i) { 237 // CHECK-LABEL: define{{.*}} void @_Z4fn10i 238 // 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 2 243 // CHECK: store i32 3 244 // CHECK: store ptr 245 (void) new std::initializer_list<int> {i, 2, 3}; 246 } 247 248 void fn11() { 249 // CHECK-LABEL: define{{.*}} void @_Z4fn11v 250 (void) new std::initializer_list<destroyme1> {destroyme1(), destroyme1()}; 251 // CHECK: call void @_ZN10destroyme1D1Ev 252 destroyme2 dm2; 253 // CHECK: call void @_ZN10destroyme2D1Ev 254 } 255 256 namespace 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 274 namespace rdar13325066 { 275 struct X { ~X(); }; 276 277 // CHECK-LABEL: define{{.*}} void @_ZN12rdar133250664loopERNS_1XES1_ 278 void loop(X &x1, X &x2) { 279 // CHECK: br label 280 // CHECK: br i1 281 // CHECK: br label 282 // CHECK: call void @_ZN12rdar133250661XD1Ev 283 // CHECK: br label 284 // CHECK: br label 285 // CHECK: call void @_ZN12rdar133250661XD1Ev 286 // CHECK: br i1 287 // CHECK: br label 288 // CHECK: ret void 289 for (X x : { x1, x2 }) { } 290 } 291 } 292 293 namespace 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 label 308 // CHECK: call void @_ZN5dtors1SD1Ev( 309 // CHECK: br i1 310 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 label 325 // CHECK: call void @_ZN5dtors1SD1Ev( 326 // CHECK: br i1 327 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 label 347 // CHECK: call void @_ZN5dtors1SD1Ev( 348 // CHECK: br i1 349 } 350 } 351 352 namespace 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_constant1kE 364 // 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 8 382 } 383 namespace 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: call 392 // CHECK: call void @_ZN6nested1AC1Ev( 393 // CHECK-NOT: call 394 const C &c { { { A() }, { A() } } }; 395 396 // CHECK: call void @_ZN6nested1fEv( 397 // CHECK-NOT: call 398 f(); 399 400 // CHECK: call void @_ZN6nested1CD1Ev( 401 // CHECK-NOT: call 402 403 // Destroy B[2] array. 404 // FIXME: This isn't technically correct: reverse construction order would 405 // destroy the second B then the second A then the first B then the first A. 406 // CHECK: call void @_ZN6nested1BD1Ev( 407 // CHECK-NOT: call 408 // CHECK: br 409 410 // CHECK-NOT: call 411 // CHECK: call void @_ZN6nested1AD1Ev( 412 // CHECK-NOT: call 413 // CHECK: call void @_ZN6nested1AD1Ev( 414 // CHECK-NOT: call 415 // CHECK: } 416 } 417 } 418 419 namespace 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 436 namespace ArrayOfInitList { 437 struct S { 438 S(std::initializer_list<int>); 439 }; 440 S x[1] = {}; 441 } 442 443 namespace 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 454 namespace 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: _ZN9ConstExpr1gEv 463 // CHECK: store ptr {{.*}}@[[REFTMP2]]{{.*}} 464 // CHECK: call void @_ZN9ConstExpr1fESt16initializer_listINS_1CEE 465 f({C(1), C(2), C(3)}); 466 } 467 } 468 469 namespace 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: @_ZN9B197730102f1Ev 483 testcase a{{"", ENUM_CONSTANT}}; 484 // X86: store ptr @.ref.tmp{{.*}}, ptr %{{.*}}, align 8 485 // AMDGCN: store ptr addrspacecast{{.*}} @.ref.tmp{{.*}}{{.*}}, ptr %{{.*}}, align 8 486 } 487 void f2() { 488 // CHECK-LABEL: @_ZN9B197730102f2Ev 489 // X86: store ptr @_ZGRZN9B197730102f2EvE1p_, ptr getelementptr inbounds (%"class.std::initializer_list.10", ptr @_ZZN9B197730102f2EvE1p, i64 1), align 16 490 // AMDGCN: store ptr addrspacecast{{.*}} @_ZGRZN9B197730102f2EvE1p_{{.*}}, ptr getelementptr inbounds (%"class.std::initializer_list.10", ptr addrspacecast{{.*}}@_ZZN9B197730102f2EvE1p{{.*}}, i64 1), align 8 491 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: @_ZN9B197730107PR22940Ev 498 // CHECK: call {{.*}} @_ZN9B197730104pairIPviEC{{.}}Ev( 499 // CHECK: call {{.*}} @_ZN9B1977301014PR22940_helperERKNS_4pairIPviEE( 500 PR22940_helper(pair<void*, int>()); 501 } 502 } 503