1 //===--- CGClass.cpp - Emit LLVM Code for C++ classes ---------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This contains code dealing with C++ code generation of classes 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CGBlocks.h" 15 #include "CGDebugInfo.h" 16 #include "CodeGenFunction.h" 17 #include "clang/AST/CXXInheritance.h" 18 #include "clang/AST/EvaluatedExprVisitor.h" 19 #include "clang/AST/RecordLayout.h" 20 #include "clang/AST/StmtCXX.h" 21 #include "clang/Frontend/CodeGenOptions.h" 22 23 using namespace clang; 24 using namespace CodeGen; 25 26 static CharUnits 27 ComputeNonVirtualBaseClassOffset(ASTContext &Context, 28 const CXXRecordDecl *DerivedClass, 29 CastExpr::path_const_iterator Start, 30 CastExpr::path_const_iterator End) { 31 CharUnits Offset = CharUnits::Zero(); 32 33 const CXXRecordDecl *RD = DerivedClass; 34 35 for (CastExpr::path_const_iterator I = Start; I != End; ++I) { 36 const CXXBaseSpecifier *Base = *I; 37 assert(!Base->isVirtual() && "Should not see virtual bases here!"); 38 39 // Get the layout. 40 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 41 42 const CXXRecordDecl *BaseDecl = 43 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 44 45 // Add the offset. 46 Offset += Layout.getBaseClassOffset(BaseDecl); 47 48 RD = BaseDecl; 49 } 50 51 return Offset; 52 } 53 54 llvm::Constant * 55 CodeGenModule::GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl, 56 CastExpr::path_const_iterator PathBegin, 57 CastExpr::path_const_iterator PathEnd) { 58 assert(PathBegin != PathEnd && "Base path should not be empty!"); 59 60 CharUnits Offset = 61 ComputeNonVirtualBaseClassOffset(getContext(), ClassDecl, 62 PathBegin, PathEnd); 63 if (Offset.isZero()) 64 return 0; 65 66 llvm::Type *PtrDiffTy = 67 Types.ConvertType(getContext().getPointerDiffType()); 68 69 return llvm::ConstantInt::get(PtrDiffTy, Offset.getQuantity()); 70 } 71 72 /// Gets the address of a direct base class within a complete object. 73 /// This should only be used for (1) non-virtual bases or (2) virtual bases 74 /// when the type is known to be complete (e.g. in complete destructors). 75 /// 76 /// The object pointed to by 'This' is assumed to be non-null. 77 llvm::Value * 78 CodeGenFunction::GetAddressOfDirectBaseInCompleteClass(llvm::Value *This, 79 const CXXRecordDecl *Derived, 80 const CXXRecordDecl *Base, 81 bool BaseIsVirtual) { 82 // 'this' must be a pointer (in some address space) to Derived. 83 assert(This->getType()->isPointerTy() && 84 cast<llvm::PointerType>(This->getType())->getElementType() 85 == ConvertType(Derived)); 86 87 // Compute the offset of the virtual base. 88 CharUnits Offset; 89 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived); 90 if (BaseIsVirtual) 91 Offset = Layout.getVBaseClassOffset(Base); 92 else 93 Offset = Layout.getBaseClassOffset(Base); 94 95 // Shift and cast down to the base type. 96 // TODO: for complete types, this should be possible with a GEP. 97 llvm::Value *V = This; 98 if (Offset.isPositive()) { 99 V = Builder.CreateBitCast(V, Int8PtrTy); 100 V = Builder.CreateConstInBoundsGEP1_64(V, Offset.getQuantity()); 101 } 102 V = Builder.CreateBitCast(V, ConvertType(Base)->getPointerTo()); 103 104 return V; 105 } 106 107 static llvm::Value * 108 ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, llvm::Value *ThisPtr, 109 CharUnits NonVirtual, llvm::Value *Virtual) { 110 llvm::Type *PtrDiffTy = 111 CGF.ConvertType(CGF.getContext().getPointerDiffType()); 112 113 llvm::Value *NonVirtualOffset = 0; 114 if (!NonVirtual.isZero()) 115 NonVirtualOffset = llvm::ConstantInt::get(PtrDiffTy, 116 NonVirtual.getQuantity()); 117 118 llvm::Value *BaseOffset; 119 if (Virtual) { 120 if (NonVirtualOffset) 121 BaseOffset = CGF.Builder.CreateAdd(Virtual, NonVirtualOffset); 122 else 123 BaseOffset = Virtual; 124 } else 125 BaseOffset = NonVirtualOffset; 126 127 // Apply the base offset. 128 ThisPtr = CGF.Builder.CreateBitCast(ThisPtr, CGF.Int8PtrTy); 129 ThisPtr = CGF.Builder.CreateGEP(ThisPtr, BaseOffset, "add.ptr"); 130 131 return ThisPtr; 132 } 133 134 llvm::Value * 135 CodeGenFunction::GetAddressOfBaseClass(llvm::Value *Value, 136 const CXXRecordDecl *Derived, 137 CastExpr::path_const_iterator PathBegin, 138 CastExpr::path_const_iterator PathEnd, 139 bool NullCheckValue) { 140 assert(PathBegin != PathEnd && "Base path should not be empty!"); 141 142 CastExpr::path_const_iterator Start = PathBegin; 143 const CXXRecordDecl *VBase = 0; 144 145 // Get the virtual base. 146 if ((*Start)->isVirtual()) { 147 VBase = 148 cast<CXXRecordDecl>((*Start)->getType()->getAs<RecordType>()->getDecl()); 149 ++Start; 150 } 151 152 CharUnits NonVirtualOffset = 153 ComputeNonVirtualBaseClassOffset(getContext(), VBase ? VBase : Derived, 154 Start, PathEnd); 155 156 // Get the base pointer type. 157 llvm::Type *BasePtrTy = 158 ConvertType((PathEnd[-1])->getType())->getPointerTo(); 159 160 if (NonVirtualOffset.isZero() && !VBase) { 161 // Just cast back. 162 return Builder.CreateBitCast(Value, BasePtrTy); 163 } 164 165 llvm::BasicBlock *CastNull = 0; 166 llvm::BasicBlock *CastNotNull = 0; 167 llvm::BasicBlock *CastEnd = 0; 168 169 if (NullCheckValue) { 170 CastNull = createBasicBlock("cast.null"); 171 CastNotNull = createBasicBlock("cast.notnull"); 172 CastEnd = createBasicBlock("cast.end"); 173 174 llvm::Value *IsNull = Builder.CreateIsNull(Value); 175 Builder.CreateCondBr(IsNull, CastNull, CastNotNull); 176 EmitBlock(CastNotNull); 177 } 178 179 llvm::Value *VirtualOffset = 0; 180 181 if (VBase) { 182 if (Derived->hasAttr<FinalAttr>()) { 183 VirtualOffset = 0; 184 185 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived); 186 187 CharUnits VBaseOffset = Layout.getVBaseClassOffset(VBase); 188 NonVirtualOffset += VBaseOffset; 189 } else 190 VirtualOffset = GetVirtualBaseClassOffset(Value, Derived, VBase); 191 } 192 193 // Apply the offsets. 194 Value = ApplyNonVirtualAndVirtualOffset(*this, Value, 195 NonVirtualOffset, 196 VirtualOffset); 197 198 // Cast back. 199 Value = Builder.CreateBitCast(Value, BasePtrTy); 200 201 if (NullCheckValue) { 202 Builder.CreateBr(CastEnd); 203 EmitBlock(CastNull); 204 Builder.CreateBr(CastEnd); 205 EmitBlock(CastEnd); 206 207 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2); 208 PHI->addIncoming(Value, CastNotNull); 209 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), 210 CastNull); 211 Value = PHI; 212 } 213 214 return Value; 215 } 216 217 llvm::Value * 218 CodeGenFunction::GetAddressOfDerivedClass(llvm::Value *Value, 219 const CXXRecordDecl *Derived, 220 CastExpr::path_const_iterator PathBegin, 221 CastExpr::path_const_iterator PathEnd, 222 bool NullCheckValue) { 223 assert(PathBegin != PathEnd && "Base path should not be empty!"); 224 225 QualType DerivedTy = 226 getContext().getCanonicalType(getContext().getTagDeclType(Derived)); 227 llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo(); 228 229 llvm::Value *NonVirtualOffset = 230 CGM.GetNonVirtualBaseClassOffset(Derived, PathBegin, PathEnd); 231 232 if (!NonVirtualOffset) { 233 // No offset, we can just cast back. 234 return Builder.CreateBitCast(Value, DerivedPtrTy); 235 } 236 237 llvm::BasicBlock *CastNull = 0; 238 llvm::BasicBlock *CastNotNull = 0; 239 llvm::BasicBlock *CastEnd = 0; 240 241 if (NullCheckValue) { 242 CastNull = createBasicBlock("cast.null"); 243 CastNotNull = createBasicBlock("cast.notnull"); 244 CastEnd = createBasicBlock("cast.end"); 245 246 llvm::Value *IsNull = Builder.CreateIsNull(Value); 247 Builder.CreateCondBr(IsNull, CastNull, CastNotNull); 248 EmitBlock(CastNotNull); 249 } 250 251 // Apply the offset. 252 Value = Builder.CreateBitCast(Value, Int8PtrTy); 253 Value = Builder.CreateGEP(Value, Builder.CreateNeg(NonVirtualOffset), 254 "sub.ptr"); 255 256 // Just cast. 257 Value = Builder.CreateBitCast(Value, DerivedPtrTy); 258 259 if (NullCheckValue) { 260 Builder.CreateBr(CastEnd); 261 EmitBlock(CastNull); 262 Builder.CreateBr(CastEnd); 263 EmitBlock(CastEnd); 264 265 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2); 266 PHI->addIncoming(Value, CastNotNull); 267 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), 268 CastNull); 269 Value = PHI; 270 } 271 272 return Value; 273 } 274 275 /// GetVTTParameter - Return the VTT parameter that should be passed to a 276 /// base constructor/destructor with virtual bases. 277 static llvm::Value *GetVTTParameter(CodeGenFunction &CGF, GlobalDecl GD, 278 bool ForVirtualBase) { 279 if (!CodeGenVTables::needsVTTParameter(GD)) { 280 // This constructor/destructor does not need a VTT parameter. 281 return 0; 282 } 283 284 const CXXRecordDecl *RD = cast<CXXMethodDecl>(CGF.CurFuncDecl)->getParent(); 285 const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent(); 286 287 llvm::Value *VTT; 288 289 uint64_t SubVTTIndex; 290 291 // If the record matches the base, this is the complete ctor/dtor 292 // variant calling the base variant in a class with virtual bases. 293 if (RD == Base) { 294 assert(!CodeGenVTables::needsVTTParameter(CGF.CurGD) && 295 "doing no-op VTT offset in base dtor/ctor?"); 296 assert(!ForVirtualBase && "Can't have same class as virtual base!"); 297 SubVTTIndex = 0; 298 } else { 299 const ASTRecordLayout &Layout = 300 CGF.getContext().getASTRecordLayout(RD); 301 CharUnits BaseOffset = ForVirtualBase ? 302 Layout.getVBaseClassOffset(Base) : 303 Layout.getBaseClassOffset(Base); 304 305 SubVTTIndex = 306 CGF.CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset)); 307 assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!"); 308 } 309 310 if (CodeGenVTables::needsVTTParameter(CGF.CurGD)) { 311 // A VTT parameter was passed to the constructor, use it. 312 VTT = CGF.LoadCXXVTT(); 313 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex); 314 } else { 315 // We're the complete constructor, so get the VTT by name. 316 VTT = CGF.CGM.getVTables().GetAddrOfVTT(RD); 317 VTT = CGF.Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex); 318 } 319 320 return VTT; 321 } 322 323 namespace { 324 /// Call the destructor for a direct base class. 325 struct CallBaseDtor : EHScopeStack::Cleanup { 326 const CXXRecordDecl *BaseClass; 327 bool BaseIsVirtual; 328 CallBaseDtor(const CXXRecordDecl *Base, bool BaseIsVirtual) 329 : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {} 330 331 void Emit(CodeGenFunction &CGF, Flags flags) { 332 const CXXRecordDecl *DerivedClass = 333 cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent(); 334 335 const CXXDestructorDecl *D = BaseClass->getDestructor(); 336 llvm::Value *Addr = 337 CGF.GetAddressOfDirectBaseInCompleteClass(CGF.LoadCXXThis(), 338 DerivedClass, BaseClass, 339 BaseIsVirtual); 340 CGF.EmitCXXDestructorCall(D, Dtor_Base, BaseIsVirtual, Addr); 341 } 342 }; 343 344 /// A visitor which checks whether an initializer uses 'this' in a 345 /// way which requires the vtable to be properly set. 346 struct DynamicThisUseChecker : EvaluatedExprVisitor<DynamicThisUseChecker> { 347 typedef EvaluatedExprVisitor<DynamicThisUseChecker> super; 348 349 bool UsesThis; 350 351 DynamicThisUseChecker(ASTContext &C) : super(C), UsesThis(false) {} 352 353 // Black-list all explicit and implicit references to 'this'. 354 // 355 // Do we need to worry about external references to 'this' derived 356 // from arbitrary code? If so, then anything which runs arbitrary 357 // external code might potentially access the vtable. 358 void VisitCXXThisExpr(CXXThisExpr *E) { UsesThis = true; } 359 }; 360 } 361 362 static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) { 363 DynamicThisUseChecker Checker(C); 364 Checker.Visit(const_cast<Expr*>(Init)); 365 return Checker.UsesThis; 366 } 367 368 static void EmitBaseInitializer(CodeGenFunction &CGF, 369 const CXXRecordDecl *ClassDecl, 370 CXXCtorInitializer *BaseInit, 371 CXXCtorType CtorType) { 372 assert(BaseInit->isBaseInitializer() && 373 "Must have base initializer!"); 374 375 llvm::Value *ThisPtr = CGF.LoadCXXThis(); 376 377 const Type *BaseType = BaseInit->getBaseClass(); 378 CXXRecordDecl *BaseClassDecl = 379 cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl()); 380 381 bool isBaseVirtual = BaseInit->isBaseVirtual(); 382 383 // The base constructor doesn't construct virtual bases. 384 if (CtorType == Ctor_Base && isBaseVirtual) 385 return; 386 387 // If the initializer for the base (other than the constructor 388 // itself) accesses 'this' in any way, we need to initialize the 389 // vtables. 390 if (BaseInitializerUsesThis(CGF.getContext(), BaseInit->getInit())) 391 CGF.InitializeVTablePointers(ClassDecl); 392 393 // We can pretend to be a complete class because it only matters for 394 // virtual bases, and we only do virtual bases for complete ctors. 395 llvm::Value *V = 396 CGF.GetAddressOfDirectBaseInCompleteClass(ThisPtr, ClassDecl, 397 BaseClassDecl, 398 isBaseVirtual); 399 CharUnits Alignment = CGF.getContext().getTypeAlignInChars(BaseType); 400 AggValueSlot AggSlot = 401 AggValueSlot::forAddr(V, Alignment, Qualifiers(), 402 AggValueSlot::IsDestructed, 403 AggValueSlot::DoesNotNeedGCBarriers, 404 AggValueSlot::IsNotAliased); 405 406 CGF.EmitAggExpr(BaseInit->getInit(), AggSlot); 407 408 if (CGF.CGM.getLangOpts().Exceptions && 409 !BaseClassDecl->hasTrivialDestructor()) 410 CGF.EHStack.pushCleanup<CallBaseDtor>(EHCleanup, BaseClassDecl, 411 isBaseVirtual); 412 } 413 414 static void EmitAggMemberInitializer(CodeGenFunction &CGF, 415 LValue LHS, 416 Expr *Init, 417 llvm::Value *ArrayIndexVar, 418 QualType T, 419 ArrayRef<VarDecl *> ArrayIndexes, 420 unsigned Index) { 421 if (Index == ArrayIndexes.size()) { 422 LValue LV = LHS; 423 { // Scope for Cleanups. 424 CodeGenFunction::RunCleanupsScope Cleanups(CGF); 425 426 if (ArrayIndexVar) { 427 // If we have an array index variable, load it and use it as an offset. 428 // Then, increment the value. 429 llvm::Value *Dest = LHS.getAddress(); 430 llvm::Value *ArrayIndex = CGF.Builder.CreateLoad(ArrayIndexVar); 431 Dest = CGF.Builder.CreateInBoundsGEP(Dest, ArrayIndex, "destaddress"); 432 llvm::Value *Next = llvm::ConstantInt::get(ArrayIndex->getType(), 1); 433 Next = CGF.Builder.CreateAdd(ArrayIndex, Next, "inc"); 434 CGF.Builder.CreateStore(Next, ArrayIndexVar); 435 436 // Update the LValue. 437 LV.setAddress(Dest); 438 CharUnits Align = CGF.getContext().getTypeAlignInChars(T); 439 LV.setAlignment(std::min(Align, LV.getAlignment())); 440 } 441 442 if (!CGF.hasAggregateLLVMType(T)) { 443 CGF.EmitScalarInit(Init, /*decl*/ 0, LV, false); 444 } else if (T->isAnyComplexType()) { 445 CGF.EmitComplexExprIntoAddr(Init, LV.getAddress(), 446 LV.isVolatileQualified()); 447 } else { 448 AggValueSlot Slot = 449 AggValueSlot::forLValue(LV, 450 AggValueSlot::IsDestructed, 451 AggValueSlot::DoesNotNeedGCBarriers, 452 AggValueSlot::IsNotAliased); 453 454 CGF.EmitAggExpr(Init, Slot); 455 } 456 } 457 458 // Now, outside of the initializer cleanup scope, destroy the backing array 459 // for a std::initializer_list member. 460 CGF.MaybeEmitStdInitializerListCleanup(LV.getAddress(), Init); 461 462 return; 463 } 464 465 const ConstantArrayType *Array = CGF.getContext().getAsConstantArrayType(T); 466 assert(Array && "Array initialization without the array type?"); 467 llvm::Value *IndexVar 468 = CGF.GetAddrOfLocalVar(ArrayIndexes[Index]); 469 assert(IndexVar && "Array index variable not loaded"); 470 471 // Initialize this index variable to zero. 472 llvm::Value* Zero 473 = llvm::Constant::getNullValue( 474 CGF.ConvertType(CGF.getContext().getSizeType())); 475 CGF.Builder.CreateStore(Zero, IndexVar); 476 477 // Start the loop with a block that tests the condition. 478 llvm::BasicBlock *CondBlock = CGF.createBasicBlock("for.cond"); 479 llvm::BasicBlock *AfterFor = CGF.createBasicBlock("for.end"); 480 481 CGF.EmitBlock(CondBlock); 482 483 llvm::BasicBlock *ForBody = CGF.createBasicBlock("for.body"); 484 // Generate: if (loop-index < number-of-elements) fall to the loop body, 485 // otherwise, go to the block after the for-loop. 486 uint64_t NumElements = Array->getSize().getZExtValue(); 487 llvm::Value *Counter = CGF.Builder.CreateLoad(IndexVar); 488 llvm::Value *NumElementsPtr = 489 llvm::ConstantInt::get(Counter->getType(), NumElements); 490 llvm::Value *IsLess = CGF.Builder.CreateICmpULT(Counter, NumElementsPtr, 491 "isless"); 492 493 // If the condition is true, execute the body. 494 CGF.Builder.CreateCondBr(IsLess, ForBody, AfterFor); 495 496 CGF.EmitBlock(ForBody); 497 llvm::BasicBlock *ContinueBlock = CGF.createBasicBlock("for.inc"); 498 499 { 500 CodeGenFunction::RunCleanupsScope Cleanups(CGF); 501 502 // Inside the loop body recurse to emit the inner loop or, eventually, the 503 // constructor call. 504 EmitAggMemberInitializer(CGF, LHS, Init, ArrayIndexVar, 505 Array->getElementType(), ArrayIndexes, Index + 1); 506 } 507 508 CGF.EmitBlock(ContinueBlock); 509 510 // Emit the increment of the loop counter. 511 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1); 512 Counter = CGF.Builder.CreateLoad(IndexVar); 513 NextVal = CGF.Builder.CreateAdd(Counter, NextVal, "inc"); 514 CGF.Builder.CreateStore(NextVal, IndexVar); 515 516 // Finally, branch back up to the condition for the next iteration. 517 CGF.EmitBranch(CondBlock); 518 519 // Emit the fall-through block. 520 CGF.EmitBlock(AfterFor, true); 521 } 522 523 namespace { 524 struct CallMemberDtor : EHScopeStack::Cleanup { 525 llvm::Value *V; 526 CXXDestructorDecl *Dtor; 527 528 CallMemberDtor(llvm::Value *V, CXXDestructorDecl *Dtor) 529 : V(V), Dtor(Dtor) {} 530 531 void Emit(CodeGenFunction &CGF, Flags flags) { 532 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false, 533 V); 534 } 535 }; 536 } 537 538 static bool hasTrivialCopyOrMoveConstructor(const CXXRecordDecl *Record, 539 bool Moving) { 540 return Moving ? Record->hasTrivialMoveConstructor() : 541 Record->hasTrivialCopyConstructor(); 542 } 543 544 static void EmitMemberInitializer(CodeGenFunction &CGF, 545 const CXXRecordDecl *ClassDecl, 546 CXXCtorInitializer *MemberInit, 547 const CXXConstructorDecl *Constructor, 548 FunctionArgList &Args) { 549 assert(MemberInit->isAnyMemberInitializer() && 550 "Must have member initializer!"); 551 assert(MemberInit->getInit() && "Must have initializer!"); 552 553 // non-static data member initializers. 554 FieldDecl *Field = MemberInit->getAnyMember(); 555 QualType FieldType = Field->getType(); 556 557 llvm::Value *ThisPtr = CGF.LoadCXXThis(); 558 QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl); 559 LValue LHS; 560 561 // If we are initializing an anonymous union field, drill down to the field. 562 if (MemberInit->isIndirectMemberInitializer()) { 563 LHS = CGF.EmitLValueForAnonRecordField(ThisPtr, 564 MemberInit->getIndirectMember(), 0); 565 FieldType = MemberInit->getIndirectMember()->getAnonField()->getType(); 566 } else { 567 LValue ThisLHSLV = CGF.MakeNaturalAlignAddrLValue(ThisPtr, RecordTy); 568 LHS = CGF.EmitLValueForFieldInitialization(ThisLHSLV, Field); 569 } 570 571 // Special case: if we are in a copy or move constructor, and we are copying 572 // an array of PODs or classes with trivial copy constructors, ignore the 573 // AST and perform the copy we know is equivalent. 574 // FIXME: This is hacky at best... if we had a bit more explicit information 575 // in the AST, we could generalize it more easily. 576 const ConstantArrayType *Array 577 = CGF.getContext().getAsConstantArrayType(FieldType); 578 if (Array && Constructor->isImplicitlyDefined() && 579 Constructor->isCopyOrMoveConstructor()) { 580 QualType BaseElementTy = CGF.getContext().getBaseElementType(Array); 581 const CXXRecordDecl *Record = BaseElementTy->getAsCXXRecordDecl(); 582 if (BaseElementTy.isPODType(CGF.getContext()) || 583 (Record && hasTrivialCopyOrMoveConstructor(Record, 584 Constructor->isMoveConstructor()))) { 585 // Find the source pointer. We knows it's the last argument because 586 // we know we're in a copy constructor. 587 unsigned SrcArgIndex = Args.size() - 1; 588 llvm::Value *SrcPtr 589 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex])); 590 LValue ThisRHSLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy); 591 LValue Src = CGF.EmitLValueForFieldInitialization(ThisRHSLV, Field); 592 593 // Copy the aggregate. 594 CGF.EmitAggregateCopy(LHS.getAddress(), Src.getAddress(), FieldType, 595 LHS.isVolatileQualified()); 596 return; 597 } 598 } 599 600 ArrayRef<VarDecl *> ArrayIndexes; 601 if (MemberInit->getNumArrayIndices()) 602 ArrayIndexes = MemberInit->getArrayIndexes(); 603 CGF.EmitInitializerForField(Field, LHS, MemberInit->getInit(), ArrayIndexes); 604 } 605 606 void CodeGenFunction::EmitInitializerForField(FieldDecl *Field, 607 LValue LHS, Expr *Init, 608 ArrayRef<VarDecl *> ArrayIndexes) { 609 QualType FieldType = Field->getType(); 610 if (!hasAggregateLLVMType(FieldType)) { 611 if (LHS.isSimple()) { 612 EmitExprAsInit(Init, Field, LHS, false); 613 } else { 614 RValue RHS = RValue::get(EmitScalarExpr(Init)); 615 EmitStoreThroughLValue(RHS, LHS); 616 } 617 } else if (FieldType->isAnyComplexType()) { 618 EmitComplexExprIntoAddr(Init, LHS.getAddress(), LHS.isVolatileQualified()); 619 } else { 620 llvm::Value *ArrayIndexVar = 0; 621 if (ArrayIndexes.size()) { 622 llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 623 624 // The LHS is a pointer to the first object we'll be constructing, as 625 // a flat array. 626 QualType BaseElementTy = getContext().getBaseElementType(FieldType); 627 llvm::Type *BasePtr = ConvertType(BaseElementTy); 628 BasePtr = llvm::PointerType::getUnqual(BasePtr); 629 llvm::Value *BaseAddrPtr = Builder.CreateBitCast(LHS.getAddress(), 630 BasePtr); 631 LHS = MakeAddrLValue(BaseAddrPtr, BaseElementTy); 632 633 // Create an array index that will be used to walk over all of the 634 // objects we're constructing. 635 ArrayIndexVar = CreateTempAlloca(SizeTy, "object.index"); 636 llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy); 637 Builder.CreateStore(Zero, ArrayIndexVar); 638 639 640 // Emit the block variables for the array indices, if any. 641 for (unsigned I = 0, N = ArrayIndexes.size(); I != N; ++I) 642 EmitAutoVarDecl(*ArrayIndexes[I]); 643 } 644 645 EmitAggMemberInitializer(*this, LHS, Init, ArrayIndexVar, FieldType, 646 ArrayIndexes, 0); 647 648 if (!CGM.getLangOpts().Exceptions) 649 return; 650 651 // FIXME: If we have an array of classes w/ non-trivial destructors, 652 // we need to destroy in reverse order of construction along the exception 653 // path. 654 const RecordType *RT = FieldType->getAs<RecordType>(); 655 if (!RT) 656 return; 657 658 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 659 if (!RD->hasTrivialDestructor()) 660 EHStack.pushCleanup<CallMemberDtor>(EHCleanup, LHS.getAddress(), 661 RD->getDestructor()); 662 } 663 } 664 665 /// Checks whether the given constructor is a valid subject for the 666 /// complete-to-base constructor delegation optimization, i.e. 667 /// emitting the complete constructor as a simple call to the base 668 /// constructor. 669 static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor) { 670 671 // Currently we disable the optimization for classes with virtual 672 // bases because (1) the addresses of parameter variables need to be 673 // consistent across all initializers but (2) the delegate function 674 // call necessarily creates a second copy of the parameter variable. 675 // 676 // The limiting example (purely theoretical AFAIK): 677 // struct A { A(int &c) { c++; } }; 678 // struct B : virtual A { 679 // B(int count) : A(count) { printf("%d\n", count); } 680 // }; 681 // ...although even this example could in principle be emitted as a 682 // delegation since the address of the parameter doesn't escape. 683 if (Ctor->getParent()->getNumVBases()) { 684 // TODO: white-list trivial vbase initializers. This case wouldn't 685 // be subject to the restrictions below. 686 687 // TODO: white-list cases where: 688 // - there are no non-reference parameters to the constructor 689 // - the initializers don't access any non-reference parameters 690 // - the initializers don't take the address of non-reference 691 // parameters 692 // - etc. 693 // If we ever add any of the above cases, remember that: 694 // - function-try-blocks will always blacklist this optimization 695 // - we need to perform the constructor prologue and cleanup in 696 // EmitConstructorBody. 697 698 return false; 699 } 700 701 // We also disable the optimization for variadic functions because 702 // it's impossible to "re-pass" varargs. 703 if (Ctor->getType()->getAs<FunctionProtoType>()->isVariadic()) 704 return false; 705 706 // FIXME: Decide if we can do a delegation of a delegating constructor. 707 if (Ctor->isDelegatingConstructor()) 708 return false; 709 710 return true; 711 } 712 713 /// EmitConstructorBody - Emits the body of the current constructor. 714 void CodeGenFunction::EmitConstructorBody(FunctionArgList &Args) { 715 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(CurGD.getDecl()); 716 CXXCtorType CtorType = CurGD.getCtorType(); 717 718 // Before we go any further, try the complete->base constructor 719 // delegation optimization. 720 if (CtorType == Ctor_Complete && IsConstructorDelegationValid(Ctor)) { 721 if (CGDebugInfo *DI = getDebugInfo()) 722 DI->EmitLocation(Builder, Ctor->getLocEnd()); 723 EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args); 724 return; 725 } 726 727 Stmt *Body = Ctor->getBody(); 728 729 // Enter the function-try-block before the constructor prologue if 730 // applicable. 731 bool IsTryBody = (Body && isa<CXXTryStmt>(Body)); 732 if (IsTryBody) 733 EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true); 734 735 EHScopeStack::stable_iterator CleanupDepth = EHStack.stable_begin(); 736 737 // TODO: in restricted cases, we can emit the vbase initializers of 738 // a complete ctor and then delegate to the base ctor. 739 740 // Emit the constructor prologue, i.e. the base and member 741 // initializers. 742 EmitCtorPrologue(Ctor, CtorType, Args); 743 744 // Emit the body of the statement. 745 if (IsTryBody) 746 EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock()); 747 else if (Body) 748 EmitStmt(Body); 749 750 // Emit any cleanup blocks associated with the member or base 751 // initializers, which includes (along the exceptional path) the 752 // destructors for those members and bases that were fully 753 // constructed. 754 PopCleanupBlocks(CleanupDepth); 755 756 if (IsTryBody) 757 ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true); 758 } 759 760 /// EmitCtorPrologue - This routine generates necessary code to initialize 761 /// base classes and non-static data members belonging to this constructor. 762 void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD, 763 CXXCtorType CtorType, 764 FunctionArgList &Args) { 765 if (CD->isDelegatingConstructor()) 766 return EmitDelegatingCXXConstructorCall(CD, Args); 767 768 const CXXRecordDecl *ClassDecl = CD->getParent(); 769 770 SmallVector<CXXCtorInitializer *, 8> MemberInitializers; 771 772 for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(), 773 E = CD->init_end(); 774 B != E; ++B) { 775 CXXCtorInitializer *Member = (*B); 776 777 if (Member->isBaseInitializer()) { 778 EmitBaseInitializer(*this, ClassDecl, Member, CtorType); 779 } else { 780 assert(Member->isAnyMemberInitializer() && 781 "Delegating initializer on non-delegating constructor"); 782 MemberInitializers.push_back(Member); 783 } 784 } 785 786 InitializeVTablePointers(ClassDecl); 787 788 for (unsigned I = 0, E = MemberInitializers.size(); I != E; ++I) 789 EmitMemberInitializer(*this, ClassDecl, MemberInitializers[I], CD, Args); 790 } 791 792 static bool 793 FieldHasTrivialDestructorBody(ASTContext &Context, const FieldDecl *Field); 794 795 static bool 796 HasTrivialDestructorBody(ASTContext &Context, 797 const CXXRecordDecl *BaseClassDecl, 798 const CXXRecordDecl *MostDerivedClassDecl) 799 { 800 // If the destructor is trivial we don't have to check anything else. 801 if (BaseClassDecl->hasTrivialDestructor()) 802 return true; 803 804 if (!BaseClassDecl->getDestructor()->hasTrivialBody()) 805 return false; 806 807 // Check fields. 808 for (CXXRecordDecl::field_iterator I = BaseClassDecl->field_begin(), 809 E = BaseClassDecl->field_end(); I != E; ++I) { 810 const FieldDecl *Field = *I; 811 812 if (!FieldHasTrivialDestructorBody(Context, Field)) 813 return false; 814 } 815 816 // Check non-virtual bases. 817 for (CXXRecordDecl::base_class_const_iterator I = 818 BaseClassDecl->bases_begin(), E = BaseClassDecl->bases_end(); 819 I != E; ++I) { 820 if (I->isVirtual()) 821 continue; 822 823 const CXXRecordDecl *NonVirtualBase = 824 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 825 if (!HasTrivialDestructorBody(Context, NonVirtualBase, 826 MostDerivedClassDecl)) 827 return false; 828 } 829 830 if (BaseClassDecl == MostDerivedClassDecl) { 831 // Check virtual bases. 832 for (CXXRecordDecl::base_class_const_iterator I = 833 BaseClassDecl->vbases_begin(), E = BaseClassDecl->vbases_end(); 834 I != E; ++I) { 835 const CXXRecordDecl *VirtualBase = 836 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 837 if (!HasTrivialDestructorBody(Context, VirtualBase, 838 MostDerivedClassDecl)) 839 return false; 840 } 841 } 842 843 return true; 844 } 845 846 static bool 847 FieldHasTrivialDestructorBody(ASTContext &Context, 848 const FieldDecl *Field) 849 { 850 QualType FieldBaseElementType = Context.getBaseElementType(Field->getType()); 851 852 const RecordType *RT = FieldBaseElementType->getAs<RecordType>(); 853 if (!RT) 854 return true; 855 856 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 857 return HasTrivialDestructorBody(Context, FieldClassDecl, FieldClassDecl); 858 } 859 860 /// CanSkipVTablePointerInitialization - Check whether we need to initialize 861 /// any vtable pointers before calling this destructor. 862 static bool CanSkipVTablePointerInitialization(ASTContext &Context, 863 const CXXDestructorDecl *Dtor) { 864 if (!Dtor->hasTrivialBody()) 865 return false; 866 867 // Check the fields. 868 const CXXRecordDecl *ClassDecl = Dtor->getParent(); 869 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(), 870 E = ClassDecl->field_end(); I != E; ++I) { 871 const FieldDecl *Field = *I; 872 873 if (!FieldHasTrivialDestructorBody(Context, Field)) 874 return false; 875 } 876 877 return true; 878 } 879 880 /// EmitDestructorBody - Emits the body of the current destructor. 881 void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) { 882 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CurGD.getDecl()); 883 CXXDtorType DtorType = CurGD.getDtorType(); 884 885 // The call to operator delete in a deleting destructor happens 886 // outside of the function-try-block, which means it's always 887 // possible to delegate the destructor body to the complete 888 // destructor. Do so. 889 if (DtorType == Dtor_Deleting) { 890 EnterDtorCleanups(Dtor, Dtor_Deleting); 891 EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false, 892 LoadCXXThis()); 893 PopCleanupBlock(); 894 return; 895 } 896 897 Stmt *Body = Dtor->getBody(); 898 899 // If the body is a function-try-block, enter the try before 900 // anything else. 901 bool isTryBody = (Body && isa<CXXTryStmt>(Body)); 902 if (isTryBody) 903 EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true); 904 905 // Enter the epilogue cleanups. 906 RunCleanupsScope DtorEpilogue(*this); 907 908 // If this is the complete variant, just invoke the base variant; 909 // the epilogue will destruct the virtual bases. But we can't do 910 // this optimization if the body is a function-try-block, because 911 // we'd introduce *two* handler blocks. 912 switch (DtorType) { 913 case Dtor_Deleting: llvm_unreachable("already handled deleting case"); 914 915 case Dtor_Complete: 916 // Enter the cleanup scopes for virtual bases. 917 EnterDtorCleanups(Dtor, Dtor_Complete); 918 919 if (!isTryBody) { 920 EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false, 921 LoadCXXThis()); 922 break; 923 } 924 // Fallthrough: act like we're in the base variant. 925 926 case Dtor_Base: 927 // Enter the cleanup scopes for fields and non-virtual bases. 928 EnterDtorCleanups(Dtor, Dtor_Base); 929 930 // Initialize the vtable pointers before entering the body. 931 if (!CanSkipVTablePointerInitialization(getContext(), Dtor)) 932 InitializeVTablePointers(Dtor->getParent()); 933 934 if (isTryBody) 935 EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock()); 936 else if (Body) 937 EmitStmt(Body); 938 else { 939 assert(Dtor->isImplicit() && "bodyless dtor not implicit"); 940 // nothing to do besides what's in the epilogue 941 } 942 // -fapple-kext must inline any call to this dtor into 943 // the caller's body. 944 if (getContext().getLangOpts().AppleKext) 945 CurFn->addFnAttr(llvm::Attribute::AlwaysInline); 946 break; 947 } 948 949 // Jump out through the epilogue cleanups. 950 DtorEpilogue.ForceCleanup(); 951 952 // Exit the try if applicable. 953 if (isTryBody) 954 ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true); 955 } 956 957 namespace { 958 /// Call the operator delete associated with the current destructor. 959 struct CallDtorDelete : EHScopeStack::Cleanup { 960 CallDtorDelete() {} 961 962 void Emit(CodeGenFunction &CGF, Flags flags) { 963 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CGF.CurCodeDecl); 964 const CXXRecordDecl *ClassDecl = Dtor->getParent(); 965 CGF.EmitDeleteCall(Dtor->getOperatorDelete(), CGF.LoadCXXThis(), 966 CGF.getContext().getTagDeclType(ClassDecl)); 967 } 968 }; 969 970 class DestroyField : public EHScopeStack::Cleanup { 971 const FieldDecl *field; 972 CodeGenFunction::Destroyer *destroyer; 973 bool useEHCleanupForArray; 974 975 public: 976 DestroyField(const FieldDecl *field, CodeGenFunction::Destroyer *destroyer, 977 bool useEHCleanupForArray) 978 : field(field), destroyer(destroyer), 979 useEHCleanupForArray(useEHCleanupForArray) {} 980 981 void Emit(CodeGenFunction &CGF, Flags flags) { 982 // Find the address of the field. 983 llvm::Value *thisValue = CGF.LoadCXXThis(); 984 QualType RecordTy = CGF.getContext().getTagDeclType(field->getParent()); 985 LValue ThisLV = CGF.MakeAddrLValue(thisValue, RecordTy); 986 LValue LV = CGF.EmitLValueForField(ThisLV, field); 987 assert(LV.isSimple()); 988 989 CGF.emitDestroy(LV.getAddress(), field->getType(), destroyer, 990 flags.isForNormalCleanup() && useEHCleanupForArray); 991 } 992 }; 993 } 994 995 /// EmitDtorEpilogue - Emit all code that comes at the end of class's 996 /// destructor. This is to call destructors on members and base classes 997 /// in reverse order of their construction. 998 void CodeGenFunction::EnterDtorCleanups(const CXXDestructorDecl *DD, 999 CXXDtorType DtorType) { 1000 assert(!DD->isTrivial() && 1001 "Should not emit dtor epilogue for trivial dtor!"); 1002 1003 // The deleting-destructor phase just needs to call the appropriate 1004 // operator delete that Sema picked up. 1005 if (DtorType == Dtor_Deleting) { 1006 assert(DD->getOperatorDelete() && 1007 "operator delete missing - EmitDtorEpilogue"); 1008 EHStack.pushCleanup<CallDtorDelete>(NormalAndEHCleanup); 1009 return; 1010 } 1011 1012 const CXXRecordDecl *ClassDecl = DD->getParent(); 1013 1014 // Unions have no bases and do not call field destructors. 1015 if (ClassDecl->isUnion()) 1016 return; 1017 1018 // The complete-destructor phase just destructs all the virtual bases. 1019 if (DtorType == Dtor_Complete) { 1020 1021 // We push them in the forward order so that they'll be popped in 1022 // the reverse order. 1023 for (CXXRecordDecl::base_class_const_iterator I = 1024 ClassDecl->vbases_begin(), E = ClassDecl->vbases_end(); 1025 I != E; ++I) { 1026 const CXXBaseSpecifier &Base = *I; 1027 CXXRecordDecl *BaseClassDecl 1028 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl()); 1029 1030 // Ignore trivial destructors. 1031 if (BaseClassDecl->hasTrivialDestructor()) 1032 continue; 1033 1034 EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup, 1035 BaseClassDecl, 1036 /*BaseIsVirtual*/ true); 1037 } 1038 1039 return; 1040 } 1041 1042 assert(DtorType == Dtor_Base); 1043 1044 // Destroy non-virtual bases. 1045 for (CXXRecordDecl::base_class_const_iterator I = 1046 ClassDecl->bases_begin(), E = ClassDecl->bases_end(); I != E; ++I) { 1047 const CXXBaseSpecifier &Base = *I; 1048 1049 // Ignore virtual bases. 1050 if (Base.isVirtual()) 1051 continue; 1052 1053 CXXRecordDecl *BaseClassDecl = Base.getType()->getAsCXXRecordDecl(); 1054 1055 // Ignore trivial destructors. 1056 if (BaseClassDecl->hasTrivialDestructor()) 1057 continue; 1058 1059 EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup, 1060 BaseClassDecl, 1061 /*BaseIsVirtual*/ false); 1062 } 1063 1064 // Destroy direct fields. 1065 SmallVector<const FieldDecl *, 16> FieldDecls; 1066 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(), 1067 E = ClassDecl->field_end(); I != E; ++I) { 1068 const FieldDecl *field = *I; 1069 QualType type = field->getType(); 1070 QualType::DestructionKind dtorKind = type.isDestructedType(); 1071 if (!dtorKind) continue; 1072 1073 // Anonymous union members do not have their destructors called. 1074 const RecordType *RT = type->getAsUnionType(); 1075 if (RT && RT->getDecl()->isAnonymousStructOrUnion()) continue; 1076 1077 CleanupKind cleanupKind = getCleanupKind(dtorKind); 1078 EHStack.pushCleanup<DestroyField>(cleanupKind, field, 1079 getDestroyer(dtorKind), 1080 cleanupKind & EHCleanup); 1081 } 1082 } 1083 1084 /// EmitCXXAggrConstructorCall - Emit a loop to call a particular 1085 /// constructor for each of several members of an array. 1086 /// 1087 /// \param ctor the constructor to call for each element 1088 /// \param argBegin,argEnd the arguments to evaluate and pass to the 1089 /// constructor 1090 /// \param arrayType the type of the array to initialize 1091 /// \param arrayBegin an arrayType* 1092 /// \param zeroInitialize true if each element should be 1093 /// zero-initialized before it is constructed 1094 void 1095 CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor, 1096 const ConstantArrayType *arrayType, 1097 llvm::Value *arrayBegin, 1098 CallExpr::const_arg_iterator argBegin, 1099 CallExpr::const_arg_iterator argEnd, 1100 bool zeroInitialize) { 1101 QualType elementType; 1102 llvm::Value *numElements = 1103 emitArrayLength(arrayType, elementType, arrayBegin); 1104 1105 EmitCXXAggrConstructorCall(ctor, numElements, arrayBegin, 1106 argBegin, argEnd, zeroInitialize); 1107 } 1108 1109 /// EmitCXXAggrConstructorCall - Emit a loop to call a particular 1110 /// constructor for each of several members of an array. 1111 /// 1112 /// \param ctor the constructor to call for each element 1113 /// \param numElements the number of elements in the array; 1114 /// may be zero 1115 /// \param argBegin,argEnd the arguments to evaluate and pass to the 1116 /// constructor 1117 /// \param arrayBegin a T*, where T is the type constructed by ctor 1118 /// \param zeroInitialize true if each element should be 1119 /// zero-initialized before it is constructed 1120 void 1121 CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor, 1122 llvm::Value *numElements, 1123 llvm::Value *arrayBegin, 1124 CallExpr::const_arg_iterator argBegin, 1125 CallExpr::const_arg_iterator argEnd, 1126 bool zeroInitialize) { 1127 1128 // It's legal for numElements to be zero. This can happen both 1129 // dynamically, because x can be zero in 'new A[x]', and statically, 1130 // because of GCC extensions that permit zero-length arrays. There 1131 // are probably legitimate places where we could assume that this 1132 // doesn't happen, but it's not clear that it's worth it. 1133 llvm::BranchInst *zeroCheckBranch = 0; 1134 1135 // Optimize for a constant count. 1136 llvm::ConstantInt *constantCount 1137 = dyn_cast<llvm::ConstantInt>(numElements); 1138 if (constantCount) { 1139 // Just skip out if the constant count is zero. 1140 if (constantCount->isZero()) return; 1141 1142 // Otherwise, emit the check. 1143 } else { 1144 llvm::BasicBlock *loopBB = createBasicBlock("new.ctorloop"); 1145 llvm::Value *iszero = Builder.CreateIsNull(numElements, "isempty"); 1146 zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB); 1147 EmitBlock(loopBB); 1148 } 1149 1150 // Find the end of the array. 1151 llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements, 1152 "arrayctor.end"); 1153 1154 // Enter the loop, setting up a phi for the current location to initialize. 1155 llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); 1156 llvm::BasicBlock *loopBB = createBasicBlock("arrayctor.loop"); 1157 EmitBlock(loopBB); 1158 llvm::PHINode *cur = Builder.CreatePHI(arrayBegin->getType(), 2, 1159 "arrayctor.cur"); 1160 cur->addIncoming(arrayBegin, entryBB); 1161 1162 // Inside the loop body, emit the constructor call on the array element. 1163 1164 QualType type = getContext().getTypeDeclType(ctor->getParent()); 1165 1166 // Zero initialize the storage, if requested. 1167 if (zeroInitialize) 1168 EmitNullInitialization(cur, type); 1169 1170 // C++ [class.temporary]p4: 1171 // There are two contexts in which temporaries are destroyed at a different 1172 // point than the end of the full-expression. The first context is when a 1173 // default constructor is called to initialize an element of an array. 1174 // If the constructor has one or more default arguments, the destruction of 1175 // every temporary created in a default argument expression is sequenced 1176 // before the construction of the next array element, if any. 1177 1178 { 1179 RunCleanupsScope Scope(*this); 1180 1181 // Evaluate the constructor and its arguments in a regular 1182 // partial-destroy cleanup. 1183 if (getLangOpts().Exceptions && 1184 !ctor->getParent()->hasTrivialDestructor()) { 1185 Destroyer *destroyer = destroyCXXObject; 1186 pushRegularPartialArrayCleanup(arrayBegin, cur, type, *destroyer); 1187 } 1188 1189 EmitCXXConstructorCall(ctor, Ctor_Complete, /*ForVirtualBase=*/ false, 1190 cur, argBegin, argEnd); 1191 } 1192 1193 // Go to the next element. 1194 llvm::Value *next = 1195 Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1), 1196 "arrayctor.next"); 1197 cur->addIncoming(next, Builder.GetInsertBlock()); 1198 1199 // Check whether that's the end of the loop. 1200 llvm::Value *done = Builder.CreateICmpEQ(next, arrayEnd, "arrayctor.done"); 1201 llvm::BasicBlock *contBB = createBasicBlock("arrayctor.cont"); 1202 Builder.CreateCondBr(done, contBB, loopBB); 1203 1204 // Patch the earlier check to skip over the loop. 1205 if (zeroCheckBranch) zeroCheckBranch->setSuccessor(0, contBB); 1206 1207 EmitBlock(contBB); 1208 } 1209 1210 void CodeGenFunction::destroyCXXObject(CodeGenFunction &CGF, 1211 llvm::Value *addr, 1212 QualType type) { 1213 const RecordType *rtype = type->castAs<RecordType>(); 1214 const CXXRecordDecl *record = cast<CXXRecordDecl>(rtype->getDecl()); 1215 const CXXDestructorDecl *dtor = record->getDestructor(); 1216 assert(!dtor->isTrivial()); 1217 CGF.EmitCXXDestructorCall(dtor, Dtor_Complete, /*for vbase*/ false, 1218 addr); 1219 } 1220 1221 void 1222 CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D, 1223 CXXCtorType Type, bool ForVirtualBase, 1224 llvm::Value *This, 1225 CallExpr::const_arg_iterator ArgBeg, 1226 CallExpr::const_arg_iterator ArgEnd) { 1227 1228 CGDebugInfo *DI = getDebugInfo(); 1229 if (DI && CGM.getCodeGenOpts().LimitDebugInfo) { 1230 // If debug info for this class has not been emitted then this is the 1231 // right time to do so. 1232 const CXXRecordDecl *Parent = D->getParent(); 1233 DI->getOrCreateRecordType(CGM.getContext().getTypeDeclType(Parent), 1234 Parent->getLocation()); 1235 } 1236 1237 if (D->isTrivial()) { 1238 if (ArgBeg == ArgEnd) { 1239 // Trivial default constructor, no codegen required. 1240 assert(D->isDefaultConstructor() && 1241 "trivial 0-arg ctor not a default ctor"); 1242 return; 1243 } 1244 1245 assert(ArgBeg + 1 == ArgEnd && "unexpected argcount for trivial ctor"); 1246 assert(D->isCopyOrMoveConstructor() && 1247 "trivial 1-arg ctor not a copy/move ctor"); 1248 1249 const Expr *E = (*ArgBeg); 1250 QualType Ty = E->getType(); 1251 llvm::Value *Src = EmitLValue(E).getAddress(); 1252 EmitAggregateCopy(This, Src, Ty); 1253 return; 1254 } 1255 1256 llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(D, Type), ForVirtualBase); 1257 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type); 1258 1259 EmitCXXMemberCall(D, Callee, ReturnValueSlot(), This, VTT, ArgBeg, ArgEnd); 1260 } 1261 1262 void 1263 CodeGenFunction::EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, 1264 llvm::Value *This, llvm::Value *Src, 1265 CallExpr::const_arg_iterator ArgBeg, 1266 CallExpr::const_arg_iterator ArgEnd) { 1267 if (D->isTrivial()) { 1268 assert(ArgBeg + 1 == ArgEnd && "unexpected argcount for trivial ctor"); 1269 assert(D->isCopyOrMoveConstructor() && 1270 "trivial 1-arg ctor not a copy/move ctor"); 1271 EmitAggregateCopy(This, Src, (*ArgBeg)->getType()); 1272 return; 1273 } 1274 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, 1275 clang::Ctor_Complete); 1276 assert(D->isInstance() && 1277 "Trying to emit a member call expr on a static method!"); 1278 1279 const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>(); 1280 1281 CallArgList Args; 1282 1283 // Push the this ptr. 1284 Args.add(RValue::get(This), D->getThisType(getContext())); 1285 1286 1287 // Push the src ptr. 1288 QualType QT = *(FPT->arg_type_begin()); 1289 llvm::Type *t = CGM.getTypes().ConvertType(QT); 1290 Src = Builder.CreateBitCast(Src, t); 1291 Args.add(RValue::get(Src), QT); 1292 1293 // Skip over first argument (Src). 1294 ++ArgBeg; 1295 CallExpr::const_arg_iterator Arg = ArgBeg; 1296 for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin()+1, 1297 E = FPT->arg_type_end(); I != E; ++I, ++Arg) { 1298 assert(Arg != ArgEnd && "Running over edge of argument list!"); 1299 EmitCallArg(Args, *Arg, *I); 1300 } 1301 // Either we've emitted all the call args, or we have a call to a 1302 // variadic function. 1303 assert((Arg == ArgEnd || FPT->isVariadic()) && 1304 "Extra arguments in non-variadic function!"); 1305 // If we still have any arguments, emit them using the type of the argument. 1306 for (; Arg != ArgEnd; ++Arg) { 1307 QualType ArgType = Arg->getType(); 1308 EmitCallArg(Args, *Arg, ArgType); 1309 } 1310 1311 EmitCall(CGM.getTypes().arrangeFunctionCall(Args, FPT), Callee, 1312 ReturnValueSlot(), Args, D); 1313 } 1314 1315 void 1316 CodeGenFunction::EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor, 1317 CXXCtorType CtorType, 1318 const FunctionArgList &Args) { 1319 CallArgList DelegateArgs; 1320 1321 FunctionArgList::const_iterator I = Args.begin(), E = Args.end(); 1322 assert(I != E && "no parameters to constructor"); 1323 1324 // this 1325 DelegateArgs.add(RValue::get(LoadCXXThis()), (*I)->getType()); 1326 ++I; 1327 1328 // vtt 1329 if (llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(Ctor, CtorType), 1330 /*ForVirtualBase=*/false)) { 1331 QualType VoidPP = getContext().getPointerType(getContext().VoidPtrTy); 1332 DelegateArgs.add(RValue::get(VTT), VoidPP); 1333 1334 if (CodeGenVTables::needsVTTParameter(CurGD)) { 1335 assert(I != E && "cannot skip vtt parameter, already done with args"); 1336 assert((*I)->getType() == VoidPP && "skipping parameter not of vtt type"); 1337 ++I; 1338 } 1339 } 1340 1341 // Explicit arguments. 1342 for (; I != E; ++I) { 1343 const VarDecl *param = *I; 1344 EmitDelegateCallArg(DelegateArgs, param); 1345 } 1346 1347 EmitCall(CGM.getTypes().arrangeCXXConstructorDeclaration(Ctor, CtorType), 1348 CGM.GetAddrOfCXXConstructor(Ctor, CtorType), 1349 ReturnValueSlot(), DelegateArgs, Ctor); 1350 } 1351 1352 namespace { 1353 struct CallDelegatingCtorDtor : EHScopeStack::Cleanup { 1354 const CXXDestructorDecl *Dtor; 1355 llvm::Value *Addr; 1356 CXXDtorType Type; 1357 1358 CallDelegatingCtorDtor(const CXXDestructorDecl *D, llvm::Value *Addr, 1359 CXXDtorType Type) 1360 : Dtor(D), Addr(Addr), Type(Type) {} 1361 1362 void Emit(CodeGenFunction &CGF, Flags flags) { 1363 CGF.EmitCXXDestructorCall(Dtor, Type, /*ForVirtualBase=*/false, 1364 Addr); 1365 } 1366 }; 1367 } 1368 1369 void 1370 CodeGenFunction::EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor, 1371 const FunctionArgList &Args) { 1372 assert(Ctor->isDelegatingConstructor()); 1373 1374 llvm::Value *ThisPtr = LoadCXXThis(); 1375 1376 QualType Ty = getContext().getTagDeclType(Ctor->getParent()); 1377 CharUnits Alignment = getContext().getTypeAlignInChars(Ty); 1378 AggValueSlot AggSlot = 1379 AggValueSlot::forAddr(ThisPtr, Alignment, Qualifiers(), 1380 AggValueSlot::IsDestructed, 1381 AggValueSlot::DoesNotNeedGCBarriers, 1382 AggValueSlot::IsNotAliased); 1383 1384 EmitAggExpr(Ctor->init_begin()[0]->getInit(), AggSlot); 1385 1386 const CXXRecordDecl *ClassDecl = Ctor->getParent(); 1387 if (CGM.getLangOpts().Exceptions && !ClassDecl->hasTrivialDestructor()) { 1388 CXXDtorType Type = 1389 CurGD.getCtorType() == Ctor_Complete ? Dtor_Complete : Dtor_Base; 1390 1391 EHStack.pushCleanup<CallDelegatingCtorDtor>(EHCleanup, 1392 ClassDecl->getDestructor(), 1393 ThisPtr, Type); 1394 } 1395 } 1396 1397 void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *DD, 1398 CXXDtorType Type, 1399 bool ForVirtualBase, 1400 llvm::Value *This) { 1401 llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(DD, Type), 1402 ForVirtualBase); 1403 llvm::Value *Callee = 0; 1404 if (getContext().getLangOpts().AppleKext) 1405 Callee = BuildAppleKextVirtualDestructorCall(DD, Type, 1406 DD->getParent()); 1407 1408 if (!Callee) 1409 Callee = CGM.GetAddrOfCXXDestructor(DD, Type); 1410 1411 EmitCXXMemberCall(DD, Callee, ReturnValueSlot(), This, VTT, 0, 0); 1412 } 1413 1414 namespace { 1415 struct CallLocalDtor : EHScopeStack::Cleanup { 1416 const CXXDestructorDecl *Dtor; 1417 llvm::Value *Addr; 1418 1419 CallLocalDtor(const CXXDestructorDecl *D, llvm::Value *Addr) 1420 : Dtor(D), Addr(Addr) {} 1421 1422 void Emit(CodeGenFunction &CGF, Flags flags) { 1423 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, 1424 /*ForVirtualBase=*/false, Addr); 1425 } 1426 }; 1427 } 1428 1429 void CodeGenFunction::PushDestructorCleanup(const CXXDestructorDecl *D, 1430 llvm::Value *Addr) { 1431 EHStack.pushCleanup<CallLocalDtor>(NormalAndEHCleanup, D, Addr); 1432 } 1433 1434 void CodeGenFunction::PushDestructorCleanup(QualType T, llvm::Value *Addr) { 1435 CXXRecordDecl *ClassDecl = T->getAsCXXRecordDecl(); 1436 if (!ClassDecl) return; 1437 if (ClassDecl->hasTrivialDestructor()) return; 1438 1439 const CXXDestructorDecl *D = ClassDecl->getDestructor(); 1440 assert(D && D->isUsed() && "destructor not marked as used!"); 1441 PushDestructorCleanup(D, Addr); 1442 } 1443 1444 llvm::Value * 1445 CodeGenFunction::GetVirtualBaseClassOffset(llvm::Value *This, 1446 const CXXRecordDecl *ClassDecl, 1447 const CXXRecordDecl *BaseClassDecl) { 1448 llvm::Value *VTablePtr = GetVTablePtr(This, Int8PtrTy); 1449 CharUnits VBaseOffsetOffset = 1450 CGM.getVTableContext().getVirtualBaseOffsetOffset(ClassDecl, BaseClassDecl); 1451 1452 llvm::Value *VBaseOffsetPtr = 1453 Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(), 1454 "vbase.offset.ptr"); 1455 llvm::Type *PtrDiffTy = 1456 ConvertType(getContext().getPointerDiffType()); 1457 1458 VBaseOffsetPtr = Builder.CreateBitCast(VBaseOffsetPtr, 1459 PtrDiffTy->getPointerTo()); 1460 1461 llvm::Value *VBaseOffset = Builder.CreateLoad(VBaseOffsetPtr, "vbase.offset"); 1462 1463 return VBaseOffset; 1464 } 1465 1466 void 1467 CodeGenFunction::InitializeVTablePointer(BaseSubobject Base, 1468 const CXXRecordDecl *NearestVBase, 1469 CharUnits OffsetFromNearestVBase, 1470 llvm::Constant *VTable, 1471 const CXXRecordDecl *VTableClass) { 1472 const CXXRecordDecl *RD = Base.getBase(); 1473 1474 // Compute the address point. 1475 llvm::Value *VTableAddressPoint; 1476 1477 // Check if we need to use a vtable from the VTT. 1478 if (CodeGenVTables::needsVTTParameter(CurGD) && 1479 (RD->getNumVBases() || NearestVBase)) { 1480 // Get the secondary vpointer index. 1481 uint64_t VirtualPointerIndex = 1482 CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base); 1483 1484 /// Load the VTT. 1485 llvm::Value *VTT = LoadCXXVTT(); 1486 if (VirtualPointerIndex) 1487 VTT = Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex); 1488 1489 // And load the address point from the VTT. 1490 VTableAddressPoint = Builder.CreateLoad(VTT); 1491 } else { 1492 uint64_t AddressPoint = 1493 CGM.getVTableContext().getVTableLayout(VTableClass).getAddressPoint(Base); 1494 VTableAddressPoint = 1495 Builder.CreateConstInBoundsGEP2_64(VTable, 0, AddressPoint); 1496 } 1497 1498 // Compute where to store the address point. 1499 llvm::Value *VirtualOffset = 0; 1500 CharUnits NonVirtualOffset = CharUnits::Zero(); 1501 1502 if (CodeGenVTables::needsVTTParameter(CurGD) && NearestVBase) { 1503 // We need to use the virtual base offset offset because the virtual base 1504 // might have a different offset in the most derived class. 1505 VirtualOffset = GetVirtualBaseClassOffset(LoadCXXThis(), VTableClass, 1506 NearestVBase); 1507 NonVirtualOffset = OffsetFromNearestVBase; 1508 } else { 1509 // We can just use the base offset in the complete class. 1510 NonVirtualOffset = Base.getBaseOffset(); 1511 } 1512 1513 // Apply the offsets. 1514 llvm::Value *VTableField = LoadCXXThis(); 1515 1516 if (!NonVirtualOffset.isZero() || VirtualOffset) 1517 VTableField = ApplyNonVirtualAndVirtualOffset(*this, VTableField, 1518 NonVirtualOffset, 1519 VirtualOffset); 1520 1521 // Finally, store the address point. 1522 llvm::Type *AddressPointPtrTy = 1523 VTableAddressPoint->getType()->getPointerTo(); 1524 VTableField = Builder.CreateBitCast(VTableField, AddressPointPtrTy); 1525 llvm::StoreInst *Store = Builder.CreateStore(VTableAddressPoint, VTableField); 1526 CGM.DecorateInstruction(Store, CGM.getTBAAInfoForVTablePtr()); 1527 } 1528 1529 void 1530 CodeGenFunction::InitializeVTablePointers(BaseSubobject Base, 1531 const CXXRecordDecl *NearestVBase, 1532 CharUnits OffsetFromNearestVBase, 1533 bool BaseIsNonVirtualPrimaryBase, 1534 llvm::Constant *VTable, 1535 const CXXRecordDecl *VTableClass, 1536 VisitedVirtualBasesSetTy& VBases) { 1537 // If this base is a non-virtual primary base the address point has already 1538 // been set. 1539 if (!BaseIsNonVirtualPrimaryBase) { 1540 // Initialize the vtable pointer for this base. 1541 InitializeVTablePointer(Base, NearestVBase, OffsetFromNearestVBase, 1542 VTable, VTableClass); 1543 } 1544 1545 const CXXRecordDecl *RD = Base.getBase(); 1546 1547 // Traverse bases. 1548 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1549 E = RD->bases_end(); I != E; ++I) { 1550 CXXRecordDecl *BaseDecl 1551 = cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 1552 1553 // Ignore classes without a vtable. 1554 if (!BaseDecl->isDynamicClass()) 1555 continue; 1556 1557 CharUnits BaseOffset; 1558 CharUnits BaseOffsetFromNearestVBase; 1559 bool BaseDeclIsNonVirtualPrimaryBase; 1560 1561 if (I->isVirtual()) { 1562 // Check if we've visited this virtual base before. 1563 if (!VBases.insert(BaseDecl)) 1564 continue; 1565 1566 const ASTRecordLayout &Layout = 1567 getContext().getASTRecordLayout(VTableClass); 1568 1569 BaseOffset = Layout.getVBaseClassOffset(BaseDecl); 1570 BaseOffsetFromNearestVBase = CharUnits::Zero(); 1571 BaseDeclIsNonVirtualPrimaryBase = false; 1572 } else { 1573 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD); 1574 1575 BaseOffset = Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl); 1576 BaseOffsetFromNearestVBase = 1577 OffsetFromNearestVBase + Layout.getBaseClassOffset(BaseDecl); 1578 BaseDeclIsNonVirtualPrimaryBase = Layout.getPrimaryBase() == BaseDecl; 1579 } 1580 1581 InitializeVTablePointers(BaseSubobject(BaseDecl, BaseOffset), 1582 I->isVirtual() ? BaseDecl : NearestVBase, 1583 BaseOffsetFromNearestVBase, 1584 BaseDeclIsNonVirtualPrimaryBase, 1585 VTable, VTableClass, VBases); 1586 } 1587 } 1588 1589 void CodeGenFunction::InitializeVTablePointers(const CXXRecordDecl *RD) { 1590 // Ignore classes without a vtable. 1591 if (!RD->isDynamicClass()) 1592 return; 1593 1594 // Get the VTable. 1595 llvm::Constant *VTable = CGM.getVTables().GetAddrOfVTable(RD); 1596 1597 // Initialize the vtable pointers for this class and all of its bases. 1598 VisitedVirtualBasesSetTy VBases; 1599 InitializeVTablePointers(BaseSubobject(RD, CharUnits::Zero()), 1600 /*NearestVBase=*/0, 1601 /*OffsetFromNearestVBase=*/CharUnits::Zero(), 1602 /*BaseIsNonVirtualPrimaryBase=*/false, 1603 VTable, RD, VBases); 1604 } 1605 1606 llvm::Value *CodeGenFunction::GetVTablePtr(llvm::Value *This, 1607 llvm::Type *Ty) { 1608 llvm::Value *VTablePtrSrc = Builder.CreateBitCast(This, Ty->getPointerTo()); 1609 llvm::Instruction *VTable = Builder.CreateLoad(VTablePtrSrc, "vtable"); 1610 CGM.DecorateInstruction(VTable, CGM.getTBAAInfoForVTablePtr()); 1611 return VTable; 1612 } 1613 1614 static const CXXRecordDecl *getMostDerivedClassDecl(const Expr *Base) { 1615 const Expr *E = Base; 1616 1617 while (true) { 1618 E = E->IgnoreParens(); 1619 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 1620 if (CE->getCastKind() == CK_DerivedToBase || 1621 CE->getCastKind() == CK_UncheckedDerivedToBase || 1622 CE->getCastKind() == CK_NoOp) { 1623 E = CE->getSubExpr(); 1624 continue; 1625 } 1626 } 1627 1628 break; 1629 } 1630 1631 QualType DerivedType = E->getType(); 1632 if (const PointerType *PTy = DerivedType->getAs<PointerType>()) 1633 DerivedType = PTy->getPointeeType(); 1634 1635 return cast<CXXRecordDecl>(DerivedType->castAs<RecordType>()->getDecl()); 1636 } 1637 1638 // FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do 1639 // quite what we want. 1640 static const Expr *skipNoOpCastsAndParens(const Expr *E) { 1641 while (true) { 1642 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 1643 E = PE->getSubExpr(); 1644 continue; 1645 } 1646 1647 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 1648 if (CE->getCastKind() == CK_NoOp) { 1649 E = CE->getSubExpr(); 1650 continue; 1651 } 1652 } 1653 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 1654 if (UO->getOpcode() == UO_Extension) { 1655 E = UO->getSubExpr(); 1656 continue; 1657 } 1658 } 1659 return E; 1660 } 1661 } 1662 1663 /// canDevirtualizeMemberFunctionCall - Checks whether the given virtual member 1664 /// function call on the given expr can be devirtualized. 1665 static bool canDevirtualizeMemberFunctionCall(const Expr *Base, 1666 const CXXMethodDecl *MD) { 1667 // If the most derived class is marked final, we know that no subclass can 1668 // override this member function and so we can devirtualize it. For example: 1669 // 1670 // struct A { virtual void f(); } 1671 // struct B final : A { }; 1672 // 1673 // void f(B *b) { 1674 // b->f(); 1675 // } 1676 // 1677 const CXXRecordDecl *MostDerivedClassDecl = getMostDerivedClassDecl(Base); 1678 if (MostDerivedClassDecl->hasAttr<FinalAttr>()) 1679 return true; 1680 1681 // If the member function is marked 'final', we know that it can't be 1682 // overridden and can therefore devirtualize it. 1683 if (MD->hasAttr<FinalAttr>()) 1684 return true; 1685 1686 // Similarly, if the class itself is marked 'final' it can't be overridden 1687 // and we can therefore devirtualize the member function call. 1688 if (MD->getParent()->hasAttr<FinalAttr>()) 1689 return true; 1690 1691 Base = skipNoOpCastsAndParens(Base); 1692 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 1693 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) { 1694 // This is a record decl. We know the type and can devirtualize it. 1695 return VD->getType()->isRecordType(); 1696 } 1697 1698 return false; 1699 } 1700 1701 // We can always devirtualize calls on temporary object expressions. 1702 if (isa<CXXConstructExpr>(Base)) 1703 return true; 1704 1705 // And calls on bound temporaries. 1706 if (isa<CXXBindTemporaryExpr>(Base)) 1707 return true; 1708 1709 // Check if this is a call expr that returns a record type. 1710 if (const CallExpr *CE = dyn_cast<CallExpr>(Base)) 1711 return CE->getCallReturnType()->isRecordType(); 1712 1713 // We can't devirtualize the call. 1714 return false; 1715 } 1716 1717 static bool UseVirtualCall(ASTContext &Context, 1718 const CXXOperatorCallExpr *CE, 1719 const CXXMethodDecl *MD) { 1720 if (!MD->isVirtual()) 1721 return false; 1722 1723 // When building with -fapple-kext, all calls must go through the vtable since 1724 // the kernel linker can do runtime patching of vtables. 1725 if (Context.getLangOpts().AppleKext) 1726 return true; 1727 1728 return !canDevirtualizeMemberFunctionCall(CE->getArg(0), MD); 1729 } 1730 1731 llvm::Value * 1732 CodeGenFunction::EmitCXXOperatorMemberCallee(const CXXOperatorCallExpr *E, 1733 const CXXMethodDecl *MD, 1734 llvm::Value *This) { 1735 llvm::FunctionType *fnType = 1736 CGM.getTypes().GetFunctionType( 1737 CGM.getTypes().arrangeCXXMethodDeclaration(MD)); 1738 1739 if (UseVirtualCall(getContext(), E, MD)) 1740 return BuildVirtualCall(MD, This, fnType); 1741 1742 return CGM.GetAddrOfFunction(MD, fnType); 1743 } 1744 1745 void CodeGenFunction::EmitForwardingCallToLambda(const CXXRecordDecl *Lambda, 1746 CallArgList &CallArgs) { 1747 // Lookup the call operator 1748 DeclarationName Name 1749 = getContext().DeclarationNames.getCXXOperatorName(OO_Call); 1750 DeclContext::lookup_const_result Calls = Lambda->lookup(Name); 1751 CXXMethodDecl *CallOperator = cast<CXXMethodDecl>(*Calls.first++); 1752 const FunctionProtoType *FPT = 1753 CallOperator->getType()->getAs<FunctionProtoType>(); 1754 QualType ResultType = FPT->getResultType(); 1755 1756 // Get the address of the call operator. 1757 GlobalDecl GD(CallOperator); 1758 const CGFunctionInfo &CalleeFnInfo = 1759 CGM.getTypes().arrangeFunctionCall(ResultType, CallArgs, FPT->getExtInfo(), 1760 RequiredArgs::forPrototypePlus(FPT, 1)); 1761 llvm::Type *Ty = CGM.getTypes().GetFunctionType(CalleeFnInfo); 1762 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty); 1763 1764 // Determine whether we have a return value slot to use. 1765 ReturnValueSlot Slot; 1766 if (!ResultType->isVoidType() && 1767 CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 1768 hasAggregateLLVMType(CurFnInfo->getReturnType())) 1769 Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified()); 1770 1771 // Now emit our call. 1772 RValue RV = EmitCall(CalleeFnInfo, Callee, Slot, CallArgs, CallOperator); 1773 1774 // Forward the returned value 1775 if (!ResultType->isVoidType() && Slot.isNull()) 1776 EmitReturnOfRValue(RV, ResultType); 1777 } 1778 1779 void CodeGenFunction::EmitLambdaBlockInvokeBody() { 1780 const BlockDecl *BD = BlockInfo->getBlockDecl(); 1781 const VarDecl *variable = BD->capture_begin()->getVariable(); 1782 const CXXRecordDecl *Lambda = variable->getType()->getAsCXXRecordDecl(); 1783 1784 // Start building arguments for forwarding call 1785 CallArgList CallArgs; 1786 1787 QualType ThisType = getContext().getPointerType(getContext().getRecordType(Lambda)); 1788 llvm::Value *ThisPtr = GetAddrOfBlockDecl(variable, false); 1789 CallArgs.add(RValue::get(ThisPtr), ThisType); 1790 1791 // Add the rest of the parameters. 1792 for (BlockDecl::param_const_iterator I = BD->param_begin(), 1793 E = BD->param_end(); I != E; ++I) { 1794 ParmVarDecl *param = *I; 1795 EmitDelegateCallArg(CallArgs, param); 1796 } 1797 1798 EmitForwardingCallToLambda(Lambda, CallArgs); 1799 } 1800 1801 void CodeGenFunction::EmitLambdaToBlockPointerBody(FunctionArgList &Args) { 1802 if (cast<CXXMethodDecl>(CurFuncDecl)->isVariadic()) { 1803 // FIXME: Making this work correctly is nasty because it requires either 1804 // cloning the body of the call operator or making the call operator forward. 1805 CGM.ErrorUnsupported(CurFuncDecl, "lambda conversion to variadic function"); 1806 return; 1807 } 1808 1809 EmitFunctionBody(Args); 1810 } 1811 1812 void CodeGenFunction::EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD) { 1813 const CXXRecordDecl *Lambda = MD->getParent(); 1814 1815 // Start building arguments for forwarding call 1816 CallArgList CallArgs; 1817 1818 QualType ThisType = getContext().getPointerType(getContext().getRecordType(Lambda)); 1819 llvm::Value *ThisPtr = llvm::UndefValue::get(getTypes().ConvertType(ThisType)); 1820 CallArgs.add(RValue::get(ThisPtr), ThisType); 1821 1822 // Add the rest of the parameters. 1823 for (FunctionDecl::param_const_iterator I = MD->param_begin(), 1824 E = MD->param_end(); I != E; ++I) { 1825 ParmVarDecl *param = *I; 1826 EmitDelegateCallArg(CallArgs, param); 1827 } 1828 1829 EmitForwardingCallToLambda(Lambda, CallArgs); 1830 } 1831 1832 void CodeGenFunction::EmitLambdaStaticInvokeFunction(const CXXMethodDecl *MD) { 1833 if (MD->isVariadic()) { 1834 // FIXME: Making this work correctly is nasty because it requires either 1835 // cloning the body of the call operator or making the call operator forward. 1836 CGM.ErrorUnsupported(MD, "lambda conversion to variadic function"); 1837 return; 1838 } 1839 1840 EmitLambdaDelegatingInvokeBody(MD); 1841 } 1842