CGCXX.cpp revision 1c536bf6bbb0cdc039cff754825b36f9abfe0629
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 if (MD->isVirtual()) { 204 ErrorUnsupported(CE, "virtual dispatch"); 205 } 206 207 const llvm::Type *Ty = 208 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 209 FPT->isVariadic()); 210 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty); 211 212 llvm::Value *This; 213 214 if (ME->isArrow()) 215 This = EmitScalarExpr(ME->getBase()); 216 else { 217 LValue BaseLV = EmitLValue(ME->getBase()); 218 This = BaseLV.getAddress(); 219 } 220 221 return EmitCXXMemberCall(MD, Callee, This, 222 CE->arg_begin(), CE->arg_end()); 223} 224 225RValue 226CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, 227 const CXXMethodDecl *MD) { 228 assert(MD->isInstance() && 229 "Trying to emit a member call expr on a static method!"); 230 231 if (MD->isCopyAssignment()) { 232 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext()); 233 if (ClassDecl->hasTrivialCopyAssignment()) { 234 assert(!ClassDecl->hasUserDeclaredCopyAssignment() && 235 "EmitCXXOperatorMemberCallExpr - user declared copy assignment"); 236 llvm::Value *This = EmitLValue(E->getArg(0)).getAddress(); 237 llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress(); 238 QualType Ty = E->getType(); 239 EmitAggregateCopy(This, Src, Ty); 240 return RValue::get(This); 241 } 242 } 243 244 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 245 const llvm::Type *Ty = 246 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 247 FPT->isVariadic()); 248 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty); 249 250 llvm::Value *This = EmitLValue(E->getArg(0)).getAddress(); 251 252 return EmitCXXMemberCall(MD, Callee, This, 253 E->arg_begin() + 1, E->arg_end()); 254} 255 256llvm::Value *CodeGenFunction::LoadCXXThis() { 257 assert(isa<CXXMethodDecl>(CurFuncDecl) && 258 "Must be in a C++ member function decl to load 'this'"); 259 assert(cast<CXXMethodDecl>(CurFuncDecl)->isInstance() && 260 "Must be in a C++ member function decl to load 'this'"); 261 262 // FIXME: What if we're inside a block? 263 // ans: See how CodeGenFunction::LoadObjCSelf() uses 264 // CodeGenFunction::BlockForwardSelf() for how to do this. 265 return Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this"); 266} 267 268static bool 269GetNestedPaths(llvm::SmallVectorImpl<const CXXRecordDecl *> &NestedBasePaths, 270 const CXXRecordDecl *ClassDecl, 271 const CXXRecordDecl *BaseClassDecl) { 272 for (CXXRecordDecl::base_class_const_iterator i = ClassDecl->bases_begin(), 273 e = ClassDecl->bases_end(); i != e; ++i) { 274 if (i->isVirtual()) 275 continue; 276 const CXXRecordDecl *Base = 277 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 278 if (Base == BaseClassDecl) { 279 NestedBasePaths.push_back(BaseClassDecl); 280 return true; 281 } 282 } 283 // BaseClassDecl not an immediate base of ClassDecl. 284 for (CXXRecordDecl::base_class_const_iterator i = ClassDecl->bases_begin(), 285 e = ClassDecl->bases_end(); i != e; ++i) { 286 if (i->isVirtual()) 287 continue; 288 const CXXRecordDecl *Base = 289 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 290 if (GetNestedPaths(NestedBasePaths, Base, BaseClassDecl)) { 291 NestedBasePaths.push_back(Base); 292 return true; 293 } 294 } 295 return false; 296} 297 298llvm::Value *CodeGenFunction::AddressCXXOfBaseClass(llvm::Value *BaseValue, 299 const CXXRecordDecl *ClassDecl, 300 const CXXRecordDecl *BaseClassDecl) { 301 if (ClassDecl == BaseClassDecl) 302 return BaseValue; 303 304 llvm::Type *I8Ptr = llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext)); 305 llvm::SmallVector<const CXXRecordDecl *, 16> NestedBasePaths; 306 GetNestedPaths(NestedBasePaths, ClassDecl, BaseClassDecl); 307 assert(NestedBasePaths.size() > 0 && 308 "AddressCXXOfBaseClass - inheritence path failed"); 309 NestedBasePaths.push_back(ClassDecl); 310 uint64_t Offset = 0; 311 312 // Accessing a member of the base class. Must add delata to 313 // the load of 'this'. 314 for (unsigned i = NestedBasePaths.size()-1; i > 0; i--) { 315 const CXXRecordDecl *DerivedClass = NestedBasePaths[i]; 316 const CXXRecordDecl *BaseClass = NestedBasePaths[i-1]; 317 const ASTRecordLayout &Layout = 318 getContext().getASTRecordLayout(DerivedClass); 319 Offset += Layout.getBaseClassOffset(BaseClass) / 8; 320 } 321 llvm::Value *OffsetVal = 322 llvm::ConstantInt::get( 323 CGM.getTypes().ConvertType(CGM.getContext().LongTy), Offset); 324 BaseValue = Builder.CreateBitCast(BaseValue, I8Ptr); 325 BaseValue = Builder.CreateGEP(BaseValue, OffsetVal, "add.ptr"); 326 QualType BTy = 327 getContext().getCanonicalType( 328 getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(BaseClassDecl))); 329 const llvm::Type *BasePtr = ConvertType(BTy); 330 BasePtr = llvm::PointerType::getUnqual(BasePtr); 331 BaseValue = Builder.CreateBitCast(BaseValue, BasePtr); 332 return BaseValue; 333} 334 335/// EmitCXXAggrConstructorCall - This routine essentially creates a (nested) 336/// for-loop to call the default constructor on individual members of the 337/// array. 'Array' is the array type, 'This' is llvm pointer of the start 338/// of the array and 'D' is the default costructor Decl for elements of the 339/// array. It is assumed that all relevant checks have been made by the 340/// caller. 341void 342CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, 343 const ArrayType *Array, 344 llvm::Value *This) { 345 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array); 346 assert(CA && "Do we support VLA for construction ?"); 347 348 // Create a temporary for the loop index and initialize it with 0. 349 llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt32Ty(VMContext), 350 "loop.index"); 351 llvm::Value* zeroConstant = 352 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 353 Builder.CreateStore(zeroConstant, IndexPtr, false); 354 355 // Start the loop with a block that tests the condition. 356 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 357 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 358 359 EmitBlock(CondBlock); 360 361 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 362 363 // Generate: if (loop-index < number-of-elements fall to the loop body, 364 // otherwise, go to the block after the for-loop. 365 uint64_t NumElements = CA->getSize().getZExtValue(); 366 llvm::Value * NumElementsPtr = 367 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), NumElements); 368 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 369 llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr, 370 "isless"); 371 // If the condition is true, execute the body. 372 Builder.CreateCondBr(IsLess, ForBody, AfterFor); 373 374 EmitBlock(ForBody); 375 376 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 377 // Inside the loop body, emit the constructor call on the array element. 378 Counter = Builder.CreateLoad(IndexPtr); 379 if (const ConstantArrayType *CAT = 380 dyn_cast<ConstantArrayType>(Array->getElementType())) { 381 uint32_t delta = 1; 382 const ConstantArrayType *CAW = CAT; 383 do { 384 delta *= CAW->getSize().getZExtValue(); 385 CAW = dyn_cast<ConstantArrayType>(CAW->getElementType()); 386 } while (CAW); 387 // Address = This + delta*Counter for current loop iteration. 388 llvm::Value *DeltaPtr = 389 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), delta); 390 DeltaPtr = Builder.CreateMul(Counter, DeltaPtr, "mul"); 391 llvm::Value *Address = 392 Builder.CreateInBoundsGEP(This, DeltaPtr, "arrayidx"); 393 EmitCXXAggrConstructorCall(D, CAT, Address); 394 } 395 else { 396 llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx"); 397 EmitCXXConstructorCall(D, Ctor_Complete, Address, 0, 0); 398 } 399 400 EmitBlock(ContinueBlock); 401 402 // Emit the increment of the loop counter. 403 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1); 404 Counter = Builder.CreateLoad(IndexPtr); 405 NextVal = Builder.CreateAdd(Counter, NextVal, "inc"); 406 Builder.CreateStore(NextVal, IndexPtr, false); 407 408 // Finally, branch back up to the condition for the next iteration. 409 EmitBranch(CondBlock); 410 411 // Emit the fall-through block. 412 EmitBlock(AfterFor, true); 413} 414 415/// EmitCXXAggrDestructorCall - calls the default destructor on array 416/// elements in reverse order of construction. 417void 418CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D, 419 const ArrayType *Array, 420 llvm::Value *This) { 421 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array); 422 assert(CA && "Do we support VLA for destruction ?"); 423 llvm::Value *One = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 424 1); 425 uint64_t ElementCount = 1; 426 const ConstantArrayType *CAW = CA; 427 do { 428 ElementCount *= CAW->getSize().getZExtValue(); 429 CAW = dyn_cast<ConstantArrayType>(CAW->getElementType()); 430 } while (CAW); 431 // Create a temporary for the loop index and initialize it with count of 432 // array elements. 433 llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext), 434 "loop.index"); 435 // Index = ElementCount; 436 llvm::Value* UpperCount = 437 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), ElementCount); 438 Builder.CreateStore(UpperCount, IndexPtr, false); 439 440 // Start the loop with a block that tests the condition. 441 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 442 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 443 444 EmitBlock(CondBlock); 445 446 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 447 448 // Generate: if (loop-index != 0 fall to the loop body, 449 // otherwise, go to the block after the for-loop. 450 llvm::Value* zeroConstant = 451 llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)); 452 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 453 llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant, 454 "isne"); 455 // If the condition is true, execute the body. 456 Builder.CreateCondBr(IsNE, ForBody, AfterFor); 457 458 EmitBlock(ForBody); 459 460 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 461 // Inside the loop body, emit the constructor call on the array element. 462 Counter = Builder.CreateLoad(IndexPtr); 463 Counter = Builder.CreateSub(Counter, One); 464 llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx"); 465 EmitCXXDestructorCall(D, Dtor_Complete, Address); 466 467 EmitBlock(ContinueBlock); 468 469 // Emit the decrement of the loop counter. 470 Counter = Builder.CreateLoad(IndexPtr); 471 Counter = Builder.CreateSub(Counter, One, "dec"); 472 Builder.CreateStore(Counter, IndexPtr, false); 473 474 // Finally, branch back up to the condition for the next iteration. 475 EmitBranch(CondBlock); 476 477 // Emit the fall-through block. 478 EmitBlock(AfterFor, true); 479} 480 481void 482CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D, 483 CXXCtorType Type, 484 llvm::Value *This, 485 CallExpr::const_arg_iterator ArgBeg, 486 CallExpr::const_arg_iterator ArgEnd) { 487 if (D->isCopyConstructor(getContext())) { 488 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D->getDeclContext()); 489 if (ClassDecl->hasTrivialCopyConstructor()) { 490 assert(!ClassDecl->hasUserDeclaredCopyConstructor() && 491 "EmitCXXConstructorCall - user declared copy constructor"); 492 const Expr *E = (*ArgBeg); 493 QualType Ty = E->getType(); 494 llvm::Value *Src = EmitLValue(E).getAddress(); 495 EmitAggregateCopy(This, Src, Ty); 496 return; 497 } 498 } 499 500 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type); 501 502 EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd); 503} 504 505void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D, 506 CXXDtorType Type, 507 llvm::Value *This) { 508 llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type); 509 510 EmitCXXMemberCall(D, Callee, This, 0, 0); 511} 512 513void 514CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest, 515 const CXXConstructExpr *E) { 516 assert(Dest && "Must have a destination!"); 517 518 const CXXRecordDecl *RD = 519 cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 520 if (RD->hasTrivialConstructor()) 521 return; 522 523 // Code gen optimization to eliminate copy constructor and return 524 // its first argument instead. 525 if (E->isElidable()) { 526 CXXConstructExpr::const_arg_iterator i = E->arg_begin(); 527 EmitAggExpr((*i), Dest, false); 528 return; 529 } 530 // Call the constructor. 531 EmitCXXConstructorCall(E->getConstructor(), Ctor_Complete, Dest, 532 E->arg_begin(), E->arg_end()); 533} 534 535llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) { 536 if (E->isArray()) { 537 ErrorUnsupported(E, "new[] expression"); 538 return llvm::UndefValue::get(ConvertType(E->getType())); 539 } 540 541 QualType AllocType = E->getAllocatedType(); 542 FunctionDecl *NewFD = E->getOperatorNew(); 543 const FunctionProtoType *NewFTy = NewFD->getType()->getAsFunctionProtoType(); 544 545 CallArgList NewArgs; 546 547 // The allocation size is the first argument. 548 QualType SizeTy = getContext().getSizeType(); 549 llvm::Value *AllocSize = 550 llvm::ConstantInt::get(ConvertType(SizeTy), 551 getContext().getTypeSize(AllocType) / 8); 552 553 NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy)); 554 555 // Emit the rest of the arguments. 556 // FIXME: Ideally, this should just use EmitCallArgs. 557 CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin(); 558 559 // First, use the types from the function type. 560 // We start at 1 here because the first argument (the allocation size) 561 // has already been emitted. 562 for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) { 563 QualType ArgType = NewFTy->getArgType(i); 564 565 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()). 566 getTypePtr() == 567 getContext().getCanonicalType(NewArg->getType()).getTypePtr() && 568 "type mismatch in call argument!"); 569 570 NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType), 571 ArgType)); 572 573 } 574 575 // Either we've emitted all the call args, or we have a call to a 576 // variadic function. 577 assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) && 578 "Extra arguments in non-variadic function!"); 579 580 // If we still have any arguments, emit them using the type of the argument. 581 for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end(); 582 NewArg != NewArgEnd; ++NewArg) { 583 QualType ArgType = NewArg->getType(); 584 NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType), 585 ArgType)); 586 } 587 588 // Emit the call to new. 589 RValue RV = 590 EmitCall(CGM.getTypes().getFunctionInfo(NewFTy->getResultType(), NewArgs), 591 CGM.GetAddrOfFunction(GlobalDecl(NewFD)), 592 NewArgs, NewFD); 593 594 // If an allocation function is declared with an empty exception specification 595 // it returns null to indicate failure to allocate storage. [expr.new]p13. 596 // (We don't need to check for null when there's no new initializer and 597 // we're allocating a POD type). 598 bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() && 599 !(AllocType->isPODType() && !E->hasInitializer()); 600 601 llvm::BasicBlock *NewNull = 0; 602 llvm::BasicBlock *NewNotNull = 0; 603 llvm::BasicBlock *NewEnd = 0; 604 605 llvm::Value *NewPtr = RV.getScalarVal(); 606 607 if (NullCheckResult) { 608 NewNull = createBasicBlock("new.null"); 609 NewNotNull = createBasicBlock("new.notnull"); 610 NewEnd = createBasicBlock("new.end"); 611 612 llvm::Value *IsNull = 613 Builder.CreateICmpEQ(NewPtr, 614 llvm::Constant::getNullValue(NewPtr->getType()), 615 "isnull"); 616 617 Builder.CreateCondBr(IsNull, NewNull, NewNotNull); 618 EmitBlock(NewNotNull); 619 } 620 621 NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType())); 622 623 if (AllocType->isPODType()) { 624 if (E->getNumConstructorArgs() > 0) { 625 assert(E->getNumConstructorArgs() == 1 && 626 "Can only have one argument to initializer of POD type."); 627 628 const Expr *Init = E->getConstructorArg(0); 629 630 if (!hasAggregateLLVMType(AllocType)) 631 Builder.CreateStore(EmitScalarExpr(Init), NewPtr); 632 else if (AllocType->isAnyComplexType()) 633 EmitComplexExprIntoAddr(Init, NewPtr, AllocType.isVolatileQualified()); 634 else 635 EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified()); 636 } 637 } else { 638 // Call the constructor. 639 CXXConstructorDecl *Ctor = E->getConstructor(); 640 641 EmitCXXConstructorCall(Ctor, Ctor_Complete, NewPtr, 642 E->constructor_arg_begin(), 643 E->constructor_arg_end()); 644 } 645 646 if (NullCheckResult) { 647 Builder.CreateBr(NewEnd); 648 EmitBlock(NewNull); 649 Builder.CreateBr(NewEnd); 650 EmitBlock(NewEnd); 651 652 llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType()); 653 PHI->reserveOperandSpace(2); 654 PHI->addIncoming(NewPtr, NewNotNull); 655 PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull); 656 657 NewPtr = PHI; 658 } 659 660 return NewPtr; 661} 662 663void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) { 664 if (E->isArrayForm()) { 665 ErrorUnsupported(E, "delete[] expression"); 666 return; 667 }; 668 669 QualType DeleteTy = 670 E->getArgument()->getType()->getAs<PointerType>()->getPointeeType(); 671 672 llvm::Value *Ptr = EmitScalarExpr(E->getArgument()); 673 674 // Null check the pointer. 675 llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull"); 676 llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end"); 677 678 llvm::Value *IsNull = 679 Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()), 680 "isnull"); 681 682 Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull); 683 EmitBlock(DeleteNotNull); 684 685 // Call the destructor if necessary. 686 if (const RecordType *RT = DeleteTy->getAs<RecordType>()) { 687 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 688 if (!RD->hasTrivialDestructor()) { 689 const CXXDestructorDecl *Dtor = RD->getDestructor(getContext()); 690 if (Dtor->isVirtual()) { 691 ErrorUnsupported(E, "delete expression with virtual destructor"); 692 return; 693 } 694 695 EmitCXXDestructorCall(Dtor, Dtor_Complete, Ptr); 696 } 697 } 698 } 699 700 // Call delete. 701 FunctionDecl *DeleteFD = E->getOperatorDelete(); 702 const FunctionProtoType *DeleteFTy = 703 DeleteFD->getType()->getAsFunctionProtoType(); 704 705 CallArgList DeleteArgs; 706 707 QualType ArgTy = DeleteFTy->getArgType(0); 708 llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy)); 709 DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy)); 710 711 // Emit the call to delete. 712 EmitCall(CGM.getTypes().getFunctionInfo(DeleteFTy->getResultType(), 713 DeleteArgs), 714 CGM.GetAddrOfFunction(GlobalDecl(DeleteFD)), 715 DeleteArgs, DeleteFD); 716 717 EmitBlock(DeleteEnd); 718} 719 720static bool canGenerateCXXstructor(const CXXRecordDecl *RD, 721 ASTContext &Context) { 722 // The class has base classes - we don't support that right now. 723 if (RD->getNumBases() > 0) 724 return false; 725 726 for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 727 I != E; ++I) { 728 // We don't support ctors for fields that aren't POD. 729 if (!I->getType()->isPODType()) 730 return false; 731 } 732 733 return true; 734} 735 736void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) { 737 if (!canGenerateCXXstructor(D->getParent(), getContext())) { 738 ErrorUnsupported(D, "C++ constructor", true); 739 return; 740 } 741 742 EmitGlobal(GlobalDecl(D, Ctor_Complete)); 743 EmitGlobal(GlobalDecl(D, Ctor_Base)); 744} 745 746void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D, 747 CXXCtorType Type) { 748 749 llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type); 750 751 CodeGenFunction(*this).GenerateCode(D, Fn); 752 753 SetFunctionDefinitionAttributes(D, Fn); 754 SetLLVMFunctionAttributesForDefinition(D, Fn); 755} 756 757llvm::Function * 758CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D, 759 CXXCtorType Type) { 760 const llvm::FunctionType *FTy = 761 getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false); 762 763 const char *Name = getMangledCXXCtorName(D, Type); 764 return cast<llvm::Function>( 765 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type))); 766} 767 768const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D, 769 CXXCtorType Type) { 770 llvm::SmallString<256> Name; 771 llvm::raw_svector_ostream Out(Name); 772 mangleCXXCtor(D, Type, Context, Out); 773 774 Name += '\0'; 775 return UniqueMangledName(Name.begin(), Name.end()); 776} 777 778void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) { 779 if (!canGenerateCXXstructor(D->getParent(), getContext())) { 780 ErrorUnsupported(D, "C++ destructor", true); 781 return; 782 } 783 784 EmitCXXDestructor(D, Dtor_Complete); 785 EmitCXXDestructor(D, Dtor_Base); 786} 787 788void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D, 789 CXXDtorType Type) { 790 llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type); 791 792 CodeGenFunction(*this).GenerateCode(D, Fn); 793 794 SetFunctionDefinitionAttributes(D, Fn); 795 SetLLVMFunctionAttributesForDefinition(D, Fn); 796} 797 798llvm::Function * 799CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D, 800 CXXDtorType Type) { 801 const llvm::FunctionType *FTy = 802 getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false); 803 804 const char *Name = getMangledCXXDtorName(D, Type); 805 return cast<llvm::Function>( 806 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type))); 807} 808 809const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D, 810 CXXDtorType Type) { 811 llvm::SmallString<256> Name; 812 llvm::raw_svector_ostream Out(Name); 813 mangleCXXDtor(D, Type, Context, Out); 814 815 Name += '\0'; 816 return UniqueMangledName(Name.begin(), Name.end()); 817} 818 819llvm::Constant *CodeGenModule::GenerateRtti(const CXXRecordDecl *RD) { 820 llvm::Type *Ptr8Ty; 821 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 822 llvm::Constant *Rtti = llvm::Constant::getNullValue(Ptr8Ty); 823 824 if (!getContext().getLangOptions().Rtti) 825 return Rtti; 826 827 llvm::SmallString<256> OutName; 828 llvm::raw_svector_ostream Out(OutName); 829 QualType ClassTy; 830 ClassTy = getContext().getTagDeclType(RD); 831 mangleCXXRtti(ClassTy, getContext(), Out); 832 llvm::GlobalVariable::LinkageTypes linktype; 833 linktype = llvm::GlobalValue::WeakAnyLinkage; 834 std::vector<llvm::Constant *> info; 835 // assert(0 && "FIXME: implement rtti descriptor"); 836 // FIXME: descriptor 837 info.push_back(llvm::Constant::getNullValue(Ptr8Ty)); 838 // assert(0 && "FIXME: implement rtti ts"); 839 // FIXME: TS 840 info.push_back(llvm::Constant::getNullValue(Ptr8Ty)); 841 842 llvm::Constant *C; 843 llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, info.size()); 844 C = llvm::ConstantArray::get(type, info); 845 Rtti = new llvm::GlobalVariable(getModule(), type, true, linktype, C, 846 Out.str()); 847 Rtti = llvm::ConstantExpr::getBitCast(Rtti, Ptr8Ty); 848 return Rtti; 849} 850 851class VtableBuilder { 852 std::vector<llvm::Constant *> &methods; 853 llvm::Type *Ptr8Ty; 854 const CXXRecordDecl *Class; 855 const ASTRecordLayout &BLayout; 856 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary; 857 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase; 858 llvm::Constant *rtti; 859 llvm::LLVMContext &VMContext; 860 CodeGenModule &CGM; // Per-module state. 861 862 typedef CXXRecordDecl::method_iterator method_iter; 863public: 864 VtableBuilder(std::vector<llvm::Constant *> &meth, 865 const CXXRecordDecl *c, 866 CodeGenModule &cgm) 867 : methods(meth), Class(c), BLayout(cgm.getContext().getASTRecordLayout(c)), 868 rtti(cgm.GenerateRtti(c)), VMContext(cgm.getModule().getContext()), 869 CGM(cgm) { 870 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 871 } 872 873 llvm::Constant *GenerateVcall(const CXXMethodDecl *MD, 874 const CXXRecordDecl *RD, 875 bool VBoundary, 876 bool SecondaryVirtual) { 877 llvm::Constant *m = 0; 878 879 // FIXME: vcall: offset for virtual base for this function 880 if (SecondaryVirtual || VBoundary) 881 m = llvm::Constant::getNullValue(Ptr8Ty); 882 return m; 883 } 884 885 void GenerateVcalls(const CXXRecordDecl *RD, bool VBoundary, 886 bool SecondaryVirtual) { 887 llvm::Constant *m; 888 889 for (method_iter mi = RD->method_begin(), 890 me = RD->method_end(); mi != me; ++mi) { 891 if (mi->isVirtual()) { 892 m = GenerateVcall(*mi, RD, VBoundary, SecondaryVirtual); 893 if (m) 894 methods.push_back(m); 895 } 896 } 897 } 898 899 void GenerateVBaseOffsets(std::vector<llvm::Constant *> &offsets, 900 const CXXRecordDecl *RD, uint64_t Offset) { 901 for (CXXRecordDecl::base_class_const_iterator i =RD->bases_begin(), 902 e = RD->bases_end(); i != e; ++i) { 903 const CXXRecordDecl *Base = 904 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 905 if (i->isVirtual() && !SeenVBase.count(Base)) { 906 SeenVBase.insert(Base); 907 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8; 908 llvm::Constant *m; 909 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),BaseOffset); 910 m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty); 911 offsets.push_back(m); 912 } 913 GenerateVBaseOffsets(offsets, Base, Offset); 914 } 915 } 916 917 void GenerateMethods(const CXXRecordDecl *RD) { 918 llvm::Constant *m; 919 920 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me; 921 ++mi) { 922 if (mi->isVirtual()) { 923 m = CGM.GetAddrOfFunction(GlobalDecl(*mi)); 924 m = llvm::ConstantExpr::getBitCast(m, Ptr8Ty); 925 methods.push_back(m); 926 } 927 } 928 } 929 930 void GenerateVtableForBase(const CXXRecordDecl *RD, 931 bool forPrimary, 932 bool VBoundary, 933 int64_t Offset, 934 bool ForVirtualBase) { 935 llvm::Constant *m = llvm::Constant::getNullValue(Ptr8Ty); 936 937 if (RD && !RD->isDynamicClass()) 938 return; 939 940 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 941 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 942 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual(); 943 944 if (VBoundary || forPrimary || ForVirtualBase) { 945 // then comes the the vcall offsets for all our functions... 946 GenerateVcalls(RD, VBoundary, !forPrimary && ForVirtualBase); 947 } 948 949 // The virtual base offsets come first... 950 // FIXME: Audit, is this right? 951 if (PrimaryBase == 0 || forPrimary || !PrimaryBaseWasVirtual) { 952 std::vector<llvm::Constant *> offsets; 953 GenerateVBaseOffsets(offsets, RD, Offset); 954 for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(), 955 e = offsets.rend(); i != e; ++i) 956 methods.push_back(*i); 957 } 958 959 bool Top = true; 960 961 // vtables are composed from the chain of primaries. 962 if (PrimaryBase) { 963 if (PrimaryBaseWasVirtual) 964 IndirectPrimary.insert(PrimaryBase); 965 Top = false; 966 GenerateVtableForBase(PrimaryBase, true, PrimaryBaseWasVirtual|VBoundary, 967 Offset, PrimaryBaseWasVirtual); 968 } 969 970 if (Top) { 971 int64_t BaseOffset; 972 if (ForVirtualBase) { 973 BaseOffset = -(BLayout.getVBaseClassOffset(RD) / 8); 974 } else 975 BaseOffset = -Offset/8; 976 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), BaseOffset); 977 m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty); 978 methods.push_back(m); 979 methods.push_back(rtti); 980 } 981 982 // And add the virtuals for the class to the primary vtable. 983 GenerateMethods(RD); 984 985 // and then the non-virtual bases. 986 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 987 e = RD->bases_end(); i != e; ++i) { 988 if (i->isVirtual()) 989 continue; 990 const CXXRecordDecl *Base = 991 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 992 if (Base != PrimaryBase || PrimaryBaseWasVirtual) { 993 uint64_t o = Offset + Layout.getBaseClassOffset(Base); 994 SeenVBase.clear(); 995 GenerateVtableForBase(Base, true, false, o, false); 996 } 997 } 998 } 999 1000 void GenerateVtableForVBases(const CXXRecordDecl *RD, 1001 const CXXRecordDecl *Class) { 1002 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 1003 e = RD->bases_end(); i != e; ++i) { 1004 const CXXRecordDecl *Base = 1005 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 1006 if (i->isVirtual() && !IndirectPrimary.count(Base)) { 1007 // Mark it so we don't output it twice. 1008 IndirectPrimary.insert(Base); 1009 SeenVBase.clear(); 1010 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base); 1011 GenerateVtableForBase(Base, false, true, BaseOffset, true); 1012 } 1013 if (Base->getNumVBases()) 1014 GenerateVtableForVBases(Base, Class); 1015 } 1016 } 1017}; 1018 1019llvm::Value *CodeGenFunction::GenerateVtable(const CXXRecordDecl *RD) { 1020 llvm::SmallString<256> OutName; 1021 llvm::raw_svector_ostream Out(OutName); 1022 QualType ClassTy; 1023 ClassTy = getContext().getTagDeclType(RD); 1024 mangleCXXVtable(ClassTy, getContext(), Out); 1025 llvm::GlobalVariable::LinkageTypes linktype; 1026 linktype = llvm::GlobalValue::WeakAnyLinkage; 1027 std::vector<llvm::Constant *> methods; 1028 llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0); 1029 int64_t Offset = 0; 1030 1031 Offset += LLVMPointerWidth; 1032 Offset += LLVMPointerWidth; 1033 1034 VtableBuilder b(methods, RD, CGM); 1035 1036 // First comes the vtables for all the non-virtual bases... 1037 b.GenerateVtableForBase(RD, true, false, 0, false); 1038 1039 // then the vtables for all the virtual bases. 1040 b.GenerateVtableForVBases(RD, RD); 1041 1042 llvm::Constant *C; 1043 llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, methods.size()); 1044 C = llvm::ConstantArray::get(type, methods); 1045 llvm::Value *vtable = new llvm::GlobalVariable(CGM.getModule(), type, true, 1046 linktype, C, Out.str()); 1047 vtable = Builder.CreateBitCast(vtable, Ptr8Ty); 1048 vtable = Builder.CreateGEP(vtable, 1049 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 1050 Offset/8)); 1051 return vtable; 1052} 1053 1054/// EmitClassMemberwiseCopy - This routine generates code to copy a class 1055/// object from SrcValue to DestValue. Copying can be either a bitwise copy 1056/// of via a copy constructor call. 1057void CodeGenFunction::EmitClassMemberwiseCopy( 1058 llvm::Value *Dest, llvm::Value *Src, 1059 const CXXRecordDecl *ClassDecl, 1060 const CXXRecordDecl *BaseClassDecl, QualType Ty) { 1061 if (ClassDecl) { 1062 Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl); 1063 Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ; 1064 } 1065 if (BaseClassDecl->hasTrivialCopyConstructor()) { 1066 EmitAggregateCopy(Dest, Src, Ty); 1067 return; 1068 } 1069 1070 if (CXXConstructorDecl *BaseCopyCtor = 1071 BaseClassDecl->getCopyConstructor(getContext(), 0)) { 1072 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor, 1073 Ctor_Complete); 1074 CallArgList CallArgs; 1075 // Push the this (Dest) ptr. 1076 CallArgs.push_back(std::make_pair(RValue::get(Dest), 1077 BaseCopyCtor->getThisType(getContext()))); 1078 1079 // Push the Src ptr. 1080 CallArgs.push_back(std::make_pair(RValue::get(Src), 1081 BaseCopyCtor->getParamDecl(0)->getType())); 1082 QualType ResultType = 1083 BaseCopyCtor->getType()->getAsFunctionType()->getResultType(); 1084 EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs), 1085 Callee, CallArgs, BaseCopyCtor); 1086 } 1087} 1088 1089/// EmitClassCopyAssignment - This routine generates code to copy assign a class 1090/// object from SrcValue to DestValue. Assignment can be either a bitwise 1091/// assignment of via an assignment operator call. 1092void CodeGenFunction::EmitClassCopyAssignment( 1093 llvm::Value *Dest, llvm::Value *Src, 1094 const CXXRecordDecl *ClassDecl, 1095 const CXXRecordDecl *BaseClassDecl, 1096 QualType Ty) { 1097 if (ClassDecl) { 1098 Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl); 1099 Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ; 1100 } 1101 if (BaseClassDecl->hasTrivialCopyAssignment()) { 1102 EmitAggregateCopy(Dest, Src, Ty); 1103 return; 1104 } 1105 1106 const CXXMethodDecl *MD = 0; 1107 bool ConstCopyAssignOp = BaseClassDecl->hasConstCopyAssignment(getContext(), 1108 MD); 1109 assert(ConstCopyAssignOp && "EmitClassCopyAssignment - missing copy assign"); 1110 (void)ConstCopyAssignOp; 1111 1112 const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType(); 1113 const llvm::Type *LTy = 1114 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD), 1115 FPT->isVariadic()); 1116 llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), LTy); 1117 1118 CallArgList CallArgs; 1119 // Push the this (Dest) ptr. 1120 CallArgs.push_back(std::make_pair(RValue::get(Dest), 1121 MD->getThisType(getContext()))); 1122 1123 // Push the Src ptr. 1124 CallArgs.push_back(std::make_pair(RValue::get(Src), 1125 MD->getParamDecl(0)->getType())); 1126 QualType ResultType = 1127 MD->getType()->getAsFunctionType()->getResultType(); 1128 EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs), 1129 Callee, CallArgs, MD); 1130} 1131 1132/// SynthesizeDefaultConstructor - synthesize a default constructor 1133void 1134CodeGenFunction::SynthesizeDefaultConstructor(const CXXConstructorDecl *CD, 1135 const FunctionDecl *FD, 1136 llvm::Function *Fn, 1137 const FunctionArgList &Args) { 1138 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1139 EmitCtorPrologue(CD); 1140 FinishFunction(); 1141} 1142 1143/// SynthesizeCXXCopyConstructor - This routine implicitly defines body of a copy 1144/// constructor, in accordance with section 12.8 (p7 and p8) of C++03 1145/// The implicitly-defined copy constructor for class X performs a memberwise 1146/// copy of its subobjects. The order of copying is the same as the order 1147/// of initialization of bases and members in a user-defined constructor 1148/// Each subobject is copied in the manner appropriate to its type: 1149/// if the subobject is of class type, the copy constructor for the class is 1150/// used; 1151/// if the subobject is an array, each element is copied, in the manner 1152/// appropriate to the element type; 1153/// if the subobject is of scalar type, the built-in assignment operator is 1154/// used. 1155/// Virtual base class subobjects shall be copied only once by the 1156/// implicitly-defined copy constructor 1157 1158void CodeGenFunction::SynthesizeCXXCopyConstructor(const CXXConstructorDecl *CD, 1159 const FunctionDecl *FD, 1160 llvm::Function *Fn, 1161 const FunctionArgList &Args) { 1162 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1163 assert(!ClassDecl->hasUserDeclaredCopyConstructor() && 1164 "SynthesizeCXXCopyConstructor - copy constructor has definition already"); 1165 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1166 1167 FunctionArgList::const_iterator i = Args.begin(); 1168 const VarDecl *ThisArg = i->first; 1169 llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg); 1170 llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this"); 1171 const VarDecl *SrcArg = (i+1)->first; 1172 llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg); 1173 llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj); 1174 1175 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 1176 Base != ClassDecl->bases_end(); ++Base) { 1177 // FIXME. copy constrution of virtual base NYI 1178 if (Base->isVirtual()) 1179 continue; 1180 1181 CXXRecordDecl *BaseClassDecl 1182 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1183 EmitClassMemberwiseCopy(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl, 1184 Base->getType()); 1185 } 1186 1187 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1188 FieldEnd = ClassDecl->field_end(); 1189 Field != FieldEnd; ++Field) { 1190 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1191 1192 // FIXME. How about copying arrays! 1193 assert(!getContext().getAsArrayType(FieldType) && 1194 "FIXME. Copying arrays NYI"); 1195 1196 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 1197 CXXRecordDecl *FieldClassDecl 1198 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 1199 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1200 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1201 1202 EmitClassMemberwiseCopy(LHS.getAddress(), RHS.getAddress(), 1203 0 /*ClassDecl*/, FieldClassDecl, FieldType); 1204 continue; 1205 } 1206 // Do a built-in assignment of scalar data members. 1207 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1208 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1209 RValue RVRHS = EmitLoadOfLValue(RHS, FieldType); 1210 EmitStoreThroughLValue(RVRHS, LHS, FieldType); 1211 } 1212 FinishFunction(); 1213} 1214 1215/// SynthesizeCXXCopyAssignment - Implicitly define copy assignment operator. 1216/// Before the implicitly-declared copy assignment operator for a class is 1217/// implicitly defined, all implicitly- declared copy assignment operators for 1218/// its direct base classes and its nonstatic data members shall have been 1219/// implicitly defined. [12.8-p12] 1220/// The implicitly-defined copy assignment operator for class X performs 1221/// memberwise assignment of its subob- jects. The direct base classes of X are 1222/// assigned first, in the order of their declaration in 1223/// the base-specifier-list, and then the immediate nonstatic data members of X 1224/// are assigned, in the order in which they were declared in the class 1225/// definition.Each subobject is assigned in the manner appropriate to its type: 1226/// if the subobject is of class type, the copy assignment operator for the 1227/// class is used (as if by explicit qualification; that is, ignoring any 1228/// possible virtual overriding functions in more derived classes); 1229/// 1230/// if the subobject is an array, each element is assigned, in the manner 1231/// appropriate to the element type; 1232/// 1233/// if the subobject is of scalar type, the built-in assignment operator is 1234/// used. 1235void CodeGenFunction::SynthesizeCXXCopyAssignment(const CXXMethodDecl *CD, 1236 const FunctionDecl *FD, 1237 llvm::Function *Fn, 1238 const FunctionArgList &Args) { 1239 1240 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1241 assert(!ClassDecl->hasUserDeclaredCopyAssignment() && 1242 "SynthesizeCXXCopyAssignment - copy assignment has user declaration"); 1243 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1244 1245 FunctionArgList::const_iterator i = Args.begin(); 1246 const VarDecl *ThisArg = i->first; 1247 llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg); 1248 llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this"); 1249 const VarDecl *SrcArg = (i+1)->first; 1250 llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg); 1251 llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj); 1252 1253 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 1254 Base != ClassDecl->bases_end(); ++Base) { 1255 // FIXME. copy assignment of virtual base NYI 1256 if (Base->isVirtual()) 1257 continue; 1258 1259 CXXRecordDecl *BaseClassDecl 1260 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1261 EmitClassCopyAssignment(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl, 1262 Base->getType()); 1263 } 1264 1265 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1266 FieldEnd = ClassDecl->field_end(); 1267 Field != FieldEnd; ++Field) { 1268 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1269 1270 // FIXME. How about copy assignment of arrays! 1271 assert(!getContext().getAsArrayType(FieldType) && 1272 "FIXME. Copy assignment of arrays NYI"); 1273 1274 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 1275 CXXRecordDecl *FieldClassDecl 1276 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 1277 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1278 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1279 1280 EmitClassCopyAssignment(LHS.getAddress(), RHS.getAddress(), 1281 0 /*ClassDecl*/, FieldClassDecl, FieldType); 1282 continue; 1283 } 1284 // Do a built-in assignment of scalar data members. 1285 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1286 LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0); 1287 RValue RVRHS = EmitLoadOfLValue(RHS, FieldType); 1288 EmitStoreThroughLValue(RVRHS, LHS, FieldType); 1289 } 1290 1291 // return *this; 1292 Builder.CreateStore(LoadOfThis, ReturnValue); 1293 1294 FinishFunction(); 1295} 1296 1297/// EmitCtorPrologue - This routine generates necessary code to initialize 1298/// base classes and non-static data members belonging to this constructor. 1299void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD) { 1300 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1301 // FIXME: Add vbase initialization 1302 llvm::Value *LoadOfThis = 0; 1303 1304 for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(), 1305 E = CD->init_end(); 1306 B != E; ++B) { 1307 CXXBaseOrMemberInitializer *Member = (*B); 1308 if (Member->isBaseInitializer()) { 1309 LoadOfThis = LoadCXXThis(); 1310 Type *BaseType = Member->getBaseClass(); 1311 CXXRecordDecl *BaseClassDecl = 1312 cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl()); 1313 llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl, 1314 BaseClassDecl); 1315 EmitCXXConstructorCall(Member->getConstructor(), 1316 Ctor_Complete, V, 1317 Member->const_arg_begin(), 1318 Member->const_arg_end()); 1319 } else { 1320 // non-static data member initilaizers. 1321 FieldDecl *Field = Member->getMember(); 1322 QualType FieldType = getContext().getCanonicalType((Field)->getType()); 1323 assert(!getContext().getAsArrayType(FieldType) 1324 && "FIXME. Field arrays initialization unsupported"); 1325 1326 LoadOfThis = LoadCXXThis(); 1327 LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0); 1328 if (FieldType->getAs<RecordType>()) { 1329 if (!Field->isAnonymousStructOrUnion()) { 1330 assert(Member->getConstructor() && 1331 "EmitCtorPrologue - no constructor to initialize member"); 1332 EmitCXXConstructorCall(Member->getConstructor(), 1333 Ctor_Complete, LHS.getAddress(), 1334 Member->const_arg_begin(), 1335 Member->const_arg_end()); 1336 continue; 1337 } 1338 else { 1339 // Initializing an anonymous union data member. 1340 FieldDecl *anonMember = Member->getAnonUnionMember(); 1341 LHS = EmitLValueForField(LHS.getAddress(), anonMember, false, 0); 1342 FieldType = anonMember->getType(); 1343 } 1344 } 1345 1346 assert(Member->getNumArgs() == 1 && "Initializer count must be 1 only"); 1347 Expr *RhsExpr = *Member->arg_begin(); 1348 llvm::Value *RHS = EmitScalarExpr(RhsExpr, true); 1349 EmitStoreThroughLValue(RValue::get(RHS), LHS, FieldType); 1350 } 1351 } 1352 1353 if (!CD->getNumBaseOrMemberInitializers() && !CD->isTrivial()) { 1354 // Nontrivial default constructor with no initializer list. It may still 1355 // have bases classes and/or contain non-static data members which require 1356 // construction. 1357 for (CXXRecordDecl::base_class_const_iterator Base = 1358 ClassDecl->bases_begin(); 1359 Base != ClassDecl->bases_end(); ++Base) { 1360 // FIXME. copy assignment of virtual base NYI 1361 if (Base->isVirtual()) 1362 continue; 1363 1364 CXXRecordDecl *BaseClassDecl 1365 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1366 if (BaseClassDecl->hasTrivialConstructor()) 1367 continue; 1368 if (CXXConstructorDecl *BaseCX = 1369 BaseClassDecl->getDefaultConstructor(getContext())) { 1370 LoadOfThis = LoadCXXThis(); 1371 llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl, 1372 BaseClassDecl); 1373 EmitCXXConstructorCall(BaseCX, Ctor_Complete, V, 0, 0); 1374 } 1375 } 1376 1377 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1378 FieldEnd = ClassDecl->field_end(); 1379 Field != FieldEnd; ++Field) { 1380 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1381 const ConstantArrayType *Array = 1382 getContext().getAsConstantArrayType(FieldType); 1383 if (Array) 1384 FieldType = getContext().getBaseElementType(FieldType); 1385 if (!FieldType->getAs<RecordType>() || Field->isAnonymousStructOrUnion()) 1386 continue; 1387 const RecordType *ClassRec = FieldType->getAs<RecordType>(); 1388 CXXRecordDecl *MemberClassDecl = 1389 dyn_cast<CXXRecordDecl>(ClassRec->getDecl()); 1390 if (!MemberClassDecl || MemberClassDecl->hasTrivialConstructor()) 1391 continue; 1392 if (CXXConstructorDecl *MamberCX = 1393 MemberClassDecl->getDefaultConstructor(getContext())) { 1394 LoadOfThis = LoadCXXThis(); 1395 LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0); 1396 if (Array) { 1397 const llvm::Type *BasePtr = ConvertType(FieldType); 1398 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1399 llvm::Value *BaseAddrPtr = 1400 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1401 EmitCXXAggrConstructorCall(MamberCX, Array, BaseAddrPtr); 1402 } 1403 else 1404 EmitCXXConstructorCall(MamberCX, Ctor_Complete, LHS.getAddress(), 1405 0, 0); 1406 } 1407 } 1408 } 1409 1410 // Initialize the vtable pointer 1411 if (ClassDecl->isDynamicClass()) { 1412 if (!LoadOfThis) 1413 LoadOfThis = LoadCXXThis(); 1414 llvm::Value *VtableField; 1415 llvm::Type *Ptr8Ty, *PtrPtr8Ty; 1416 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0); 1417 PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0); 1418 VtableField = Builder.CreateBitCast(LoadOfThis, PtrPtr8Ty); 1419 llvm::Value *vtable = GenerateVtable(ClassDecl); 1420 Builder.CreateStore(vtable, VtableField); 1421 } 1422} 1423 1424/// EmitDtorEpilogue - Emit all code that comes at the end of class's 1425/// destructor. This is to call destructors on members and base classes 1426/// in reverse order of their construction. 1427void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD) { 1428 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext()); 1429 assert(!ClassDecl->isPolymorphic() && 1430 "FIXME. polymorphic destruction not supported"); 1431 (void)ClassDecl; // prevent warning. 1432 1433 for (CXXDestructorDecl::destr_const_iterator *B = DD->destr_begin(), 1434 *E = DD->destr_end(); B != E; ++B) { 1435 uintptr_t BaseOrMember = (*B); 1436 if (DD->isMemberToDestroy(BaseOrMember)) { 1437 FieldDecl *FD = DD->getMemberToDestroy(BaseOrMember); 1438 QualType FieldType = getContext().getCanonicalType((FD)->getType()); 1439 const ConstantArrayType *Array = 1440 getContext().getAsConstantArrayType(FieldType); 1441 if (Array) 1442 FieldType = getContext().getBaseElementType(FieldType); 1443 const RecordType *RT = FieldType->getAs<RecordType>(); 1444 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1445 if (FieldClassDecl->hasTrivialDestructor()) 1446 continue; 1447 llvm::Value *LoadOfThis = LoadCXXThis(); 1448 LValue LHS = EmitLValueForField(LoadOfThis, FD, false, 0); 1449 if (Array) { 1450 const llvm::Type *BasePtr = ConvertType(FieldType); 1451 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1452 llvm::Value *BaseAddrPtr = 1453 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1454 EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()), 1455 Array, BaseAddrPtr); 1456 } 1457 else 1458 EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()), 1459 Dtor_Complete, LHS.getAddress()); 1460 } else { 1461 const RecordType *RT = 1462 DD->getAnyBaseClassToDestroy(BaseOrMember)->getAs<RecordType>(); 1463 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1464 if (BaseClassDecl->hasTrivialDestructor()) 1465 continue; 1466 llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(), 1467 ClassDecl,BaseClassDecl); 1468 EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()), 1469 Dtor_Complete, V); 1470 } 1471 } 1472 if (DD->getNumBaseOrMemberDestructions() || DD->isTrivial()) 1473 return; 1474 // Case of destructor synthesis with fields and base classes 1475 // which have non-trivial destructors. They must be destructed in 1476 // reverse order of their construction. 1477 llvm::SmallVector<FieldDecl *, 16> DestructedFields; 1478 1479 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 1480 FieldEnd = ClassDecl->field_end(); 1481 Field != FieldEnd; ++Field) { 1482 QualType FieldType = getContext().getCanonicalType((*Field)->getType()); 1483 if (getContext().getAsConstantArrayType(FieldType)) 1484 FieldType = getContext().getBaseElementType(FieldType); 1485 if (const RecordType *RT = FieldType->getAs<RecordType>()) { 1486 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1487 if (FieldClassDecl->hasTrivialDestructor()) 1488 continue; 1489 DestructedFields.push_back(*Field); 1490 } 1491 } 1492 if (!DestructedFields.empty()) 1493 for (int i = DestructedFields.size() -1; i >= 0; --i) { 1494 FieldDecl *Field = DestructedFields[i]; 1495 QualType FieldType = Field->getType(); 1496 const ConstantArrayType *Array = 1497 getContext().getAsConstantArrayType(FieldType); 1498 if (Array) 1499 FieldType = getContext().getBaseElementType(FieldType); 1500 const RecordType *RT = FieldType->getAs<RecordType>(); 1501 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 1502 llvm::Value *LoadOfThis = LoadCXXThis(); 1503 LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0); 1504 if (Array) { 1505 const llvm::Type *BasePtr = ConvertType(FieldType); 1506 BasePtr = llvm::PointerType::getUnqual(BasePtr); 1507 llvm::Value *BaseAddrPtr = 1508 Builder.CreateBitCast(LHS.getAddress(), BasePtr); 1509 EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()), 1510 Array, BaseAddrPtr); 1511 } 1512 else 1513 EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()), 1514 Dtor_Complete, LHS.getAddress()); 1515 } 1516 1517 llvm::SmallVector<CXXRecordDecl*, 4> DestructedBases; 1518 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 1519 Base != ClassDecl->bases_end(); ++Base) { 1520 // FIXME. copy assignment of virtual base NYI 1521 if (Base->isVirtual()) 1522 continue; 1523 1524 CXXRecordDecl *BaseClassDecl 1525 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 1526 if (BaseClassDecl->hasTrivialDestructor()) 1527 continue; 1528 DestructedBases.push_back(BaseClassDecl); 1529 } 1530 if (DestructedBases.empty()) 1531 return; 1532 for (int i = DestructedBases.size() -1; i >= 0; --i) { 1533 CXXRecordDecl *BaseClassDecl = DestructedBases[i]; 1534 llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(), 1535 ClassDecl,BaseClassDecl); 1536 EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()), 1537 Dtor_Complete, V); 1538 } 1539} 1540 1541void CodeGenFunction::SynthesizeDefaultDestructor(const CXXDestructorDecl *CD, 1542 const FunctionDecl *FD, 1543 llvm::Function *Fn, 1544 const FunctionArgList &Args) { 1545 1546 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 1547 assert(!ClassDecl->hasUserDeclaredDestructor() && 1548 "SynthesizeDefaultDestructor - destructor has user declaration"); 1549 (void) ClassDecl; 1550 1551 StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation()); 1552 EmitDtorEpilogue(CD); 1553 FinishFunction(); 1554} 1555