1 // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -std=c++11 | FileCheck %s 2 3 namespace PR16263 { 4 const unsigned int n = 1234; 5 extern const int &r = (const int&)n; 6 // CHECK: @_ZGRN7PR162631rE_ = private constant i32 1234, 7 // CHECK: @_ZN7PR162631rE = constant i32* @_ZGRN7PR162631rE_, 8 9 extern const int &s = reinterpret_cast<const int&>(n); 10 // CHECK: @_ZN7PR16263L1nE = internal constant i32 1234, align 4 11 // CHECK: @_ZN7PR162631sE = constant i32* @_ZN7PR16263L1nE, align 8 12 13 struct A { int n; }; 14 struct B { int n; }; 15 struct C : A, B {}; 16 extern const A &&a = (A&&)(A&&)(C&&)(C{}); 17 // CHECK: @_ZGRN7PR162631aE_ = private global {{.*}} zeroinitializer, 18 // CHECK: @_ZN7PR162631aE = constant {{.*}} bitcast ({{.*}}* @_ZGRN7PR162631aE_ to 19 20 extern const int &&t = ((B&&)C{}).n; 21 // CHECK: @_ZGRN7PR162631tE_ = private global {{.*}} zeroinitializer, 22 // CHECK: @_ZN7PR162631tE = constant i32* {{.*}}* @_ZGRN7PR162631tE_ {{.*}} 4 23 24 struct D { double d; C c; }; 25 extern const int &&u = (123, static_cast<B&&>(0, ((D&&)D{}).*&D::c).n); 26 // CHECK: @_ZGRN7PR162631uE_ = private global {{.*}} zeroinitializer 27 // CHECK: @_ZN7PR162631uE = constant i32* {{.*}} @_ZGRN7PR162631uE_ {{.*}} 12 28 } 29 30 namespace PR20227 { 31 struct A { ~A(); }; 32 struct B { virtual ~B(); }; 33 struct C : B {}; 34 35 A &&a = dynamic_cast<A&&>(A{}); 36 // CHECK: @_ZGRN7PR202271aE_ = private global 37 38 B &&b = dynamic_cast<C&&>(dynamic_cast<B&&>(C{})); 39 // CHECK: @_ZGRN7PR202271bE_ = private global 40 41 B &&c = static_cast<C&&>(static_cast<B&&>(C{})); 42 // CHECK: @_ZGRN7PR202271cE_ = private global 43 } 44 45 struct A { 46 A(); 47 ~A(); 48 void f(); 49 }; 50 51 void f1() { 52 // CHECK: call void @_ZN1AC1Ev 53 // CHECK: call void @_ZN1AD1Ev 54 (void)A(); 55 56 // CHECK: call void @_ZN1AC1Ev 57 // CHECK: call void @_ZN1AD1Ev 58 A().f(); 59 } 60 61 // Function calls 62 struct B { 63 B(); 64 ~B(); 65 }; 66 67 B g(); 68 69 void f2() { 70 // CHECK-NOT: call void @_ZN1BC1Ev 71 // CHECK: call void @_ZN1BD1Ev 72 (void)g(); 73 } 74 75 // Member function calls 76 struct C { 77 C(); 78 ~C(); 79 80 C f(); 81 }; 82 83 void f3() { 84 // CHECK: call void @_ZN1CC1Ev 85 // CHECK: call void @_ZN1CD1Ev 86 // CHECK: call void @_ZN1CD1Ev 87 C().f(); 88 } 89 90 // Function call operator 91 struct D { 92 D(); 93 ~D(); 94 95 D operator()(); 96 }; 97 98 void f4() { 99 // CHECK: call void @_ZN1DC1Ev 100 // CHECK: call void @_ZN1DD1Ev 101 // CHECK: call void @_ZN1DD1Ev 102 D()(); 103 } 104 105 // Overloaded operators 106 struct E { 107 E(); 108 ~E(); 109 E operator+(const E&); 110 E operator!(); 111 }; 112 113 void f5() { 114 // CHECK: call void @_ZN1EC1Ev 115 // CHECK: call void @_ZN1EC1Ev 116 // CHECK: call void @_ZN1ED1Ev 117 // CHECK: call void @_ZN1ED1Ev 118 // CHECK: call void @_ZN1ED1Ev 119 E() + E(); 120 121 // CHECK: call void @_ZN1EC1Ev 122 // CHECK: call void @_ZN1ED1Ev 123 // CHECK: call void @_ZN1ED1Ev 124 !E(); 125 } 126 127 struct F { 128 F(); 129 ~F(); 130 F& f(); 131 }; 132 133 void f6() { 134 // CHECK: call void @_ZN1FC1Ev 135 // CHECK: call void @_ZN1FD1Ev 136 F().f(); 137 } 138 139 struct G { 140 G(); 141 G(A); 142 ~G(); 143 operator A(); 144 }; 145 146 void a(const A&); 147 148 void f7() { 149 // CHECK: call void @_ZN1AC1Ev 150 // CHECK: call void @_Z1aRK1A 151 // CHECK: call void @_ZN1AD1Ev 152 a(A()); 153 154 // CHECK: call void @_ZN1GC1Ev 155 // CHECK: call void @_ZN1Gcv1AEv 156 // CHECK: call void @_Z1aRK1A 157 // CHECK: call void @_ZN1AD1Ev 158 // CHECK: call void @_ZN1GD1Ev 159 a(G()); 160 } 161 162 namespace PR5077 { 163 164 struct A { 165 A(); 166 ~A(); 167 int f(); 168 }; 169 170 void f(); 171 int g(const A&); 172 173 struct B { 174 int a1; 175 int a2; 176 B(); 177 ~B(); 178 }; 179 180 B::B() 181 // CHECK: call void @_ZN6PR50771AC1Ev 182 // CHECK: call i32 @_ZN6PR50771A1fEv 183 // CHECK: call void @_ZN6PR50771AD1Ev 184 : a1(A().f()) 185 // CHECK: call void @_ZN6PR50771AC1Ev 186 // CHECK: call i32 @_ZN6PR50771gERKNS_1AE 187 // CHECK: call void @_ZN6PR50771AD1Ev 188 , a2(g(A())) 189 { 190 // CHECK: call void @_ZN6PR50771fEv 191 f(); 192 } 193 194 struct C { 195 C(); 196 197 const B& b; 198 }; 199 200 C::C() 201 // CHECK: call void @_ZN6PR50771BC1Ev 202 : b(B()) { 203 // CHECK: call void @_ZN6PR50771fEv 204 f(); 205 206 // CHECK: call void @_ZN6PR50771BD1Ev 207 } 208 } 209 210 A f8() { 211 // CHECK: call void @_ZN1AC1Ev 212 // CHECK-NOT: call void @_ZN1AD1Ev 213 return A(); 214 // CHECK: ret void 215 } 216 217 struct H { 218 H(); 219 ~H(); 220 H(const H&); 221 }; 222 223 void f9(H h) { 224 // CHECK: call void @_ZN1HC1Ev 225 // CHECK: call void @_Z2f91H 226 // CHECK: call void @_ZN1HD1Ev 227 f9(H()); 228 229 // CHECK: call void @_ZN1HC1ERKS_ 230 // CHECK: call void @_Z2f91H 231 // CHECK: call void @_ZN1HD1Ev 232 f9(h); 233 } 234 235 void f10(const H&); 236 237 void f11(H h) { 238 // CHECK: call void @_ZN1HC1Ev 239 // CHECK: call void @_Z3f10RK1H 240 // CHECK: call void @_ZN1HD1Ev 241 f10(H()); 242 243 // CHECK: call void @_Z3f10RK1H 244 // CHECK-NOT: call void @_ZN1HD1Ev 245 // CHECK: ret void 246 f10(h); 247 } 248 249 // PR5808 250 struct I { 251 I(const char *); 252 ~I(); 253 }; 254 255 // CHECK: _Z3f12v 256 I f12() { 257 // CHECK: call void @_ZN1IC1EPKc 258 // CHECK-NOT: call void @_ZN1ID1Ev 259 // CHECK: ret void 260 return "Hello"; 261 } 262 263 // PR5867 264 namespace PR5867 { 265 struct S { 266 S(); 267 S(const S &); 268 ~S(); 269 }; 270 271 void f(S, int); 272 // CHECK-LABEL: define void @_ZN6PR58671gEv 273 void g() { 274 // CHECK: call void @_ZN6PR58671SC1Ev 275 // CHECK-NEXT: call void @_ZN6PR58671fENS_1SEi 276 // CHECK-NEXT: call void @_ZN6PR58671SD1Ev 277 // CHECK-NEXT: ret void 278 (f)(S(), 0); 279 } 280 281 // CHECK-LABEL: define linkonce_odr void @_ZN6PR58672g2IiEEvT_ 282 template<typename T> 283 void g2(T) { 284 // CHECK: call void @_ZN6PR58671SC1Ev 285 // CHECK-NEXT: call void @_ZN6PR58671fENS_1SEi 286 // CHECK-NEXT: call void @_ZN6PR58671SD1Ev 287 // CHECK-NEXT: ret void 288 (f)(S(), 0); 289 } 290 291 void h() { 292 g2(17); 293 } 294 } 295 296 // PR6199 297 namespace PR6199 { 298 struct A { ~A(); }; 299 300 struct B { operator A(); }; 301 302 // CHECK-LABEL: define weak_odr void @_ZN6PR61992f2IiEENS_1AET_ 303 template<typename T> A f2(T) { 304 B b; 305 // CHECK: call void @_ZN6PR61991BcvNS_1AEEv 306 // CHECK-NEXT: ret void 307 return b; 308 } 309 310 template A f2<int>(int); 311 312 } 313 314 namespace T12 { 315 316 struct A { 317 A(); 318 ~A(); 319 int f(); 320 }; 321 322 int& f(int); 323 324 // CHECK-LABEL: define void @_ZN3T121gEv 325 void g() { 326 // CHECK: call void @_ZN3T121AC1Ev 327 // CHECK-NEXT: call i32 @_ZN3T121A1fEv( 328 // CHECK-NEXT: call nonnull i32* @_ZN3T121fEi( 329 // CHECK-NEXT: call void @_ZN3T121AD1Ev( 330 int& i = f(A().f()); 331 } 332 333 } 334 335 namespace PR6648 { 336 struct B { 337 ~B(); 338 }; 339 B foo; 340 struct D; 341 D& zed(B); 342 void foobar() { 343 // CHECK: call nonnull %"struct.PR6648::D"* @_ZN6PR66483zedENS_1BE 344 zed(foo); 345 } 346 } 347 348 namespace UserConvertToValue { 349 struct X { 350 X(int); 351 X(const X&); 352 ~X(); 353 }; 354 355 void f(X); 356 357 // CHECK: void @_ZN18UserConvertToValue1gEv() 358 void g() { 359 // CHECK: call void @_ZN18UserConvertToValue1XC1Ei 360 // CHECK: call void @_ZN18UserConvertToValue1fENS_1XE 361 // CHECK: call void @_ZN18UserConvertToValue1XD1Ev 362 // CHECK: ret void 363 f(1); 364 } 365 } 366 367 namespace PR7556 { 368 struct A { ~A(); }; 369 struct B { int i; ~B(); }; 370 struct C { int C::*pm; ~C(); }; 371 // CHECK-LABEL: define void @_ZN6PR75563fooEv() 372 void foo() { 373 // CHECK: call void @_ZN6PR75561AD1Ev 374 A(); 375 // CHECK: call void @llvm.memset.p0i8.i64 376 // CHECK: call void @_ZN6PR75561BD1Ev 377 B(); 378 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64 379 // CHECK: call void @_ZN6PR75561CD1Ev 380 C(); 381 // CHECK-NEXT: ret void 382 } 383 } 384 385 namespace Elision { 386 struct A { 387 A(); A(const A &); ~A(); 388 void *p; 389 void foo() const; 390 }; 391 392 void foo(); 393 A fooA(); 394 void takeA(A a); 395 396 // CHECK-LABEL: define void @_ZN7Elision5test0Ev() 397 void test0() { 398 // CHECK: [[I:%.*]] = alloca [[A:%.*]], align 8 399 // CHECK-NEXT: [[J:%.*]] = alloca [[A]], align 8 400 // CHECK-NEXT: [[T0:%.*]] = alloca [[A]], align 8 401 // CHECK-NEXT: [[K:%.*]] = alloca [[A]], align 8 402 // CHECK-NEXT: [[T1:%.*]] = alloca [[A]], align 8 403 404 // CHECK-NEXT: call void @_ZN7Elision3fooEv() 405 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[I]]) 406 A i = (foo(), A()); 407 408 // CHECK-NEXT: call void @_ZN7Elision4fooAEv([[A]]* sret [[T0]]) 409 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[J]]) 410 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[T0]]) 411 A j = (fooA(), A()); 412 413 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[T1]]) 414 // CHECK-NEXT: call void @_ZN7Elision4fooAEv([[A]]* sret [[K]]) 415 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[T1]]) 416 A k = (A(), fooA()); 417 418 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[K]]) 419 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[J]]) 420 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[I]]) 421 } 422 423 424 // CHECK-LABEL: define void @_ZN7Elision5test1EbNS_1AE( 425 void test1(bool c, A x) { 426 // CHECK: [[I:%.*]] = alloca [[A]], align 8 427 // CHECK-NEXT: [[J:%.*]] = alloca [[A]], align 8 428 429 // CHECK: call void @_ZN7Elision1AC1Ev([[A]]* [[I]]) 430 // CHECK: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[I]], [[A]]* nonnull [[X:%.*]]) 431 A i = (c ? A() : x); 432 433 // CHECK: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[J]], [[A]]* nonnull [[X]]) 434 // CHECK: call void @_ZN7Elision1AC1Ev([[A]]* [[J]]) 435 A j = (c ? x : A()); 436 437 // CHECK: call void @_ZN7Elision1AD1Ev([[A]]* [[J]]) 438 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[I]]) 439 } 440 441 // CHECK: define void @_ZN7Elision5test2Ev([[A]]* noalias sret 442 A test2() { 443 // CHECK: call void @_ZN7Elision3fooEv() 444 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[RET:%.*]]) 445 // CHECK-NEXT: ret void 446 return (foo(), A()); 447 } 448 449 // CHECK: define void @_ZN7Elision5test3EiNS_1AE([[A]]* noalias sret 450 A test3(int v, A x) { 451 if (v < 5) 452 // CHECK: call void @_ZN7Elision1AC1Ev([[A]]* [[RET:%.*]]) 453 // CHECK: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[RET]], [[A]]* nonnull [[X:%.*]]) 454 return (v < 0 ? A() : x); 455 else 456 // CHECK: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[RET]], [[A]]* nonnull [[X]]) 457 // CHECK: call void @_ZN7Elision1AC1Ev([[A]]* [[RET]]) 458 return (v > 10 ? x : A()); 459 460 // CHECK: ret void 461 } 462 463 // CHECK-LABEL: define void @_ZN7Elision5test4Ev() 464 void test4() { 465 // CHECK: [[X:%.*]] = alloca [[A]], align 8 466 // CHECK-NEXT: [[XS:%.*]] = alloca [2 x [[A]]], align 16 467 468 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[X]]) 469 A x; 470 471 // CHECK-NEXT: [[XS0:%.*]] = getelementptr inbounds [2 x [[A]]]* [[XS]], i64 0, i64 0 472 // CHECK-NEXT: call void @_ZN7Elision1AC1Ev([[A]]* [[XS0]]) 473 // CHECK-NEXT: [[XS1:%.*]] = getelementptr inbounds [[A]]* [[XS0]], i64 1 474 // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[XS1]], [[A]]* nonnull [[X]]) 475 A xs[] = { A(), x }; 476 477 // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [2 x [[A]]]* [[XS]], i32 0, i32 0 478 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 2 479 // CHECK-NEXT: br label 480 // CHECK: [[AFTER:%.*]] = phi [[A]]* 481 // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]]* [[AFTER]], i64 -1 482 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[CUR]]) 483 // CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[CUR]], [[BEGIN]] 484 // CHECK-NEXT: br i1 [[T0]], 485 486 // CHECK: call void @_ZN7Elision1AD1Ev([[A]]* [[X]]) 487 } 488 489 // rdar://problem/8433352 490 // CHECK: define void @_ZN7Elision5test5Ev([[A]]* noalias sret 491 struct B { A a; B(); }; 492 A test5() { 493 // CHECK: [[AT0:%.*]] = alloca [[A]], align 8 494 // CHECK-NEXT: [[BT0:%.*]] = alloca [[B:%.*]], align 8 495 // CHECK-NEXT: [[X:%.*]] = alloca [[A]], align 8 496 // CHECK-NEXT: [[BT1:%.*]] = alloca [[B]], align 8 497 // CHECK-NEXT: [[BT2:%.*]] = alloca [[B]], align 8 498 499 // CHECK: call void @_ZN7Elision1BC1Ev([[B]]* [[BT0]]) 500 // CHECK-NEXT: [[AM:%.*]] = getelementptr inbounds [[B]]* [[BT0]], i32 0, i32 0 501 // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[AT0]], [[A]]* nonnull [[AM]]) 502 // CHECK-NEXT: call void @_ZN7Elision5takeAENS_1AE([[A]]* [[AT0]]) 503 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[AT0]]) 504 // CHECK-NEXT: call void @_ZN7Elision1BD1Ev([[B]]* [[BT0]]) 505 takeA(B().a); 506 507 // CHECK-NEXT: call void @_ZN7Elision1BC1Ev([[B]]* [[BT1]]) 508 // CHECK-NEXT: [[AM:%.*]] = getelementptr inbounds [[B]]* [[BT1]], i32 0, i32 0 509 // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[X]], [[A]]* nonnull [[AM]]) 510 // CHECK-NEXT: call void @_ZN7Elision1BD1Ev([[B]]* [[BT1]]) 511 A x = B().a; 512 513 // CHECK-NEXT: call void @_ZN7Elision1BC1Ev([[B]]* [[BT2]]) 514 // CHECK-NEXT: [[AM:%.*]] = getelementptr inbounds [[B]]* [[BT2]], i32 0, i32 0 515 // CHECK-NEXT: call void @_ZN7Elision1AC1ERKS0_([[A]]* [[RET:%.*]], [[A]]* nonnull [[AM]]) 516 // CHECK-NEXT: call void @_ZN7Elision1BD1Ev([[B]]* [[BT2]]) 517 return B().a; 518 519 // CHECK: call void @_ZN7Elision1AD1Ev([[A]]* [[X]]) 520 } 521 522 // Reduced from webkit. 523 // CHECK: define void @_ZN7Elision5test6EPKNS_1CE([[C:%.*]]* 524 struct C { operator A() const; }; 525 void test6(const C *x) { 526 // CHECK: [[T0:%.*]] = alloca [[A]], align 8 527 // CHECK: [[X:%.*]] = load [[C]]** {{%.*}}, align 8 528 // CHECK-NEXT: call void @_ZNK7Elision1CcvNS_1AEEv([[A]]* sret [[T0]], [[C]]* [[X]]) 529 // CHECK-NEXT: call void @_ZNK7Elision1A3fooEv([[A]]* [[T0]]) 530 // CHECK-NEXT: call void @_ZN7Elision1AD1Ev([[A]]* [[T0]]) 531 // CHECK-NEXT: ret void 532 A(*x).foo(); 533 } 534 } 535 536 namespace PR8623 { 537 struct A { A(int); ~A(); }; 538 539 // CHECK-LABEL: define void @_ZN6PR86233fooEb( 540 void foo(bool b) { 541 // CHECK: [[TMP:%.*]] = alloca [[A:%.*]], align 1 542 // CHECK-NEXT: [[LCONS:%.*]] = alloca i1 543 // CHECK-NEXT: [[RCONS:%.*]] = alloca i1 544 // CHECK: store i1 false, i1* [[LCONS]] 545 // CHECK-NEXT: store i1 false, i1* [[RCONS]] 546 // CHECK-NEXT: br i1 547 // CHECK: call void @_ZN6PR86231AC1Ei([[A]]* [[TMP]], i32 2) 548 // CHECK-NEXT: store i1 true, i1* [[LCONS]] 549 // CHECK-NEXT: br label 550 // CHECK: call void @_ZN6PR86231AC1Ei([[A]]* [[TMP]], i32 3) 551 // CHECK-NEXT: store i1 true, i1* [[RCONS]] 552 // CHECK-NEXT: br label 553 // CHECK: load i1* [[RCONS]] 554 // CHECK-NEXT: br i1 555 // CHECK: call void @_ZN6PR86231AD1Ev([[A]]* [[TMP]]) 556 // CHECK-NEXT: br label 557 // CHECK: load i1* [[LCONS]] 558 // CHECK-NEXT: br i1 559 // CHECK: call void @_ZN6PR86231AD1Ev([[A]]* [[TMP]]) 560 // CHECK-NEXT: br label 561 // CHECK: ret void 562 b ? A(2) : A(3); 563 } 564 } 565 566 namespace PR11365 { 567 struct A { A(); ~A(); }; 568 569 // CHECK-LABEL: define void @_ZN7PR113653fooEv( 570 void foo() { 571 // CHECK: [[BEGIN:%.*]] = getelementptr inbounds [3 x [[A:%.*]]]* {{.*}}, i32 0, i32 0 572 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 3 573 // CHECK-NEXT: br label 574 575 // CHECK: [[PHI:%.*]] = phi 576 // CHECK-NEXT: [[ELEM:%.*]] = getelementptr inbounds [[A]]* [[PHI]], i64 -1 577 // CHECK-NEXT: call void @_ZN7PR113651AD1Ev([[A]]* [[ELEM]]) 578 // CHECK-NEXT: icmp eq [[A]]* [[ELEM]], [[BEGIN]] 579 // CHECK-NEXT: br i1 580 (void) (A [3]) {}; 581 } 582 } 583 584 namespace AssignmentOp { 585 struct A { ~A(); }; 586 struct B { A operator=(const B&); }; 587 struct C : B { B b1, b2; }; 588 // CHECK-LABEL: define void @_ZN12AssignmentOp1fE 589 void f(C &c1, const C &c2) { 590 // CHECK: call {{.*}} @_ZN12AssignmentOp1CaSERKS0_( 591 c1 = c2; 592 } 593 594 // Ensure that each 'A' temporary is destroyed before the next subobject is 595 // copied. 596 // CHECK: define {{.*}} @_ZN12AssignmentOp1CaSERKS0_( 597 // CHECK: call {{.*}} @_ZN12AssignmentOp1BaSERKS 598 // CHECK: call {{.*}} @_ZN12AssignmentOp1AD1Ev( 599 // CHECK: call {{.*}} @_ZN12AssignmentOp1BaSERKS 600 // CHECK: call {{.*}} @_ZN12AssignmentOp1AD1Ev( 601 // CHECK: call {{.*}} @_ZN12AssignmentOp1BaSERKS 602 // CHECK: call {{.*}} @_ZN12AssignmentOp1AD1Ev( 603 } 604 605 namespace BindToSubobject { 606 struct A { 607 A(); 608 ~A(); 609 int a; 610 }; 611 612 void f(), g(); 613 614 // CHECK: call void @_ZN15BindToSubobject1AC1Ev({{.*}} @_ZGRN15BindToSubobject1aE_) 615 // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1AD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1aE_ to i8*), i8* @__dso_handle) 616 // CHECK: store i32* getelementptr inbounds ({{.*}} @_ZGRN15BindToSubobject1aE_, i32 0, i32 0), i32** @_ZN15BindToSubobject1aE, align 8 617 int &&a = A().a; 618 619 // CHECK: call void @_ZN15BindToSubobject1fEv() 620 // CHECK: call void @_ZN15BindToSubobject1AC1Ev({{.*}} @_ZGRN15BindToSubobject1bE_) 621 // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1AD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1bE_ to i8*), i8* @__dso_handle) 622 // CHECK: store i32* getelementptr inbounds ({{.*}} @_ZGRN15BindToSubobject1bE_, i32 0, i32 0), i32** @_ZN15BindToSubobject1bE, align 8 623 int &&b = (f(), A().a); 624 625 int A::*h(); 626 627 // CHECK: call void @_ZN15BindToSubobject1fEv() 628 // CHECK: call void @_ZN15BindToSubobject1gEv() 629 // CHECK: call void @_ZN15BindToSubobject1AC1Ev({{.*}} @_ZGRN15BindToSubobject1cE_) 630 // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1AD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1cE_ to i8*), i8* @__dso_handle) 631 // CHECK: call {{.*}} @_ZN15BindToSubobject1hE 632 // CHECK: getelementptr 633 // CHECK: store i32* {{.*}}, i32** @_ZN15BindToSubobject1cE, align 8 634 int &&c = (f(), (g(), A().*h())); 635 636 struct B { 637 int padding; 638 A a; 639 }; 640 641 // CHECK: call void @_ZN15BindToSubobject1BC1Ev({{.*}} @_ZGRN15BindToSubobject1dE_) 642 // CHECK: call i32 @__cxa_atexit({{.*}} bitcast ({{.*}} @_ZN15BindToSubobject1BD1Ev to void (i8*)*), i8* bitcast ({{.*}} @_ZGRN15BindToSubobject1dE_ to i8*), i8* @__dso_handle) 643 // CHECK: call {{.*}} @_ZN15BindToSubobject1hE 644 // CHECK: getelementptr {{.*}} getelementptr 645 // CHECK: store i32* {{.*}}, i32** @_ZN15BindToSubobject1dE, align 8 646 int &&d = (B().a).*h(); 647 } 648 649 namespace Bitfield { 650 struct S { int a : 5; ~S(); }; 651 652 // Do not lifetime extend the S() temporary here. 653 // CHECK: alloca 654 // CHECK: call {{.*}}memset 655 // CHECK: store i32 {{.*}}, i32* @_ZGRN8Bitfield1rE_ 656 // CHECK: call void @_ZN8Bitfield1SD1 657 // CHECK: store i32* @_ZGRN8Bitfield1rE_, i32** @_ZN8Bitfield1rE, align 8 658 int &&r = S().a; 659 } 660 661 namespace Vector { 662 typedef __attribute__((vector_size(16))) int vi4a; 663 typedef __attribute__((ext_vector_type(4))) int vi4b; 664 struct S { 665 vi4a v; 666 vi4b w; 667 }; 668 // CHECK: alloca 669 // CHECK: extractelement 670 // CHECK: store i32 {{.*}}, i32* @_ZGRN6Vector1rE_ 671 // CHECK: store i32* @_ZGRN6Vector1rE_, i32** @_ZN6Vector1rE, 672 int &&r = S().v[1]; 673 674 // CHECK: alloca 675 // CHECK: extractelement 676 // CHECK: store i32 {{.*}}, i32* @_ZGRN6Vector1sE_ 677 // CHECK: store i32* @_ZGRN6Vector1sE_, i32** @_ZN6Vector1sE, 678 int &&s = S().w[1]; 679 // FIXME PR16204: The following code leads to an assertion in Sema. 680 //int &&s = S().w.y; 681 } 682 683 namespace ImplicitTemporaryCleanup { 684 struct A { A(int); ~A(); }; 685 void g(); 686 687 // CHECK-LABEL: define void @_ZN24ImplicitTemporaryCleanup1fEv( 688 void f() { 689 // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AC1Ei( 690 A &&a = 0; 691 692 // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1gEv( 693 g(); 694 695 // CHECK: call {{.*}} @_ZN24ImplicitTemporaryCleanup1AD1Ev( 696 } 697 } 698 699 namespace MultipleExtension { 700 struct A { A(); ~A(); }; 701 struct B { B(); ~B(); }; 702 struct C { C(); ~C(); }; 703 struct D { D(); ~D(); int n; C c; }; 704 struct E { const A &a; B b; const C &c; ~E(); }; 705 706 E &&e1 = { A(), B(), D().c }; 707 708 // CHECK: call void @_ZN17MultipleExtension1AC1Ev({{.*}} @[[TEMPA:_ZGRN17MultipleExtension2e1E.*]]) 709 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1AD1Ev {{.*}} @[[TEMPA]] 710 // CHECK: store {{.*}} @[[TEMPA]], {{.*}} getelementptr inbounds ({{.*}} @[[TEMPE:_ZGRN17MultipleExtension2e1E.*]], i32 0, i32 0) 711 712 // CHECK: call void @_ZN17MultipleExtension1BC1Ev({{.*}} getelementptr inbounds ({{.*}} @[[TEMPE]], i32 0, i32 1)) 713 714 // CHECK: call void @_ZN17MultipleExtension1DC1Ev({{.*}} @[[TEMPD:_ZGRN17MultipleExtension2e1E.*]]) 715 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1DD1Ev {{.*}} @[[TEMPD]] 716 // CHECK: store {{.*}} @[[TEMPD]], {{.*}} getelementptr inbounds ({{.*}} @[[TEMPE]], i32 0, i32 2) 717 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1ED1Ev {{.*}} @[[TEMPE]] 718 // CHECK: store {{.*}} @[[TEMPE]], %"struct.MultipleExtension::E"** @_ZN17MultipleExtension2e1E, align 8 719 720 E e2 = { A(), B(), D().c }; 721 722 // CHECK: call void @_ZN17MultipleExtension1AC1Ev({{.*}} @[[TEMPA:_ZGRN17MultipleExtension2e2E.*]]) 723 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1AD1Ev {{.*}} @[[TEMPA]] 724 // CHECK: store {{.*}} @[[TEMPA]], {{.*}} getelementptr inbounds ({{.*}} @[[E:_ZN17MultipleExtension2e2E]], i32 0, i32 0) 725 726 // CHECK: call void @_ZN17MultipleExtension1BC1Ev({{.*}} getelementptr inbounds ({{.*}} @[[E]], i32 0, i32 1)) 727 728 // CHECK: call void @_ZN17MultipleExtension1DC1Ev({{.*}} @[[TEMPD:_ZGRN17MultipleExtension2e2E.*]]) 729 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1DD1Ev {{.*}} @[[TEMPD]] 730 // CHECK: store {{.*}} @[[TEMPD]], {{.*}} getelementptr inbounds ({{.*}} @[[E]], i32 0, i32 2) 731 // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN17MultipleExtension1ED1Ev {{.*}} @[[E]] 732 733 734 void g(); 735 // CHECK: define void @[[NS:_ZN17MultipleExtension]]1fEv( 736 void f() { 737 E &&e1 = { A(), B(), D().c }; 738 // CHECK: %[[TEMPE1_A:.*]] = getelementptr inbounds {{.*}} %[[TEMPE1:.*]], i32 0, i32 0 739 // CHECK: call void @[[NS]]1AC1Ev({{.*}} %[[TEMPA1:.*]]) 740 // CHECK: store {{.*}} %[[TEMPA1]], {{.*}} %[[TEMPE1_A]] 741 // CHECK: %[[TEMPE1_B:.*]] = getelementptr inbounds {{.*}} %[[TEMPE1]], i32 0, i32 1 742 // CHECK: call void @[[NS]]1BC1Ev({{.*}} %[[TEMPE1_B]]) 743 // CHECK: %[[TEMPE1_C:.*]] = getelementptr inbounds {{.*}} %[[TEMPE1]], i32 0, i32 2 744 // CHECK: call void @[[NS]]1DC1Ev({{.*}} %[[TEMPD1:.*]]) 745 // CHECK: %[[TEMPD1_C:.*]] = getelementptr inbounds {{.*}} %[[TEMPD1]], i32 0, i32 1 746 // CHECK: store {{.*}} %[[TEMPD1_C]], {{.*}} %[[TEMPE1_C]] 747 // CHECK: store {{.*}} %[[TEMPE1]], {{.*}} %[[E1:.*]] 748 749 g(); 750 // CHECK: call void @[[NS]]1gEv() 751 752 E e2 = { A(), B(), D().c }; 753 // CHECK: %[[TEMPE2_A:.*]] = getelementptr inbounds {{.*}} %[[E2:.*]], i32 0, i32 0 754 // CHECK: call void @[[NS]]1AC1Ev({{.*}} %[[TEMPA2:.*]]) 755 // CHECK: store {{.*}} %[[TEMPA2]], {{.*}} %[[TEMPE2_A]] 756 // CHECK: %[[TEMPE2_B:.*]] = getelementptr inbounds {{.*}} %[[E2]], i32 0, i32 1 757 // CHECK: call void @[[NS]]1BC1Ev({{.*}} %[[TEMPE2_B]]) 758 // CHECK: %[[TEMPE2_C:.*]] = getelementptr inbounds {{.*}} %[[E2]], i32 0, i32 2 759 // CHECK: call void @[[NS]]1DC1Ev({{.*}} %[[TEMPD2:.*]]) 760 // CHECK: %[[TEMPD2_C:.*]] = getelementptr inbounds {{.*}} %[[TEMPD2]], i32 0, i32 1 761 // CHECK: store {{.*}} %[[TEMPD2_C]], {{.*}}* %[[TEMPE2_C]] 762 763 g(); 764 // CHECK: call void @[[NS]]1gEv() 765 766 // CHECK: call void @[[NS]]1ED1Ev({{.*}} %[[E2]]) 767 // CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD2]]) 768 // CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA2]]) 769 // CHECK: call void @[[NS]]1ED1Ev({{.*}} %[[TEMPE1]]) 770 // CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD1]]) 771 // CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA1]]) 772 } 773 } 774 775 namespace PR14130 { 776 struct S { S(int); }; 777 struct U { S &&s; }; 778 U v { { 0 } }; 779 // CHECK: call void @_ZN7PR141301SC1Ei({{.*}} @_ZGRN7PR141301vE_, i32 0) 780 // CHECK: store {{.*}} @_ZGRN7PR141301vE_, {{.*}} @_ZN7PR141301vE 781 } 782 783 namespace Ctor { 784 struct A { A(); ~A(); }; 785 void f(); 786 struct B { 787 A &&a; 788 B() : a{} { f(); } 789 } b; 790 // CHECK: define {{.*}}void @_ZN4Ctor1BC1Ev( 791 // CHECK: call void @_ZN4Ctor1AC1Ev( 792 // CHECK: call void @_ZN4Ctor1fEv( 793 // CHECK: call void @_ZN4Ctor1AD1Ev( 794 } 795