CGCXX.cpp revision f9a883c27e3b5724a5a59499691fa109eb5032f8
1//===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===// 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. 11// 12//===----------------------------------------------------------------------===// 13 14// We might split this into multiple files if it gets too unwieldy 15 16#include "CodeGenFunction.h" 17#include "CodeGenModule.h" 18#include "Mangle.h" 19#include "clang/AST/ASTContext.h" 20#include "clang/AST/RecordLayout.h" 21#include "clang/AST/Decl.h" 22#include "clang/AST/DeclCXX.h" 23#include "clang/AST/DeclObjC.h" 24#include "llvm/ADT/StringExtras.h" 25using namespace clang; 26using namespace CodeGen; 27 28void 29CodeGenFunction::EmitCXXGlobalDtorRegistration(const CXXDestructorDecl *Dtor, 30 llvm::Constant *DeclPtr) { 31 // FIXME: This is ABI dependent and we use the Itanium ABI. 32 33 const llvm::Type *Int8PtrTy = 34 llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext)); 35 36 std::vector<const llvm::Type *> Params; 37 Params.push_back(Int8PtrTy); 38 39 // Get the destructor function type 40 const llvm::Type *DtorFnTy = 41 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Params, false); 42 DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy); 43 44 Params.clear(); 45 Params.push_back(DtorFnTy); 46 Params.push_back(Int8PtrTy); 47 Params.push_back(Int8PtrTy); 48 49 // Get the __cxa_atexit function type 50 // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d ); 51 const llvm::FunctionType *AtExitFnTy = 52 llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false); 53 54 llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy, 55 "__cxa_atexit"); 56 57 llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy, 58 "__dso_handle"); 59 60 llvm::Constant *DtorFn = CGM.GetAddrOfCXXDestructor(Dtor, Dtor_Complete); 61 62 llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy), 63 llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy), 64 llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) }; 65 Builder.CreateCall(AtExitFn, &Args[0], llvm::array_endof(Args)); 66} 67 68void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D, 69 llvm::Constant *DeclPtr) { 70 assert(D.hasGlobalStorage() && 71 "VarDecl must have global storage!"); 72 73 const Expr *Init = D.getInit(); 74 QualType T = D.getType(); 75 76 if (T->isReferenceType()) { 77 ErrorUnsupported(Init, "global variable that binds to a reference"); 78 } else if (!hasAggregateLLVMType(T)) { 79 llvm::Value *V = EmitScalarExpr(Init); 80 EmitStoreOfScalar(V, DeclPtr, T.isVolatileQualified(), T); 81 } else if (T->isAnyComplexType()) { 82 EmitComplexExprIntoAddr(Init, DeclPtr, T.isVolatileQualified()); 83 } else { 84 EmitAggExpr(Init, DeclPtr, T.isVolatileQualified()); 85 86 if (const RecordType *RT = T->getAs<RecordType>()) { 87 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 88 if (!RD->hasTrivialDestructor()) 89 EmitCXXGlobalDtorRegistration(RD->getDestructor(getContext()), DeclPtr); 90 } 91 } 92} 93 94void 95CodeGenModule::EmitCXXGlobalInitFunc() { 96 if (CXXGlobalInits.empty()) 97 return; 98 99 const llvm::FunctionType *FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 100 false); 101 102 // Create our global initialization function. 103 // FIXME: Should this be tweakable by targets? 104 llvm::Function *Fn = 105 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, 106 "__cxx_global_initialization", &TheModule); 107 108 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, 109 &CXXGlobalInits[0], 110 CXXGlobalInits.size()); 111 AddGlobalCtor(Fn); 112} 113 114void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, 115 const VarDecl **Decls, 116 unsigned NumDecls) { 117 StartFunction(0, getContext().VoidTy, Fn, FunctionArgList(), 118 SourceLocation()); 119 120 for (unsigned i = 0; i != NumDecls; ++i) { 121 const VarDecl *D = Decls[i]; 122 123 llvm::Constant *DeclPtr = CGM.GetAddrOfGlobalVar(D); 124 EmitCXXGlobalVarDeclInit(*D, DeclPtr); 125 } 126 FinishFunction(); 127} 128 129void 130CodeGenFunction::EmitStaticCXXBlockVarDeclInit(const VarDecl &D, 131 llvm::GlobalVariable *GV) { 132 // FIXME: This should use __cxa_guard_{acquire,release}? 133 134 assert(!getContext().getLangOptions().ThreadsafeStatics && 135 "thread safe statics are currently not supported!"); 136 137 llvm::SmallString<256> GuardVName; 138 llvm::raw_svector_ostream GuardVOut(GuardVName); 139 mangleGuardVariable(&D, getContext(), GuardVOut); 140 141 // Create the guard variable. 142 llvm::GlobalValue *GuardV = 143 new llvm::GlobalVariable(CGM.getModule(), llvm::Type::getInt64Ty(VMContext), false, 144 GV->getLinkage(), 145 llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)), 146 GuardVName.str()); 147 148 // Load the first byte of the guard variable. 149 const llvm::Type *PtrTy = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 150 llvm::Value *V = Builder.CreateLoad(Builder.CreateBitCast(GuardV, PtrTy), 151 "tmp"); 152 153 // Compare it against 0. 154 llvm::Value *nullValue = llvm::Constant::getNullValue(llvm::Type::getInt8Ty(VMContext)); 155 llvm::Value *ICmp = Builder.CreateICmpEQ(V, nullValue , "tobool"); 156 157 llvm::BasicBlock *InitBlock = createBasicBlock("init"); 158 llvm::BasicBlock *EndBlock = createBasicBlock("init.end"); 159 160 // If the guard variable is 0, jump to the initializer code. 161 Builder.CreateCondBr(ICmp, InitBlock, EndBlock); 162 163 EmitBlock(InitBlock); 164 165 EmitCXXGlobalVarDeclInit(D, GV); 166 167 Builder.CreateStore(llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 1), 168 Builder.CreateBitCast(GuardV, PtrTy)); 169 170 EmitBlock(EndBlock); 171} 172 173RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD, 174 llvm::Value *Callee, 175 llvm::Value *This, 176 CallExpr::const_arg_iterator ArgBeg, 177 CallExpr::const_arg_iterator ArgEnd) { 178 assert(MD->isInstance() && 179 "Trying to emit a member call expr on a static method!"); 180 181 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 182 183 CallArgList Args; 184 185 // Push the this ptr. 186 Args.push_back(std::make_pair(RValue::get(This), 187 MD->getThisType(getContext()))); 188 189 // And the rest of the call args 190 EmitCallArgs(Args, FPT, ArgBeg, ArgEnd); 191 192 QualType ResultType = MD->getType()->getAsFunctionType()->getResultType(); 193 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args), 194 Callee, Args, MD); 195} 196 197RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE) { 198 const MemberExpr *ME = cast<MemberExpr>(CE->getCallee()); 199 const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl()); 200 201 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 202 203 const llvm::Type *Ty = 204 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 205 FPT->isVariadic()); 206 llvm::Value *This; 207 208 if (ME->isArrow()) 209 This = EmitScalarExpr(ME->getBase()); 210 else { 211 LValue BaseLV = EmitLValue(ME->getBase()); 212 This = BaseLV.getAddress(); 213 } 214 215 // C++ [class.virtual]p12: 216 // Explicit qualification with the scope operator (5.1) suppresses the 217 // virtual call mechanism. 218 llvm::Value *Callee; 219 if (MD->isVirtual() && !ME->hasQualifier()) 220 Callee = BuildVirtualCall(MD, This, Ty); 221 else 222 Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty); 223 224 return EmitCXXMemberCall(MD, Callee, This, 225 CE->arg_begin(), CE->arg_end()); 226} 227 228RValue 229CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, 230 const CXXMethodDecl *MD) { 231 assert(MD->isInstance() && 232 "Trying to emit a member call expr on a static method!"); 233 234 if (MD->isCopyAssignment()) { 235 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext()); 236 if (ClassDecl->hasTrivialCopyAssignment()) { 237 assert(!ClassDecl->hasUserDeclaredCopyAssignment() && 238 "EmitCXXOperatorMemberCallExpr - user declared copy assignment"); 239 llvm::Value *This = EmitLValue(E->getArg(0)).getAddress(); 240 llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress(); 241 QualType Ty = E->getType(); 242 EmitAggregateCopy(This, Src, Ty); 243 return RValue::get(This); 244 } 245 } 246 247 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 248 const llvm::Type *Ty = 249 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 250 FPT->isVariadic()); 251 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty); 252 253 llvm::Value *This = EmitLValue(E->getArg(0)).getAddress(); 254 255 return EmitCXXMemberCall(MD, Callee, This, 256 E->arg_begin() + 1, E->arg_end()); 257} 258 259RValue 260CodeGenFunction::EmitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *E) { 261 assert((E->getCastKind() == CastExpr::CK_UserDefinedConversion) && 262 "EmitCXXFunctionalCastExpr - called with wrong cast"); 263 264 CXXMethodDecl *MD = E->getTypeConversionMethod(); 265 assert(MD && "EmitCXXFunctionalCastExpr - null conversion method"); 266 assert(isa<CXXConversionDecl>(MD) && "EmitCXXFunctionalCastExpr - not" 267 " method decl"); 268 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 269 270 const llvm::Type *Ty = 271 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 272 FPT->isVariadic()); 273 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty); 274 llvm::Value *This = EmitLValue(E->getSubExpr()).getAddress(); 275 RValue RV = EmitCXXMemberCall(MD, Callee, This, 0, 0); 276 if (RV.isAggregate()) 277 RV = RValue::get(RV.getAggregateAddr()); 278 return RV; 279} 280 281llvm::Value *CodeGenFunction::LoadCXXThis() { 282 assert(isa<CXXMethodDecl>(CurFuncDecl) && 283 "Must be in a C++ member function decl to load 'this'"); 284 assert(cast<CXXMethodDecl>(CurFuncDecl)->isInstance() && 285 "Must be in a C++ member function decl to load 'this'"); 286 287 // FIXME: What if we're inside a block? 288 // ans: See how CodeGenFunction::LoadObjCSelf() uses 289 // CodeGenFunction::BlockForwardSelf() for how to do this. 290 return Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this"); 291} 292 293static bool 294GetNestedPaths(llvm::SmallVectorImpl<const CXXRecordDecl *> &NestedBasePaths, 295 const CXXRecordDecl *ClassDecl, 296 const CXXRecordDecl *BaseClassDecl) { 297 for (CXXRecordDecl::base_class_const_iterator i = ClassDecl->bases_begin(), 298 e = ClassDecl->bases_end(); i != e; ++i) { 299 if (i->isVirtual()) 300 continue; 301 const CXXRecordDecl *Base = 302 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 303 if (Base == BaseClassDecl) { 304 NestedBasePaths.push_back(BaseClassDecl); 305 return true; 306 } 307 } 308 // BaseClassDecl not an immediate base of ClassDecl. 309 for (CXXRecordDecl::base_class_const_iterator i = ClassDecl->bases_begin(), 310 e = ClassDecl->bases_end(); i != e; ++i) { 311 if (i->isVirtual()) 312 continue; 313 const CXXRecordDecl *Base = 314 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 315 if (GetNestedPaths(NestedBasePaths, Base, BaseClassDecl)) { 316 NestedBasePaths.push_back(Base); 317 return true; 318 } 319 } 320 return false; 321} 322 323llvm::Value *CodeGenFunction::AddressCXXOfBaseClass(llvm::Value *BaseValue, 324 const CXXRecordDecl *ClassDecl, 325 const CXXRecordDecl *BaseClassDecl) { 326 if (ClassDecl == BaseClassDecl) 327 return BaseValue; 328 329 llvm::Type *I8Ptr = llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext)); 330 llvm::SmallVector<const CXXRecordDecl *, 16> NestedBasePaths; 331 GetNestedPaths(NestedBasePaths, ClassDecl, BaseClassDecl); 332 assert(NestedBasePaths.size() > 0 && 333 "AddressCXXOfBaseClass - inheritence path failed"); 334 NestedBasePaths.push_back(ClassDecl); 335 uint64_t Offset = 0; 336 337 // Accessing a member of the base class. Must add delata to 338 // the load of 'this'. 339 for (unsigned i = NestedBasePaths.size()-1; i > 0; i--) { 340 const CXXRecordDecl *DerivedClass = NestedBasePaths[i]; 341 const CXXRecordDecl *BaseClass = NestedBasePaths[i-1]; 342 const ASTRecordLayout &Layout = 343 getContext().getASTRecordLayout(DerivedClass); 344 Offset += Layout.getBaseClassOffset(BaseClass) / 8; 345 } 346 llvm::Value *OffsetVal = 347 llvm::ConstantInt::get( 348 CGM.getTypes().ConvertType(CGM.getContext().LongTy), Offset); 349 BaseValue = Builder.CreateBitCast(BaseValue, I8Ptr); 350 BaseValue = Builder.CreateGEP(BaseValue, OffsetVal, "add.ptr"); 351 QualType BTy = 352 getContext().getCanonicalType( 353 getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(BaseClassDecl))); 354 const llvm::Type *BasePtr = ConvertType(BTy); 355 BasePtr = llvm::PointerType::getUnqual(BasePtr); 356 BaseValue = Builder.CreateBitCast(BaseValue, BasePtr); 357 return BaseValue; 358} 359 360/// EmitCXXAggrConstructorCall - This routine essentially creates a (nested) 361/// for-loop to call the default constructor on individual members of the 362/// array. 'Array' is the array type, 'This' is llvm pointer of the start 363/// of the array and 'D' is the default costructor Decl for elements of the 364/// array. It is assumed that all relevant checks have been made by the 365/// caller. 366void 367CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, 368 const ArrayType *Array, 369 llvm::Value *This) { 370 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array); 371 assert(CA && "Do we support VLA for construction ?"); 372 373 // Create a temporary for the loop index and initialize it with 0. 374 llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext), 375 "loop.index"); 376 llvm::Value* zeroConstant = 377 llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)); 378 Builder.CreateStore(zeroConstant, IndexPtr, false); 379 380 // Start the loop with a block that tests the condition. 381 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 382 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 383 384 EmitBlock(CondBlock); 385 386 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 387 388 // Generate: if (loop-index < number-of-elements fall to the loop body, 389 // otherwise, go to the block after the for-loop. 390 uint64_t NumElements = getContext().getConstantArrayElementCount(CA); 391 llvm::Value * NumElementsPtr = 392 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements); 393 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 394 llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr, 395 "isless"); 396 // If the condition is true, execute the body. 397 Builder.CreateCondBr(IsLess, ForBody, AfterFor); 398 399 EmitBlock(ForBody); 400 401 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 402 // Inside the loop body, emit the constructor call on the array element. 403 Counter = Builder.CreateLoad(IndexPtr); 404 llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx"); 405 EmitCXXConstructorCall(D, Ctor_Complete, Address, 0, 0); 406 407 EmitBlock(ContinueBlock); 408 409 // Emit the increment of the loop counter. 410 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1); 411 Counter = Builder.CreateLoad(IndexPtr); 412 NextVal = Builder.CreateAdd(Counter, NextVal, "inc"); 413 Builder.CreateStore(NextVal, IndexPtr, false); 414 415 // Finally, branch back up to the condition for the next iteration. 416 EmitBranch(CondBlock); 417 418 // Emit the fall-through block. 419 EmitBlock(AfterFor, true); 420} 421 422/// EmitCXXAggrDestructorCall - calls the default destructor on array 423/// elements in reverse order of construction. 424void 425CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D, 426 const ArrayType *Array, 427 llvm::Value *This) { 428 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array); 429 assert(CA && "Do we support VLA for destruction ?"); 430 llvm::Value *One = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 431 1); 432 uint64_t ElementCount = getContext().getConstantArrayElementCount(CA); 433 // Create a temporary for the loop index and initialize it with count of 434 // array elements. 435 llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext), 436 "loop.index"); 437 // Index = ElementCount; 438 llvm::Value* UpperCount = 439 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), ElementCount); 440 Builder.CreateStore(UpperCount, IndexPtr, false); 441 442 // Start the loop with a block that tests the condition. 443 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 444 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 445 446 EmitBlock(CondBlock); 447 448 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 449 450 // Generate: if (loop-index != 0 fall to the loop body, 451 // otherwise, go to the block after the for-loop. 452 llvm::Value* zeroConstant = 453 llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)); 454 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 455 llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant, 456 "isne"); 457 // If the condition is true, execute the body. 458 Builder.CreateCondBr(IsNE, ForBody, AfterFor); 459 460 EmitBlock(ForBody); 461 462 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 463 // Inside the loop body, emit the constructor call on the array element. 464 Counter = Builder.CreateLoad(IndexPtr); 465 Counter = Builder.CreateSub(Counter, One); 466 llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx"); 467 EmitCXXDestructorCall(D, Dtor_Complete, Address); 468 469 EmitBlock(ContinueBlock); 470 471 // Emit the decrement of the loop counter. 472 Counter = Builder.CreateLoad(IndexPtr); 473 Counter = Builder.CreateSub(Counter, One, "dec"); 474 Builder.CreateStore(Counter, IndexPtr, false); 475 476 // Finally, branch back up to the condition for the next iteration. 477 EmitBranch(CondBlock); 478 479 // Emit the fall-through block. 480 EmitBlock(AfterFor, true); 481} 482 483void 484CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D, 485 CXXCtorType Type, 486 llvm::Value *This, 487 CallExpr::const_arg_iterator ArgBeg, 488 CallExpr::const_arg_iterator ArgEnd) { 489 if (D->isCopyConstructor(getContext())) { 490 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D->getDeclContext()); 491 if (ClassDecl->hasTrivialCopyConstructor()) { 492 assert(!ClassDecl->hasUserDeclaredCopyConstructor() && 493 "EmitCXXConstructorCall - user declared copy constructor"); 494 const Expr *E = (*ArgBeg); 495 QualType Ty = E->getType(); 496 llvm::Value *Src = EmitLValue(E).getAddress(); 497 EmitAggregateCopy(This, Src, Ty); 498 return; 499 } 500 } 501 502 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type); 503 504 EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd); 505} 506 507void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D, 508 CXXDtorType Type, 509 llvm::Value *This) { 510 llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type); 511 512 EmitCXXMemberCall(D, Callee, This, 0, 0); 513} 514 515void 516CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest, 517 const CXXConstructExpr *E) { 518 assert(Dest && "Must have a destination!"); 519 520 const CXXRecordDecl *RD = 521 cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 522 if (RD->hasTrivialConstructor()) 523 return; 524 525 // Code gen optimization to eliminate copy constructor and return 526 // its first argument instead. 527 if (getContext().getLangOptions().ElideConstructors && E->isElidable()) { 528 CXXConstructExpr::const_arg_iterator i = E->arg_begin(); 529 EmitAggExpr((*i), Dest, false); 530 return; 531 } 532 // Call the constructor. 533 EmitCXXConstructorCall(E->getConstructor(), Ctor_Complete, Dest, 534 E->arg_begin(), E->arg_end()); 535} 536 537llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) { 538 if (E->isArray()) { 539 ErrorUnsupported(E, "new[] expression"); 540 return llvm::UndefValue::get(ConvertType(E->getType())); 541 } 542 543 QualType AllocType = E->getAllocatedType(); 544 FunctionDecl *NewFD = E->getOperatorNew(); 545 const FunctionProtoType *NewFTy = NewFD->getType()->getAsFunctionProtoType(); 546 547 CallArgList NewArgs; 548 549 // The allocation size is the first argument. 550 QualType SizeTy = getContext().getSizeType(); 551 llvm::Value *AllocSize = 552 llvm::ConstantInt::get(ConvertType(SizeTy), 553 getContext().getTypeSize(AllocType) / 8); 554 555 NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy)); 556 557 // Emit the rest of the arguments. 558 // FIXME: Ideally, this should just use EmitCallArgs. 559 CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin(); 560 561 // First, use the types from the function type. 562 // We start at 1 here because the first argument (the allocation size) 563 // has already been emitted. 564 for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) { 565 QualType ArgType = NewFTy->getArgType(i); 566 567 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()). 568 getTypePtr() == 569 getContext().getCanonicalType(NewArg->getType()).getTypePtr() && 570 "type mismatch in call argument!"); 571 572 NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType), 573 ArgType)); 574 575 } 576 577 // Either we've emitted all the call args, or we have a call to a 578 // variadic function. 579 assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) && 580 "Extra arguments in non-variadic function!"); 581 582 // If we still have any arguments, emit them using the type of the argument. 583 for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end(); 584 NewArg != NewArgEnd; ++NewArg) { 585 QualType ArgType = NewArg->getType(); 586 NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType), 587 ArgType)); 588 } 589 590 // Emit the call to new. 591 RValue RV = 592 EmitCall(CGM.getTypes().getFunctionInfo(NewFTy->getResultType(), NewArgs), 593 CGM.GetAddrOfFunction(GlobalDecl(NewFD)), 594 NewArgs, NewFD); 595 596 // If an allocation function is declared with an empty exception specification 597 // it returns null to indicate failure to allocate storage. [expr.new]p13. 598 // (We don't need to check for null when there's no new initializer and 599 // we're allocating a POD type). 600 bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() && 601 !(AllocType->isPODType() && !E->hasInitializer()); 602 603 llvm::BasicBlock *NewNull = 0; 604 llvm::BasicBlock *NewNotNull = 0; 605 llvm::BasicBlock *NewEnd = 0; 606 607 llvm::Value *NewPtr = RV.getScalarVal(); 608 609 if (NullCheckResult) { 610 NewNull = createBasicBlock("new.null"); 611 NewNotNull = createBasicBlock("new.notnull"); 612 NewEnd = createBasicBlock("new.end"); 613 614 llvm::Value *IsNull = 615 Builder.CreateICmpEQ(NewPtr, 616 llvm::Constant::getNullValue(NewPtr->getType()), 617 "isnull"); 618 619 Builder.CreateCondBr(IsNull, NewNull, NewNotNull); 620 EmitBlock(NewNotNull); 621 } 622 623 NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType())); 624 625 if (AllocType->isPODType()) { 626 if (E->getNumConstructorArgs() > 0) { 627 assert(E->getNumConstructorArgs() == 1 && 628 "Can only have one argument to initializer of POD type."); 629 630 const Expr *Init = E->getConstructorArg(0); 631 632 if (!hasAggregateLLVMType(AllocType)) 633 Builder.CreateStore(EmitScalarExpr(Init), NewPtr); 634 else if (AllocType->isAnyComplexType()) 635 EmitComplexExprIntoAddr(Init, NewPtr, AllocType.isVolatileQualified()); 636 else 637 EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified()); 638 } 639 } else { 640 // Call the constructor. 641 CXXConstructorDecl *Ctor = E->getConstructor(); 642 643 EmitCXXConstructorCall(Ctor, Ctor_Complete, NewPtr, 644 E->constructor_arg_begin(), 645 E->constructor_arg_end()); 646 } 647 648 if (NullCheckResult) { 649 Builder.CreateBr(NewEnd); 650 EmitBlock(NewNull); 651 Builder.CreateBr(NewEnd); 652 EmitBlock(NewEnd); 653 654 llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType()); 655 PHI->reserveOperandSpace(2); 656 PHI->addIncoming(NewPtr, NewNotNull); 657 PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull); 658 659 NewPtr = PHI; 660 } 661 662 return NewPtr; 663} 664 665void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) { 666 if (E->isArrayForm()) { 667 ErrorUnsupported(E, "delete[] expression"); 668 return; 669 }; 670 671 QualType DeleteTy = 672 E->getArgument()->getType()->getAs<PointerType>()->getPointeeType(); 673 674 llvm::Value *Ptr = EmitScalarExpr(E->getArgument()); 675 676 // Null check the pointer. 677 llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull"); 678 llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end"); 679 680 llvm::Value *IsNull = 681 Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()), 682 "isnull"); 683 684 Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull); 685 EmitBlock(DeleteNotNull); 686 687 // Call the destructor if necessary. 688 if (const RecordType *RT = DeleteTy->getAs<RecordType>()) { 689 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 690 if (!RD->hasTrivialDestructor()) { 691 const CXXDestructorDecl *Dtor = RD->getDestructor(getContext()); 692 if (Dtor->isVirtual()) { 693 ErrorUnsupported(E, "delete expression with virtual destructor"); 694 return; 695 } 696 697 EmitCXXDestructorCall(Dtor, Dtor_Complete, Ptr); 698 } 699 } 700 } 701 702 // Call delete. 703 FunctionDecl *DeleteFD = E->getOperatorDelete(); 704 const FunctionProtoType *DeleteFTy = 705 DeleteFD->getType()->getAsFunctionProtoType(); 706 707 CallArgList DeleteArgs; 708 709 QualType ArgTy = DeleteFTy->getArgType(0); 710 llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy)); 711 DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy)); 712 713 // Emit the call to delete. 714 EmitCall(CGM.getTypes().getFunctionInfo(DeleteFTy->getResultType(), 715 DeleteArgs), 716 CGM.GetAddrOfFunction(GlobalDecl(DeleteFD)), 717 DeleteArgs, DeleteFD); 718 719 EmitBlock(DeleteEnd); 720} 721 722void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) { 723 EmitGlobal(GlobalDecl(D, Ctor_Complete)); 724 EmitGlobal(GlobalDecl(D, Ctor_Base)); 725} 726 727void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D, 728 CXXCtorType Type) { 729 730 llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type); 731 732 CodeGenFunction(*this).GenerateCode(D, Fn); 733 734 SetFunctionDefinitionAttributes(D, Fn); 735 SetLLVMFunctionAttributesForDefinition(D, Fn); 736} 737 738llvm::Function * 739CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D, 740 CXXCtorType Type) { 741 const llvm::FunctionType *FTy = 742 getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false); 743 744 const char *Name = getMangledCXXCtorName(D, Type); 745 return cast<llvm::Function>( 746 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type))); 747} 748 749const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D, 750 CXXCtorType Type) { 751 llvm::SmallString<256> Name; 752 llvm::raw_svector_ostream Out(Name); 753 mangleCXXCtor(D, Type, Context, Out); 754 755 Name += '\0'; 756 return UniqueMangledName(Name.begin(), Name.end()); 757} 758 759void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) { 760 EmitCXXDestructor(D, Dtor_Complete); 761 EmitCXXDestructor(D, Dtor_Base); 762} 763 764void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D, 765 CXXDtorType Type) { 766 llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type); 767 768 CodeGenFunction(*this).GenerateCode(D, Fn); 769 770 SetFunctionDefinitionAttributes(D, Fn); 771 SetLLVMFunctionAttributesForDefinition(D, Fn); 772} 773 774llvm::Function * 775CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D, 776 CXXDtorType Type) { 777 const llvm::FunctionType *FTy = 778 getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false); 779 780 const char *Name = getMangledCXXDtorName(D, Type); 781 return cast<llvm::Function>( 782 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type))); 783} 784 785const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D, 786 CXXDtorType Type) { 787 llvm::SmallString<256> Name; 788 llvm::raw_svector_ostream Out(Name); 789 mangleCXXDtor(D, Type, Context, Out); 790 791 Name += '\0'; 792 return UniqueMangledName(Name.begin(), Name.end()); 793} 794 795llvm::Constant *CodeGenModule::GenerateRtti(const CXXRecordDecl *RD) { 796 llvm::Type *Ptr8Ty; 797 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 798 llvm::Constant *Rtti = llvm::Constant::getNullValue(Ptr8Ty); 799 800 if (!getContext().getLangOptions().Rtti) 801 return Rtti; 802 803 llvm::SmallString<256> OutName; 804 llvm::raw_svector_ostream Out(OutName); 805 QualType ClassTy; 806 ClassTy = getContext().getTagDeclType(RD); 807 mangleCXXRtti(ClassTy, getContext(), Out); 808 llvm::GlobalVariable::LinkageTypes linktype; 809 linktype = llvm::GlobalValue::WeakAnyLinkage; 810 std::vector<llvm::Constant *> info; 811 // assert(0 && "FIXME: implement rtti descriptor"); 812 // FIXME: descriptor 813 info.push_back(llvm::Constant::getNullValue(Ptr8Ty)); 814 // assert(0 && "FIXME: implement rtti ts"); 815 // FIXME: TS 816 info.push_back(llvm::Constant::getNullValue(Ptr8Ty)); 817 818 llvm::Constant *C; 819 llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, info.size()); 820 C = llvm::ConstantArray::get(type, info); 821 Rtti = new llvm::GlobalVariable(getModule(), type, true, linktype, C, 822 Out.str()); 823 Rtti = llvm::ConstantExpr::getBitCast(Rtti, Ptr8Ty); 824 return Rtti; 825} 826 827class VtableBuilder { 828public: 829 /// Index_t - Vtable index type. 830 typedef uint64_t Index_t; 831private: 832 std::vector<llvm::Constant *> &methods; 833 std::vector<llvm::Constant *> submethods; 834 llvm::Type *Ptr8Ty; 835 /// Class - The most derived class that this vtable is being built for. 836 const CXXRecordDecl *Class; 837 /// BLayout - Layout for the most derived class that this vtable is being 838 /// built for. 839 const ASTRecordLayout &BLayout; 840 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary; 841 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase; 842 llvm::Constant *rtti; 843 llvm::LLVMContext &VMContext; 844 CodeGenModule &CGM; // Per-module state. 845 /// Index - Maps a method decl into a vtable index. Useful for virtual 846 /// dispatch codegen. 847 llvm::DenseMap<const CXXMethodDecl *, Index_t> Index; 848 llvm::DenseMap<const CXXMethodDecl *, Index_t> VCall; 849 llvm::DenseMap<const CXXMethodDecl *, Index_t> VCallOffset; 850 std::vector<Index_t> VCalls; 851 typedef CXXRecordDecl::method_iterator method_iter; 852public: 853 VtableBuilder(std::vector<llvm::Constant *> &meth, 854 const CXXRecordDecl *c, 855 CodeGenModule &cgm) 856 : methods(meth), Class(c), BLayout(cgm.getContext().getASTRecordLayout(c)), 857 rtti(cgm.GenerateRtti(c)), VMContext(cgm.getModule().getContext()), 858 CGM(cgm) { 859 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 860 } 861 862 llvm::DenseMap<const CXXMethodDecl *, Index_t> &getIndex() { return Index; } 863 864 llvm::Constant *wrap(Index_t i) { 865 llvm::Constant *m; 866 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i); 867 return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty); 868 } 869 870 llvm::Constant *wrap(llvm::Constant *m) { 871 return llvm::ConstantExpr::getBitCast(m, Ptr8Ty); 872 } 873 874 void GenerateVBaseOffsets(std::vector<llvm::Constant *> &offsets, 875 const CXXRecordDecl *RD, uint64_t Offset) { 876 for (CXXRecordDecl::base_class_const_iterator i =RD->bases_begin(), 877 e = RD->bases_end(); i != e; ++i) { 878 const CXXRecordDecl *Base = 879 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 880 if (i->isVirtual() && !SeenVBase.count(Base)) { 881 SeenVBase.insert(Base); 882 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8; 883 llvm::Constant *m = wrap(BaseOffset); 884 m = wrap((0?700:0) + BaseOffset); 885 offsets.push_back(m); 886 } 887 GenerateVBaseOffsets(offsets, Base, Offset); 888 } 889 } 890 891 void StartNewTable() { 892 SeenVBase.clear(); 893 } 894 895 bool OverrideMethod(const CXXMethodDecl *MD, llvm::Constant *m, 896 bool MorallyVirtual, Index_t Offset) { 897 typedef CXXMethodDecl::method_iterator meth_iter; 898 899 // FIXME: Don't like the nested loops. For very large inheritance 900 // heirarchies we could have a table on the side with the final overridder 901 // and just replace each instance of an overridden method once. Would be 902 // nice to measure the cost/benefit on real code. 903 904 // If we can find a previously allocated slot for this, reuse it. 905 for (meth_iter mi = MD->begin_overridden_methods(), 906 e = MD->end_overridden_methods(); 907 mi != e; ++mi) { 908 const CXXMethodDecl *OMD = *mi; 909 llvm::Constant *om; 910 om = CGM.GetAddrOfFunction(GlobalDecl(OMD), Ptr8Ty); 911 om = llvm::ConstantExpr::getBitCast(om, Ptr8Ty); 912 913 for (Index_t i = 0, e = submethods.size(); 914 i != e; ++i) { 915 // FIXME: begin_overridden_methods might be too lax, covariance */ 916 if (submethods[i] == om) { 917 // FIXME: thunks 918 submethods[i] = m; 919 Index[MD] = i; 920 if (MorallyVirtual) { 921 VCallOffset[MD] = Offset/8; 922 VCalls[VCall[OMD]] = Offset/8 - VCallOffset[OMD]; 923 } 924 // submethods[VCall[OMD]] = wrap(Offset/8 - VCallOffset[OMD]); 925 return true; 926 } 927 } 928 } 929 930 return false; 931 } 932 933 void OverrideMethods(const CXXRecordDecl *RD, Index_t AddressPoint, 934 bool MorallyVirtual, Index_t Offset) { 935 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me; 936 ++mi) 937 if (mi->isVirtual()) { 938 const CXXMethodDecl *MD = *mi; 939 llvm::Constant *m = wrap(CGM.GetAddrOfFunction(GlobalDecl(MD), Ptr8Ty)); 940 OverrideMethod(MD, m, MorallyVirtual, Offset); 941 } 942 } 943 944 void AddMethod(const CXXMethodDecl *MD, Index_t AddressPoint, 945 bool MorallyVirtual, Index_t Offset) { 946 llvm::Constant *m = wrap(CGM.GetAddrOfFunction(GlobalDecl(MD), Ptr8Ty)); 947 if (OverrideMethod(MD, m, MorallyVirtual, Offset)) 948 return; 949 950 // else allocate a new slot. 951 Index[MD] = submethods.size(); 952 // VCall[MD] = Offset; 953 if (MorallyVirtual) { 954 VCallOffset[MD] = Offset/8; 955 Index_t &idx = VCall[MD]; 956 // Allocate the first one, after that, we reuse the previous one. 957 if (idx == 0) { 958 idx = VCalls.size()+1; 959 VCallOffset[MD] = Offset/8; 960 VCalls.push_back(0); 961 } 962 } 963 submethods.push_back(m); 964 } 965 966 void AddMethods(const CXXRecordDecl *RD, Index_t AddressPoint, 967 bool MorallyVirtual, Index_t Offset) { 968 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me; 969 ++mi) 970 if (mi->isVirtual()) 971 AddMethod(*mi, AddressPoint, MorallyVirtual, Offset); 972 } 973 974 int64_t GenerateVtableForBase(const CXXRecordDecl *RD, bool forPrimary, 975 bool Bottom, bool MorallyVirtual, 976 int64_t Offset, bool ForVirtualBase) { 977 llvm::Constant *m = llvm::Constant::getNullValue(Ptr8Ty); 978 int64_t AddressPoint=0; 979 980 if (RD && !RD->isDynamicClass()) 981 return 0; 982 983 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 984 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 985 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual(); 986 987 std::vector<llvm::Constant *> offsets; 988 // FIXME: Audit, is this right? 989 if (Bottom && (PrimaryBase == 0 || forPrimary || !PrimaryBaseWasVirtual 990 || Bottom)) 991 GenerateVBaseOffsets(offsets, RD, Offset); 992 993 bool Top = true; 994 995 // vtables are composed from the chain of primaries. 996 if (PrimaryBase) { 997 if (PrimaryBaseWasVirtual) 998 IndirectPrimary.insert(PrimaryBase); 999 Top = false; 1000 AddressPoint = GenerateVtableForBase(PrimaryBase, true, false, 1001 PrimaryBaseWasVirtual|MorallyVirtual, 1002 Offset, PrimaryBaseWasVirtual); 1003 } 1004 1005 // And add the virtuals for the class to the primary vtable. 1006 AddMethods(RD, AddressPoint, MorallyVirtual, Offset); 1007 1008 if (!Bottom) 1009 return AddressPoint; 1010 1011 StartNewTable(); 1012 // FIXME: Cleanup. 1013 if (!ForVirtualBase) { 1014 // then virtual base offsets... 1015 for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(), 1016 e = offsets.rend(); i != e; ++i) 1017 methods.push_back(*i); 1018 } 1019 1020 // The vcalls come first... 1021 for (std::vector<Index_t>::iterator i=VCalls.begin(), e=VCalls.end(); 1022 i < e; ++i) 1023 methods.push_back(wrap((0?600:0) + *i)); 1024 VCalls.clear(); 1025 1026 if (ForVirtualBase) { 1027 // then virtual base offsets... 1028 for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(), 1029 e = offsets.rend(); i != e; ++i) 1030 methods.push_back(*i); 1031 } 1032 1033 m = wrap(-(Offset/8)); 1034 methods.push_back(m); 1035 methods.push_back(rtti); 1036 AddressPoint = methods.size(); 1037 1038 methods.insert(methods.end(), submethods.begin(), submethods.end()); 1039 submethods.clear(); 1040 1041 // and then the non-virtual bases. 1042 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 1043 e = RD->bases_end(); i != e; ++i) { 1044 if (i->isVirtual()) 1045 continue; 1046 const CXXRecordDecl *Base = 1047 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 1048 if (Base != PrimaryBase || PrimaryBaseWasVirtual) { 1049 uint64_t o = Offset + Layout.getBaseClassOffset(Base); 1050 StartNewTable(); 1051 GenerateVtableForBase(Base, true, true, false, o, false); 1052 } 1053 } 1054 return AddressPoint; 1055 } 1056 1057 void GenerateVtableForVBases(const CXXRecordDecl *RD, 1058 const CXXRecordDecl *Class) { 1059 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 1060 e = RD->bases_end(); i != e; ++i) { 1061 const CXXRecordDecl *Base = 1062 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 1063 if (i->isVirtual() && !IndirectPrimary.count(Base)) { 1064 // Mark it so we don't output it twice. 1065 IndirectPrimary.insert(Base); 1066 StartNewTable(); 1067 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base); 1068 GenerateVtableForBase(Base, false, true, true, BaseOffset, true); 1069 } 1070 if (Base->getNumVBases()) 1071 GenerateVtableForVBases(Base, Class); 1072 } 1073 } 1074}; 1075 1076class VtableInfo { 1077public: 1078 typedef VtableBuilder::Index_t Index_t; 1079private: 1080 CodeGenModule &CGM; // Per-module state. 1081 /// Index_t - Vtable index type. 1082 typedef llvm::DenseMap<const CXXMethodDecl *, Index_t> ElTy; 1083 typedef llvm::DenseMap<const CXXRecordDecl *, ElTy *> MapTy; 1084 // FIXME: Move to Context. 1085 static MapTy IndexFor; 1086public: 1087 VtableInfo(CodeGenModule &cgm) : CGM(cgm) { } 1088 void register_index(const CXXRecordDecl *RD, const ElTy &e) { 1089 assert(IndexFor.find(RD) == IndexFor.end() && "Don't compute vtbl twice"); 1090 // We own a copy of this, it will go away shortly. 1091 new ElTy (e); 1092 IndexFor[RD] = new ElTy (e); 1093 } 1094 Index_t lookup(const CXXMethodDecl *MD) { 1095 const CXXRecordDecl *RD = MD->getParent(); 1096 MapTy::iterator I = IndexFor.find(RD); 1097 if (I == IndexFor.end()) { 1098 std::vector<llvm::Constant *> methods; 1099 VtableBuilder b(methods, RD, CGM); 1100 b.GenerateVtableForBase(RD, true, true, false, 0, false); 1101 b.GenerateVtableForVBases(RD, RD); 1102 register_index(RD, b.getIndex()); 1103 I = IndexFor.find(RD); 1104 } 1105 assert(I->second->find(MD)!=I->second->end() && "Can't find vtable index"); 1106 return (*I->second)[MD]; 1107 } 1108}; 1109 1110// FIXME: Move to Context. 1111VtableInfo::MapTy VtableInfo::IndexFor; 1112 1113llvm::Value *CodeGenFunction::GenerateVtable(const CXXRecordDecl *RD) { 1114 llvm::SmallString<256> OutName; 1115 llvm::raw_svector_ostream Out(OutName); 1116 QualType ClassTy; 1117 ClassTy = getContext().getTagDeclType(RD); 1118 mangleCXXVtable(ClassTy, getContext(), Out); 1119 llvm::GlobalVariable::LinkageTypes linktype; 1120 linktype = llvm::GlobalValue::WeakAnyLinkage; 1121 std::vector<llvm::Constant *> methods; 1122 llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0); 1123 int64_t Offset; 1124 1125 VtableBuilder b(methods, RD, CGM); 1126 1127 // First comes the vtables for all the non-virtual bases... 1128 Offset = b.GenerateVtableForBase(RD, true, true, false, 0, false); 1129 1130 // then the vtables for all the virtual bases. 1131 b.GenerateVtableForVBases(RD, RD); 1132 1133 llvm::Constant *C; 1134 llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, methods.size()); 1135 C = llvm::ConstantArray::get(type, methods); 1136 llvm::Value *vtable = new llvm::GlobalVariable(CGM.getModule(), type, true, 1137 linktype, C, Out.str()); 1138 vtable = Builder.CreateBitCast(vtable, Ptr8Ty); 1139 vtable = Builder.CreateGEP(vtable, 1140 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 1141 Offset*LLVMPointerWidth/8)); 1142 return vtable; 1143} 1144 1145// FIXME: move to Context 1146static VtableInfo *vtableinfo; 1147 1148llvm::Value * 1149CodeGenFunction::BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *&This, 1150 const llvm::Type *Ty) { 1151 // FIXME: If we know the dynamic type, we don't have to do a virtual dispatch. 1152 1153 // FIXME: move to Context 1154 if (vtableinfo == 0) 1155 vtableinfo = new VtableInfo(CGM); 1156 1157 VtableInfo::Index_t Idx = vtableinfo->lookup(MD); 1158 1159 Ty = llvm::PointerType::get(Ty, 0); 1160 Ty = llvm::PointerType::get(Ty, 0); 1161 Ty = llvm::PointerType::get(Ty, 0); 1162 llvm::Value *vtbl = Builder.CreateBitCast(This, Ty); 1163 vtbl = Builder.CreateLoad(vtbl); 1164 llvm::Value *vfn = Builder.CreateConstInBoundsGEP1_64(vtbl, 1165 Idx, "vfn"); 1166 vfn = Builder.CreateLoad(vfn); 1167 return vfn; 1168} 1169 1170/// EmitClassAggrMemberwiseCopy - This routine generates code to copy a class 1171/// array of objects from SrcValue to DestValue. Copying can be either a bitwise 1172/// copy or via a copy constructor call. 1173// FIXME. Consolidate this with EmitCXXAggrConstructorCall. 1174void CodeGenFunction::EmitClassAggrMemberwiseCopy(llvm::Value *Dest, 1175 llvm::Value *Src, 1176 const ArrayType *Array, 1177 const CXXRecordDecl *BaseClassDecl, 1178 QualType Ty) { 1179 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array); 1180 assert(CA && "VLA cannot be copied over"); 1181 bool BitwiseCopy = BaseClassDecl->hasTrivialCopyConstructor(); 1182 1183 // Create a temporary for the loop index and initialize it with 0. 1184 llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext), 1185 "loop.index"); 1186 llvm::Value* zeroConstant = 1187 llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)); 1188 Builder.CreateStore(zeroConstant, IndexPtr, false); 1189 // Start the loop with a block that tests the condition. 1190 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 1191 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 1192 1193 EmitBlock(CondBlock); 1194 1195 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 1196 // Generate: if (loop-index < number-of-elements fall to the loop body, 1197 // otherwise, go to the block after the for-loop. 1198 uint64_t NumElements = getContext().getConstantArrayElementCount(CA); 1199 llvm::Value * NumElementsPtr = 1200 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements); 1201 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 1202 llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr, 1203 "isless"); 1204 // If the condition is true, execute the body. 1205 Builder.CreateCondBr(IsLess, ForBody, AfterFor); 1206 1207 EmitBlock(ForBody); 1208 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 1209 // Inside the loop body, emit the constructor call on the array element. 1210 Counter = Builder.CreateLoad(IndexPtr); 1211 Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress"); 1212 Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress"); 1213 if (BitwiseCopy) 1214 EmitAggregateCopy(Dest, Src, Ty); 1215 else if (CXXConstructorDecl *BaseCopyCtor = 1216 BaseClassDecl->getCopyConstructor(getContext(), 0)) { 1217 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor, 1218 Ctor_Complete); 1219 CallArgList CallArgs; 1220 // Push the this (Dest) ptr. 1221 CallArgs.push_back(std::make_pair(RValue::get(Dest), 1222 BaseCopyCtor->getThisType(getContext()))); 1223 1224 // Push the Src ptr. 1225 CallArgs.push_back(std::make_pair(RValue::get(Src), 1226 BaseCopyCtor->getParamDecl(0)->getType())); 1227 QualType ResultType = 1228 BaseCopyCtor->getType()->getAsFunctionType()->getResultType(); 1229 EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs), 1230 Callee, CallArgs, BaseCopyCtor); 1231 } 1232 EmitBlock(ContinueBlock); 1233 1234 // Emit the increment of the loop counter. 1235 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1); 1236 Counter = Builder.CreateLoad(IndexPtr); 1237 NextVal = Builder.CreateAdd(Counter, NextVal, "inc"); 1238 Builder.CreateStore(NextVal, IndexPtr, false); 1239 1240 // Finally, branch back up to the condition for the next iteration. 1241 EmitBranch(CondBlock); 1242 1243 // Emit the fall-through block. 1244 EmitBlock(AfterFor, true); 1245} 1246 1247/// EmitClassAggrCopyAssignment - This routine generates code to assign a class 1248/// array of objects from SrcValue to DestValue. Assignment can be either a 1249/// bitwise assignment or via a copy assignment operator function call. 1250/// FIXME. This can be consolidated with EmitClassAggrMemberwiseCopy 1251void CodeGenFunction::EmitClassAggrCopyAssignment(llvm::Value *Dest, 1252 llvm::Value *Src, 1253 const ArrayType *Array, 1254 const CXXRecordDecl *BaseClassDecl, 1255 QualType Ty) { 1256 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array); 1257 assert(CA && "VLA cannot be asssigned"); 1258 bool BitwiseAssign = BaseClassDecl->hasTrivialCopyAssignment(); 1259 1260 // Create a temporary for the loop index and initialize it with 0. 1261 llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext), 1262 "loop.index"); 1263 llvm::Value* zeroConstant = 1264 llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)); 1265 Builder.CreateStore(zeroConstant, IndexPtr, false); 1266 // Start the loop with a block that tests the condition. 1267 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 1268 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 1269 1270 EmitBlock(CondBlock); 1271 1272 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 1273 // Generate: if (loop-index < number-of-elements fall to the loop body, 1274 // otherwise, go to the block after the for-loop. 1275 uint64_t NumElements = getContext().getConstantArrayElementCount(CA); 1276 llvm::Value * NumElementsPtr = 1277 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements); 1278 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 1279 llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr, 1280 "isless"); 1281 // If the condition is true, execute the body. 1282 Builder.CreateCondBr(IsLess, ForBody, AfterFor); 1283 1284 EmitBlock(ForBody); 1285 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 1286 // Inside the loop body, emit the assignment operator call on array element. 1287 Counter = Builder.CreateLoad(IndexPtr); 1288 Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress"); 1289 Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress"); 1290 const CXXMethodDecl *MD = 0; 1291 if (BitwiseAssign) 1292 EmitAggregateCopy(Dest, Src, Ty); 1293 else { 1294 bool hasCopyAssign = BaseClassDecl->hasConstCopyAssignment(getContext(), 1295 MD); 1296 assert(hasCopyAssign && "EmitClassAggrCopyAssignment - No user assign"); 1297 (void)hasCopyAssign; 1298 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 1299 const llvm::Type *LTy = 1300 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 1301 FPT->isVariadic()); 1302 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), LTy); 1303 1304 CallArgList CallArgs; 1305 // Push the this (Dest) ptr. 1306 CallArgs.push_back(std::make_pair(RValue::get(Dest), 1307 MD->getThisType(getContext()))); 1308 1309 // Push the Src ptr. 1310 CallArgs.push_back(std::make_pair(RValue::get(Src), 1311 MD->getParamDecl(0)->getType())); 1312 QualType ResultType = 1313 MD->getType()->getAsFunctionType()->getResultType(); 1314 EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs), 1315 Callee, CallArgs, MD); 1316 } 1317 EmitBlock(ContinueBlock); 1318 1319 // Emit the increment of the loop counter. 1320 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1); 1321 Counter = Builder.CreateLoad(IndexPtr); 1322 NextVal = Builder.CreateAdd(Counter, NextVal, "inc"); 1323 Builder.CreateStore(NextVal, IndexPtr, false); 1324 1325 // Finally, branch back up to the condition for the next iteration. 1326 EmitBranch(CondBlock); 1327 1328 // Emit the fall-through block. 1329 EmitBlock(AfterFor, true); 1330} 1331 1332/// EmitClassMemberwiseCopy - This routine generates code to copy a class 1333/// object from SrcValue to DestValue. Copying can be either a bitwise copy 1334/// or via a copy constructor call. 1335void CodeGenFunction::EmitClassMemberwiseCopy( 1336 llvm::Value *Dest, llvm::Value *Src, 1337 const CXXRecordDecl *ClassDecl, 1338 const CXXRecordDecl *BaseClassDecl, QualType Ty) { 1339 if (ClassDecl) { 1340 Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl); 1341 Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ; 1342 } 1343 if (BaseClassDecl->hasTrivialCopyConstructor()) { 1344 EmitAggregateCopy(Dest, Src, Ty); 1345 return; 1346 } 1347 1348 if (CXXConstructorDecl *BaseCopyCtor = 1349 BaseClassDecl->getCopyConstructor(getContext(), 0)) { 1350 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor, 1351 Ctor_Complete); 1352 CallArgList CallArgs; 1353 // Push the this (Dest) ptr. 1354 CallArgs.push_back(std::make_pair(RValue::get(Dest), 1355 BaseCopyCtor->getThisType(getContext()))); 1356 1357 // Push the Src ptr. 1358 CallArgs.push_back(std::make_pair(RValue::get(Src), 1359 BaseCopyCtor->getParamDecl(0)->getType())); 1360 QualType ResultType = 1361 BaseCopyCtor->getType()->getAsFunctionType()->getResultType(); 1362 EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs), 1363 Callee, CallArgs, BaseCopyCtor); 1364 } 1365} 1366 1367/// EmitClassCopyAssignment - This routine generates code to copy assign a class 1368/// object from SrcValue to DestValue. Assignment can be either a bitwise 1369/// assignment of via an assignment operator call. 1370// FIXME. Consolidate this with EmitClassMemberwiseCopy as they share a lot. 1371void CodeGenFunction::EmitClassCopyAssignment( 1372 llvm::Value *Dest, llvm::Value *Src, 1373 const CXXRecordDecl *ClassDecl, 1374 const CXXRecordDecl *BaseClassDecl, 1375 QualType Ty) { 1376 if (ClassDecl) { 1377 Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl); 1378 Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ; 1379 } 1380 if (BaseClassDecl->hasTrivialCopyAssignment()) { 1381 EmitAggregateCopy(Dest, Src, Ty); 1382 return; 1383 } 1384 1385 const CXXMethodDecl *MD = 0; 1386 bool ConstCopyAssignOp = BaseClassDecl->hasConstCopyAssignment(getContext(), 1387 MD); 1388 assert(ConstCopyAssignOp && "EmitClassCopyAssignment - missing copy assign"); 1389 (void)ConstCopyAssignOp; 1390 1391 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 1392 const llvm::Type *LTy = 1393 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 1394 FPT->isVariadic()); 1395 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), LTy); 1396 1397 CallArgList CallArgs; 1398 // Push the this (Dest) ptr. 1399 CallArgs.push_back(std::make_pair(RValue::get(Dest), 1400 MD->getThisType(getContext()))); 1401 1402 // Push the Src ptr. 1403 CallArgs.push_back(std::make_pair(RValue::get(Src), 1404 MD->getParamDecl(0)->getType())); 1405 QualType ResultType = 1406 MD->getType()->getAsFunctionType()->getResultType(); 1407 EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs), 1408 Callee, CallArgs, MD); 1409} 1410 1411/// SynthesizeDefaultConstructor - synthesize a default constructor 1412void 1413CodeGenFunction::SynthesizeDefaultConstructor(const CXXConstructorDecl *CD, 1414 const FunctionDecl *FD, 1415 llvm::Function *Fn, 1416 const FunctionArgList &Args) { 1417 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1418 EmitCtorPrologue(CD); 1419 FinishFunction(); 1420} 1421 1422/// SynthesizeCXXCopyConstructor - This routine implicitly defines body of a copy 1423/// constructor, in accordance with section 12.8 (p7 and p8) of C++03 1424/// The implicitly-defined copy constructor for class X performs a memberwise 1425/// copy of its subobjects. The order of copying is the same as the order 1426/// of initialization of bases and members in a user-defined constructor 1427/// Each subobject is copied in the manner appropriate to its type: 1428/// if the subobject is of class type, the copy constructor for the class is 1429/// used; 1430/// if the subobject is an array, each element is copied, in the manner 1431/// appropriate to the element type; 1432/// if the subobject is of scalar type, the built-in assignment operator is 1433/// used. 1434/// Virtual base class subobjects shall be copied only once by the 1435/// implicitly-defined copy constructor 1436 1437void CodeGenFunction::SynthesizeCXXCopyConstructor(const CXXConstructorDecl *CD, 1438 const FunctionDecl *FD, 1439 llvm::Function *Fn, 1440 const FunctionArgList &Args) { 1441 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1442 assert(!ClassDecl->hasUserDeclaredCopyConstructor() && 1443 "SynthesizeCXXCopyConstructor - copy constructor has definition already"); 1444 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1445 1446 FunctionArgList::const_iterator i = Args.begin(); 1447 const VarDecl *ThisArg = i->first; 1448 llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg); 1449 llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this"); 1450 const VarDecl *SrcArg = (i+1)->first; 1451 llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg); 1452 llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj); 1453 1454 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 1455 Base != ClassDecl->bases_end(); ++Base) { 1456 // FIXME. copy constrution of virtual base NYI 1457 if (Base->isVirtual()) 1458 continue; 1459 1460 CXXRecordDecl *BaseClassDecl 1461 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1462 EmitClassMemberwiseCopy(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl, 1463 Base->getType()); 1464 } 1465 1466 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1467 FieldEnd = ClassDecl->field_end(); 1468 Field != FieldEnd; ++Field) { 1469 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1470 const ConstantArrayType *Array = 1471 getContext().getAsConstantArrayType(FieldType); 1472 if (Array) 1473 FieldType = getContext().getBaseElementType(FieldType); 1474 1475 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 1476 CXXRecordDecl *FieldClassDecl 1477 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 1478 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1479 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1480 if (Array) { 1481 const llvm::Type *BasePtr = ConvertType(FieldType); 1482 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1483 llvm::Value *DestBaseAddrPtr = 1484 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1485 llvm::Value *SrcBaseAddrPtr = 1486 Builder.CreateBitCast(RHS.getAddress(), BasePtr); 1487 EmitClassAggrMemberwiseCopy(DestBaseAddrPtr, SrcBaseAddrPtr, Array, 1488 FieldClassDecl, FieldType); 1489 } 1490 else 1491 EmitClassMemberwiseCopy(LHS.getAddress(), RHS.getAddress(), 1492 0 /*ClassDecl*/, FieldClassDecl, FieldType); 1493 continue; 1494 } 1495 // Do a built-in assignment of scalar data members. 1496 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1497 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1498 RValue RVRHS = EmitLoadOfLValue(RHS, FieldType); 1499 EmitStoreThroughLValue(RVRHS, LHS, FieldType); 1500 } 1501 FinishFunction(); 1502} 1503 1504/// SynthesizeCXXCopyAssignment - Implicitly define copy assignment operator. 1505/// Before the implicitly-declared copy assignment operator for a class is 1506/// implicitly defined, all implicitly- declared copy assignment operators for 1507/// its direct base classes and its nonstatic data members shall have been 1508/// implicitly defined. [12.8-p12] 1509/// The implicitly-defined copy assignment operator for class X performs 1510/// memberwise assignment of its subob- jects. The direct base classes of X are 1511/// assigned first, in the order of their declaration in 1512/// the base-specifier-list, and then the immediate nonstatic data members of X 1513/// are assigned, in the order in which they were declared in the class 1514/// definition.Each subobject is assigned in the manner appropriate to its type: 1515/// if the subobject is of class type, the copy assignment operator for the 1516/// class is used (as if by explicit qualification; that is, ignoring any 1517/// possible virtual overriding functions in more derived classes); 1518/// 1519/// if the subobject is an array, each element is assigned, in the manner 1520/// appropriate to the element type; 1521/// 1522/// if the subobject is of scalar type, the built-in assignment operator is 1523/// used. 1524void CodeGenFunction::SynthesizeCXXCopyAssignment(const CXXMethodDecl *CD, 1525 const FunctionDecl *FD, 1526 llvm::Function *Fn, 1527 const FunctionArgList &Args) { 1528 1529 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1530 assert(!ClassDecl->hasUserDeclaredCopyAssignment() && 1531 "SynthesizeCXXCopyAssignment - copy assignment has user declaration"); 1532 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1533 1534 FunctionArgList::const_iterator i = Args.begin(); 1535 const VarDecl *ThisArg = i->first; 1536 llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg); 1537 llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this"); 1538 const VarDecl *SrcArg = (i+1)->first; 1539 llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg); 1540 llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj); 1541 1542 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 1543 Base != ClassDecl->bases_end(); ++Base) { 1544 // FIXME. copy assignment of virtual base NYI 1545 if (Base->isVirtual()) 1546 continue; 1547 1548 CXXRecordDecl *BaseClassDecl 1549 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1550 EmitClassCopyAssignment(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl, 1551 Base->getType()); 1552 } 1553 1554 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1555 FieldEnd = ClassDecl->field_end(); 1556 Field != FieldEnd; ++Field) { 1557 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1558 const ConstantArrayType *Array = 1559 getContext().getAsConstantArrayType(FieldType); 1560 if (Array) 1561 FieldType = getContext().getBaseElementType(FieldType); 1562 1563 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 1564 CXXRecordDecl *FieldClassDecl 1565 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 1566 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1567 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1568 if (Array) { 1569 const llvm::Type *BasePtr = ConvertType(FieldType); 1570 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1571 llvm::Value *DestBaseAddrPtr = 1572 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1573 llvm::Value *SrcBaseAddrPtr = 1574 Builder.CreateBitCast(RHS.getAddress(), BasePtr); 1575 EmitClassAggrCopyAssignment(DestBaseAddrPtr, SrcBaseAddrPtr, Array, 1576 FieldClassDecl, FieldType); 1577 } 1578 else 1579 EmitClassCopyAssignment(LHS.getAddress(), RHS.getAddress(), 1580 0 /*ClassDecl*/, FieldClassDecl, FieldType); 1581 continue; 1582 } 1583 // Do a built-in assignment of scalar data members. 1584 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1585 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1586 RValue RVRHS = EmitLoadOfLValue(RHS, FieldType); 1587 EmitStoreThroughLValue(RVRHS, LHS, FieldType); 1588 } 1589 1590 // return *this; 1591 Builder.CreateStore(LoadOfThis, ReturnValue); 1592 1593 FinishFunction(); 1594} 1595 1596/// EmitCtorPrologue - This routine generates necessary code to initialize 1597/// base classes and non-static data members belonging to this constructor. 1598/// FIXME: This needs to take a CXXCtorType. 1599void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD) { 1600 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1601 // FIXME: Add vbase initialization 1602 llvm::Value *LoadOfThis = 0; 1603 1604 for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(), 1605 E = CD->init_end(); 1606 B != E; ++B) { 1607 CXXBaseOrMemberInitializer *Member = (*B); 1608 if (Member->isBaseInitializer()) { 1609 LoadOfThis = LoadCXXThis(); 1610 Type *BaseType = Member->getBaseClass(); 1611 CXXRecordDecl *BaseClassDecl = 1612 cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl()); 1613 llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl, 1614 BaseClassDecl); 1615 EmitCXXConstructorCall(Member->getConstructor(), 1616 Ctor_Complete, V, 1617 Member->const_arg_begin(), 1618 Member->const_arg_end()); 1619 } else { 1620 // non-static data member initilaizers. 1621 FieldDecl *Field = Member->getMember(); 1622 QualType FieldType = getContext().getCanonicalType((Field)->getType()); 1623 const ConstantArrayType *Array = 1624 getContext().getAsConstantArrayType(FieldType); 1625 if (Array) 1626 FieldType = getContext().getBaseElementType(FieldType); 1627 1628 LoadOfThis = LoadCXXThis(); 1629 LValue LHS; 1630 if (FieldType->isReferenceType()) { 1631 // FIXME: This is really ugly; should be refactored somehow 1632 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 1633 llvm::Value *V = Builder.CreateStructGEP(LoadOfThis, idx, "tmp"); 1634 LHS = LValue::MakeAddr(V, FieldType.getCVRQualifiers(), 1635 QualType::GCNone, FieldType.getAddressSpace()); 1636 } else { 1637 LHS = EmitLValueForField(LoadOfThis, Field, false, 0); 1638 } 1639 if (FieldType->getAs<RecordType>()) { 1640 if (!Field->isAnonymousStructOrUnion()) { 1641 assert(Member->getConstructor() && 1642 "EmitCtorPrologue - no constructor to initialize member"); 1643 if (Array) { 1644 const llvm::Type *BasePtr = ConvertType(FieldType); 1645 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1646 llvm::Value *BaseAddrPtr = 1647 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1648 EmitCXXAggrConstructorCall(Member->getConstructor(), 1649 Array, BaseAddrPtr); 1650 } 1651 else 1652 EmitCXXConstructorCall(Member->getConstructor(), 1653 Ctor_Complete, LHS.getAddress(), 1654 Member->const_arg_begin(), 1655 Member->const_arg_end()); 1656 continue; 1657 } 1658 else { 1659 // Initializing an anonymous union data member. 1660 FieldDecl *anonMember = Member->getAnonUnionMember(); 1661 LHS = EmitLValueForField(LHS.getAddress(), anonMember, false, 0); 1662 FieldType = anonMember->getType(); 1663 } 1664 } 1665 1666 assert(Member->getNumArgs() == 1 && "Initializer count must be 1 only"); 1667 Expr *RhsExpr = *Member->arg_begin(); 1668 RValue RHS; 1669 if (FieldType->isReferenceType()) 1670 RHS = EmitReferenceBindingToExpr(RhsExpr, FieldType, 1671 /*IsInitializer=*/true); 1672 else 1673 RHS = RValue::get(EmitScalarExpr(RhsExpr, true)); 1674 EmitStoreThroughLValue(RHS, LHS, FieldType); 1675 } 1676 } 1677 1678 if (!CD->getNumBaseOrMemberInitializers() && !CD->isTrivial()) { 1679 // Nontrivial default constructor with no initializer list. It may still 1680 // have bases classes and/or contain non-static data members which require 1681 // construction. 1682 for (CXXRecordDecl::base_class_const_iterator Base = 1683 ClassDecl->bases_begin(); 1684 Base != ClassDecl->bases_end(); ++Base) { 1685 // FIXME. copy assignment of virtual base NYI 1686 if (Base->isVirtual()) 1687 continue; 1688 1689 CXXRecordDecl *BaseClassDecl 1690 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1691 if (BaseClassDecl->hasTrivialConstructor()) 1692 continue; 1693 if (CXXConstructorDecl *BaseCX = 1694 BaseClassDecl->getDefaultConstructor(getContext())) { 1695 LoadOfThis = LoadCXXThis(); 1696 llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl, 1697 BaseClassDecl); 1698 EmitCXXConstructorCall(BaseCX, Ctor_Complete, V, 0, 0); 1699 } 1700 } 1701 1702 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1703 FieldEnd = ClassDecl->field_end(); 1704 Field != FieldEnd; ++Field) { 1705 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1706 const ConstantArrayType *Array = 1707 getContext().getAsConstantArrayType(FieldType); 1708 if (Array) 1709 FieldType = getContext().getBaseElementType(FieldType); 1710 if (!FieldType->getAs<RecordType>() || Field->isAnonymousStructOrUnion()) 1711 continue; 1712 const RecordType *ClassRec = FieldType->getAs<RecordType>(); 1713 CXXRecordDecl *MemberClassDecl = 1714 dyn_cast<CXXRecordDecl>(ClassRec->getDecl()); 1715 if (!MemberClassDecl || MemberClassDecl->hasTrivialConstructor()) 1716 continue; 1717 if (CXXConstructorDecl *MamberCX = 1718 MemberClassDecl->getDefaultConstructor(getContext())) { 1719 LoadOfThis = LoadCXXThis(); 1720 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1721 if (Array) { 1722 const llvm::Type *BasePtr = ConvertType(FieldType); 1723 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1724 llvm::Value *BaseAddrPtr = 1725 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1726 EmitCXXAggrConstructorCall(MamberCX, Array, BaseAddrPtr); 1727 } 1728 else 1729 EmitCXXConstructorCall(MamberCX, Ctor_Complete, LHS.getAddress(), 1730 0, 0); 1731 } 1732 } 1733 } 1734 1735 // Initialize the vtable pointer 1736 if (ClassDecl->isDynamicClass()) { 1737 if (!LoadOfThis) 1738 LoadOfThis = LoadCXXThis(); 1739 llvm::Value *VtableField; 1740 llvm::Type *Ptr8Ty, *PtrPtr8Ty; 1741 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 1742 PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0); 1743 VtableField = Builder.CreateBitCast(LoadOfThis, PtrPtr8Ty); 1744 llvm::Value *vtable = GenerateVtable(ClassDecl); 1745 Builder.CreateStore(vtable, VtableField); 1746 } 1747} 1748 1749/// EmitDtorEpilogue - Emit all code that comes at the end of class's 1750/// destructor. This is to call destructors on members and base classes 1751/// in reverse order of their construction. 1752/// FIXME: This needs to take a CXXDtorType. 1753void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD) { 1754 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext()); 1755 assert(!ClassDecl->getNumVBases() && 1756 "FIXME: Destruction of virtual bases not supported"); 1757 (void)ClassDecl; // prevent warning. 1758 1759 for (CXXDestructorDecl::destr_const_iterator *B = DD->destr_begin(), 1760 *E = DD->destr_end(); B != E; ++B) { 1761 uintptr_t BaseOrMember = (*B); 1762 if (DD->isMemberToDestroy(BaseOrMember)) { 1763 FieldDecl *FD = DD->getMemberToDestroy(BaseOrMember); 1764 QualType FieldType = getContext().getCanonicalType((FD)->getType()); 1765 const ConstantArrayType *Array = 1766 getContext().getAsConstantArrayType(FieldType); 1767 if (Array) 1768 FieldType = getContext().getBaseElementType(FieldType); 1769 const RecordType *RT = FieldType->getAs<RecordType>(); 1770 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1771 if (FieldClassDecl->hasTrivialDestructor()) 1772 continue; 1773 llvm::Value *LoadOfThis = LoadCXXThis(); 1774 LValue LHS = EmitLValueForField(LoadOfThis, FD, false, 0); 1775 if (Array) { 1776 const llvm::Type *BasePtr = ConvertType(FieldType); 1777 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1778 llvm::Value *BaseAddrPtr = 1779 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1780 EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()), 1781 Array, BaseAddrPtr); 1782 } 1783 else 1784 EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()), 1785 Dtor_Complete, LHS.getAddress()); 1786 } else { 1787 const RecordType *RT = 1788 DD->getAnyBaseClassToDestroy(BaseOrMember)->getAs<RecordType>(); 1789 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1790 if (BaseClassDecl->hasTrivialDestructor()) 1791 continue; 1792 llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(), 1793 ClassDecl,BaseClassDecl); 1794 EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()), 1795 Dtor_Complete, V); 1796 } 1797 } 1798 if (DD->getNumBaseOrMemberDestructions() || DD->isTrivial()) 1799 return; 1800 // Case of destructor synthesis with fields and base classes 1801 // which have non-trivial destructors. They must be destructed in 1802 // reverse order of their construction. 1803 llvm::SmallVector<FieldDecl *, 16> DestructedFields; 1804 1805 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1806 FieldEnd = ClassDecl->field_end(); 1807 Field != FieldEnd; ++Field) { 1808 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1809 if (getContext().getAsConstantArrayType(FieldType)) 1810 FieldType = getContext().getBaseElementType(FieldType); 1811 if (const RecordType *RT = FieldType->getAs<RecordType>()) { 1812 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1813 if (FieldClassDecl->hasTrivialDestructor()) 1814 continue; 1815 DestructedFields.push_back(*Field); 1816 } 1817 } 1818 if (!DestructedFields.empty()) 1819 for (int i = DestructedFields.size() -1; i >= 0; --i) { 1820 FieldDecl *Field = DestructedFields[i]; 1821 QualType FieldType = Field->getType(); 1822 const ConstantArrayType *Array = 1823 getContext().getAsConstantArrayType(FieldType); 1824 if (Array) 1825 FieldType = getContext().getBaseElementType(FieldType); 1826 const RecordType *RT = FieldType->getAs<RecordType>(); 1827 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1828 llvm::Value *LoadOfThis = LoadCXXThis(); 1829 LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0); 1830 if (Array) { 1831 const llvm::Type *BasePtr = ConvertType(FieldType); 1832 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1833 llvm::Value *BaseAddrPtr = 1834 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1835 EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()), 1836 Array, BaseAddrPtr); 1837 } 1838 else 1839 EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()), 1840 Dtor_Complete, LHS.getAddress()); 1841 } 1842 1843 llvm::SmallVector<CXXRecordDecl*, 4> DestructedBases; 1844 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 1845 Base != ClassDecl->bases_end(); ++Base) { 1846 // FIXME. copy assignment of virtual base NYI 1847 if (Base->isVirtual()) 1848 continue; 1849 1850 CXXRecordDecl *BaseClassDecl 1851 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1852 if (BaseClassDecl->hasTrivialDestructor()) 1853 continue; 1854 DestructedBases.push_back(BaseClassDecl); 1855 } 1856 if (DestructedBases.empty()) 1857 return; 1858 for (int i = DestructedBases.size() -1; i >= 0; --i) { 1859 CXXRecordDecl *BaseClassDecl = DestructedBases[i]; 1860 llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(), 1861 ClassDecl,BaseClassDecl); 1862 EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()), 1863 Dtor_Complete, V); 1864 } 1865} 1866 1867void CodeGenFunction::SynthesizeDefaultDestructor(const CXXDestructorDecl *CD, 1868 const FunctionDecl *FD, 1869 llvm::Function *Fn, 1870 const FunctionArgList &Args) { 1871 1872 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1873 assert(!ClassDecl->hasUserDeclaredDestructor() && 1874 "SynthesizeDefaultDestructor - destructor has user declaration"); 1875 (void) ClassDecl; 1876 1877 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1878 EmitDtorEpilogue(CD); 1879 FinishFunction(); 1880} 1881