1 //===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This contains code dealing with C++ code generation of virtual tables. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CodeGenModule.h" 15 #include "CodeGenFunction.h" 16 #include "CGCXXABI.h" 17 #include "clang/AST/CXXInheritance.h" 18 #include "clang/AST/RecordLayout.h" 19 #include "clang/Frontend/CodeGenOptions.h" 20 #include "llvm/ADT/DenseSet.h" 21 #include "llvm/ADT/SetVector.h" 22 #include "llvm/Support/Compiler.h" 23 #include "llvm/Support/Format.h" 24 #include "llvm/Transforms/Utils/Cloning.h" 25 #include <algorithm> 26 #include <cstdio> 27 28 using namespace clang; 29 using namespace CodeGen; 30 31 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM) 32 : CGM(CGM), VTContext(CGM.getContext()) { } 33 34 bool CodeGenVTables::ShouldEmitVTableInThisTU(const CXXRecordDecl *RD) { 35 assert(RD->isDynamicClass() && "Non dynamic classes have no VTable."); 36 37 TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind(); 38 if (TSK == TSK_ExplicitInstantiationDeclaration) 39 return false; 40 41 const CXXMethodDecl *KeyFunction = CGM.getContext().getKeyFunction(RD); 42 if (!KeyFunction) 43 return true; 44 45 // Itanium C++ ABI, 5.2.6 Instantiated Templates: 46 // An instantiation of a class template requires: 47 // - In the object where instantiated, the virtual table... 48 if (TSK == TSK_ImplicitInstantiation || 49 TSK == TSK_ExplicitInstantiationDefinition) 50 return true; 51 52 // If we're building with optimization, we always emit VTables since that 53 // allows for virtual function calls to be devirtualized. 54 // (We don't want to do this in -fapple-kext mode however). 55 if (CGM.getCodeGenOpts().OptimizationLevel && !CGM.getLangOptions().AppleKext) 56 return true; 57 58 return KeyFunction->hasBody(); 59 } 60 61 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD, 62 const ThunkInfo &Thunk) { 63 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 64 65 // Compute the mangled name. 66 llvm::SmallString<256> Name; 67 llvm::raw_svector_ostream Out(Name); 68 if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD)) 69 getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(), 70 Thunk.This, Out); 71 else 72 getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out); 73 Out.flush(); 74 75 llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD); 76 return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true); 77 } 78 79 static llvm::Value *PerformTypeAdjustment(CodeGenFunction &CGF, 80 llvm::Value *Ptr, 81 int64_t NonVirtualAdjustment, 82 int64_t VirtualAdjustment) { 83 if (!NonVirtualAdjustment && !VirtualAdjustment) 84 return Ptr; 85 86 llvm::Type *Int8PtrTy = 87 llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 88 89 llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy); 90 91 if (NonVirtualAdjustment) { 92 // Do the non-virtual adjustment. 93 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment); 94 } 95 96 if (VirtualAdjustment) { 97 llvm::Type *PtrDiffTy = 98 CGF.ConvertType(CGF.getContext().getPointerDiffType()); 99 100 // Do the virtual adjustment. 101 llvm::Value *VTablePtrPtr = 102 CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo()); 103 104 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr); 105 106 llvm::Value *OffsetPtr = 107 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment); 108 109 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo()); 110 111 // Load the adjustment offset from the vtable. 112 llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr); 113 114 // Adjust our pointer. 115 V = CGF.Builder.CreateInBoundsGEP(V, Offset); 116 } 117 118 // Cast back to the original type. 119 return CGF.Builder.CreateBitCast(V, Ptr->getType()); 120 } 121 122 static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD, 123 const ThunkInfo &Thunk, llvm::Function *Fn) { 124 CGM.setGlobalVisibility(Fn, MD); 125 126 if (!CGM.getCodeGenOpts().HiddenWeakVTables) 127 return; 128 129 // If the thunk has weak/linkonce linkage, but the function must be 130 // emitted in every translation unit that references it, then we can 131 // emit its thunks with hidden visibility, since its thunks must be 132 // emitted when the function is. 133 134 // This follows CodeGenModule::setTypeVisibility; see the comments 135 // there for explanation. 136 137 if ((Fn->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage && 138 Fn->getLinkage() != llvm::GlobalVariable::WeakODRLinkage) || 139 Fn->getVisibility() != llvm::GlobalVariable::DefaultVisibility) 140 return; 141 142 if (MD->getExplicitVisibility()) 143 return; 144 145 switch (MD->getTemplateSpecializationKind()) { 146 case TSK_ExplicitInstantiationDefinition: 147 case TSK_ExplicitInstantiationDeclaration: 148 return; 149 150 case TSK_Undeclared: 151 break; 152 153 case TSK_ExplicitSpecialization: 154 case TSK_ImplicitInstantiation: 155 if (!CGM.getCodeGenOpts().HiddenWeakTemplateVTables) 156 return; 157 break; 158 } 159 160 // If there's an explicit definition, and that definition is 161 // out-of-line, then we can't assume that all users will have a 162 // definition to emit. 163 const FunctionDecl *Def = 0; 164 if (MD->hasBody(Def) && Def->isOutOfLine()) 165 return; 166 167 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility); 168 } 169 170 #ifndef NDEBUG 171 static bool similar(const ABIArgInfo &infoL, CanQualType typeL, 172 const ABIArgInfo &infoR, CanQualType typeR) { 173 return (infoL.getKind() == infoR.getKind() && 174 (typeL == typeR || 175 (isa<PointerType>(typeL) && isa<PointerType>(typeR)) || 176 (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR)))); 177 } 178 #endif 179 180 static RValue PerformReturnAdjustment(CodeGenFunction &CGF, 181 QualType ResultType, RValue RV, 182 const ThunkInfo &Thunk) { 183 // Emit the return adjustment. 184 bool NullCheckValue = !ResultType->isReferenceType(); 185 186 llvm::BasicBlock *AdjustNull = 0; 187 llvm::BasicBlock *AdjustNotNull = 0; 188 llvm::BasicBlock *AdjustEnd = 0; 189 190 llvm::Value *ReturnValue = RV.getScalarVal(); 191 192 if (NullCheckValue) { 193 AdjustNull = CGF.createBasicBlock("adjust.null"); 194 AdjustNotNull = CGF.createBasicBlock("adjust.notnull"); 195 AdjustEnd = CGF.createBasicBlock("adjust.end"); 196 197 llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue); 198 CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull); 199 CGF.EmitBlock(AdjustNotNull); 200 } 201 202 ReturnValue = PerformTypeAdjustment(CGF, ReturnValue, 203 Thunk.Return.NonVirtual, 204 Thunk.Return.VBaseOffsetOffset); 205 206 if (NullCheckValue) { 207 CGF.Builder.CreateBr(AdjustEnd); 208 CGF.EmitBlock(AdjustNull); 209 CGF.Builder.CreateBr(AdjustEnd); 210 CGF.EmitBlock(AdjustEnd); 211 212 llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2); 213 PHI->addIncoming(ReturnValue, AdjustNotNull); 214 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()), 215 AdjustNull); 216 ReturnValue = PHI; 217 } 218 219 return RValue::get(ReturnValue); 220 } 221 222 // This function does roughly the same thing as GenerateThunk, but in a 223 // very different way, so that va_start and va_end work correctly. 224 // FIXME: This function assumes "this" is the first non-sret LLVM argument of 225 // a function, and that there is an alloca built in the entry block 226 // for all accesses to "this". 227 // FIXME: This function assumes there is only one "ret" statement per function. 228 // FIXME: Cloning isn't correct in the presence of indirect goto! 229 // FIXME: This implementation of thunks bloats codesize by duplicating the 230 // function definition. There are alternatives: 231 // 1. Add some sort of stub support to LLVM for cases where we can 232 // do a this adjustment, then a sibcall. 233 // 2. We could transform the definition to take a va_list instead of an 234 // actual variable argument list, then have the thunks (including a 235 // no-op thunk for the regular definition) call va_start/va_end. 236 // There's a bit of per-call overhead for this solution, but it's 237 // better for codesize if the definition is long. 238 void CodeGenFunction::GenerateVarArgsThunk( 239 llvm::Function *Fn, 240 const CGFunctionInfo &FnInfo, 241 GlobalDecl GD, const ThunkInfo &Thunk) { 242 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 243 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); 244 QualType ResultType = FPT->getResultType(); 245 246 // Get the original function 247 llvm::Type *Ty = 248 CGM.getTypes().GetFunctionType(FnInfo, /*IsVariadic*/true); 249 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); 250 llvm::Function *BaseFn = cast<llvm::Function>(Callee); 251 252 // Clone to thunk. 253 llvm::Function *NewFn = llvm::CloneFunction(BaseFn); 254 CGM.getModule().getFunctionList().push_back(NewFn); 255 Fn->replaceAllUsesWith(NewFn); 256 NewFn->takeName(Fn); 257 Fn->eraseFromParent(); 258 Fn = NewFn; 259 260 // "Initialize" CGF (minimally). 261 CurFn = Fn; 262 263 // Get the "this" value 264 llvm::Function::arg_iterator AI = Fn->arg_begin(); 265 if (CGM.ReturnTypeUsesSRet(FnInfo)) 266 ++AI; 267 268 // Find the first store of "this", which will be to the alloca associated 269 // with "this". 270 llvm::Value *ThisPtr = &*AI; 271 llvm::BasicBlock *EntryBB = Fn->begin(); 272 llvm::Instruction *ThisStore = 0; 273 for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end(); 274 I != E; I++) { 275 if (isa<llvm::StoreInst>(I) && I->getOperand(0) == ThisPtr) { 276 ThisStore = cast<llvm::StoreInst>(I); 277 break; 278 } 279 } 280 assert(ThisStore && "Store of this should be in entry block?"); 281 // Adjust "this", if necessary. 282 Builder.SetInsertPoint(ThisStore); 283 llvm::Value *AdjustedThisPtr = 284 PerformTypeAdjustment(*this, ThisPtr, 285 Thunk.This.NonVirtual, 286 Thunk.This.VCallOffsetOffset); 287 ThisStore->setOperand(0, AdjustedThisPtr); 288 289 if (!Thunk.Return.isEmpty()) { 290 // Fix up the returned value, if necessary. 291 for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) { 292 llvm::Instruction *T = I->getTerminator(); 293 if (isa<llvm::ReturnInst>(T)) { 294 RValue RV = RValue::get(T->getOperand(0)); 295 T->eraseFromParent(); 296 Builder.SetInsertPoint(&*I); 297 RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk); 298 Builder.CreateRet(RV.getScalarVal()); 299 break; 300 } 301 } 302 } 303 } 304 305 void CodeGenFunction::GenerateThunk(llvm::Function *Fn, 306 const CGFunctionInfo &FnInfo, 307 GlobalDecl GD, const ThunkInfo &Thunk) { 308 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 309 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); 310 QualType ResultType = FPT->getResultType(); 311 QualType ThisType = MD->getThisType(getContext()); 312 313 FunctionArgList FunctionArgs; 314 315 // FIXME: It would be nice if more of this code could be shared with 316 // CodeGenFunction::GenerateCode. 317 318 // Create the implicit 'this' parameter declaration. 319 CurGD = GD; 320 CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResultType, FunctionArgs); 321 322 // Add the rest of the parameters. 323 for (FunctionDecl::param_const_iterator I = MD->param_begin(), 324 E = MD->param_end(); I != E; ++I) { 325 ParmVarDecl *Param = *I; 326 327 FunctionArgs.push_back(Param); 328 } 329 330 StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs, 331 SourceLocation()); 332 333 CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 334 335 // Adjust the 'this' pointer if necessary. 336 llvm::Value *AdjustedThisPtr = 337 PerformTypeAdjustment(*this, LoadCXXThis(), 338 Thunk.This.NonVirtual, 339 Thunk.This.VCallOffsetOffset); 340 341 CallArgList CallArgs; 342 343 // Add our adjusted 'this' pointer. 344 CallArgs.add(RValue::get(AdjustedThisPtr), ThisType); 345 346 // Add the rest of the parameters. 347 for (FunctionDecl::param_const_iterator I = MD->param_begin(), 348 E = MD->param_end(); I != E; ++I) { 349 ParmVarDecl *param = *I; 350 EmitDelegateCallArg(CallArgs, param); 351 } 352 353 // Get our callee. 354 llvm::Type *Ty = 355 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(GD), 356 FPT->isVariadic()); 357 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); 358 359 #ifndef NDEBUG 360 const CGFunctionInfo &CallFnInfo = 361 CGM.getTypes().getFunctionInfo(ResultType, CallArgs, FPT->getExtInfo()); 362 assert(CallFnInfo.getRegParm() == FnInfo.getRegParm() && 363 CallFnInfo.isNoReturn() == FnInfo.isNoReturn() && 364 CallFnInfo.getCallingConvention() == FnInfo.getCallingConvention()); 365 assert(similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(), 366 FnInfo.getReturnInfo(), FnInfo.getReturnType())); 367 assert(CallFnInfo.arg_size() == FnInfo.arg_size()); 368 for (unsigned i = 0, e = FnInfo.arg_size(); i != e; ++i) 369 assert(similar(CallFnInfo.arg_begin()[i].info, 370 CallFnInfo.arg_begin()[i].type, 371 FnInfo.arg_begin()[i].info, FnInfo.arg_begin()[i].type)); 372 #endif 373 374 // Determine whether we have a return value slot to use. 375 ReturnValueSlot Slot; 376 if (!ResultType->isVoidType() && 377 FnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect && 378 hasAggregateLLVMType(CurFnInfo->getReturnType())) 379 Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified()); 380 381 // Now emit our call. 382 RValue RV = EmitCall(FnInfo, Callee, Slot, CallArgs, MD); 383 384 if (!Thunk.Return.isEmpty()) 385 RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk); 386 387 if (!ResultType->isVoidType() && Slot.isNull()) 388 CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType); 389 390 FinishFunction(); 391 392 // Set the right linkage. 393 CGM.setFunctionLinkage(MD, Fn); 394 395 // Set the right visibility. 396 setThunkVisibility(CGM, MD, Thunk, Fn); 397 } 398 399 void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk, 400 bool UseAvailableExternallyLinkage) 401 { 402 const CGFunctionInfo &FnInfo = CGM.getTypes().getFunctionInfo(GD); 403 404 // FIXME: re-use FnInfo in this computation. 405 llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk); 406 407 // Strip off a bitcast if we got one back. 408 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 409 assert(CE->getOpcode() == llvm::Instruction::BitCast); 410 Entry = CE->getOperand(0); 411 } 412 413 // There's already a declaration with the same name, check if it has the same 414 // type or if we need to replace it. 415 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != 416 CGM.getTypes().GetFunctionTypeForVTable(GD)) { 417 llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry); 418 419 // If the types mismatch then we have to rewrite the definition. 420 assert(OldThunkFn->isDeclaration() && 421 "Shouldn't replace non-declaration"); 422 423 // Remove the name from the old thunk function and get a new thunk. 424 OldThunkFn->setName(StringRef()); 425 Entry = CGM.GetAddrOfThunk(GD, Thunk); 426 427 // If needed, replace the old thunk with a bitcast. 428 if (!OldThunkFn->use_empty()) { 429 llvm::Constant *NewPtrForOldDecl = 430 llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType()); 431 OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl); 432 } 433 434 // Remove the old thunk. 435 OldThunkFn->eraseFromParent(); 436 } 437 438 llvm::Function *ThunkFn = cast<llvm::Function>(Entry); 439 440 if (!ThunkFn->isDeclaration()) { 441 if (UseAvailableExternallyLinkage) { 442 // There is already a thunk emitted for this function, do nothing. 443 return; 444 } 445 446 // If a function has a body, it should have available_externally linkage. 447 assert(ThunkFn->hasAvailableExternallyLinkage() && 448 "Function should have available_externally linkage!"); 449 450 // Change the linkage. 451 CGM.setFunctionLinkage(cast<CXXMethodDecl>(GD.getDecl()), ThunkFn); 452 return; 453 } 454 455 if (ThunkFn->isVarArg()) { 456 // Varargs thunks are special; we can't just generate a call because 457 // we can't copy the varargs. Our implementation is rather 458 // expensive/sucky at the moment, so don't generate the thunk unless 459 // we have to. 460 // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly. 461 if (!UseAvailableExternallyLinkage) 462 CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); 463 } else { 464 // Normal thunk body generation. 465 CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk); 466 } 467 468 if (UseAvailableExternallyLinkage) 469 ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage); 470 } 471 472 void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD, 473 const ThunkInfo &Thunk) { 474 // We only want to do this when building with optimizations. 475 if (!CGM.getCodeGenOpts().OptimizationLevel) 476 return; 477 478 // We can't emit thunks for member functions with incomplete types. 479 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 480 if (!CGM.getTypes().isFuncTypeConvertible( 481 cast<FunctionType>(MD->getType().getTypePtr()))) 482 return; 483 484 EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true); 485 } 486 487 void CodeGenVTables::EmitThunks(GlobalDecl GD) 488 { 489 const CXXMethodDecl *MD = 490 cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl(); 491 492 // We don't need to generate thunks for the base destructor. 493 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base) 494 return; 495 496 const VTableContext::ThunkInfoVectorTy *ThunkInfoVector = 497 VTContext.getThunkInfo(MD); 498 if (!ThunkInfoVector) 499 return; 500 501 for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I) 502 EmitThunk(GD, (*ThunkInfoVector)[I], 503 /*UseAvailableExternallyLinkage=*/false); 504 } 505 506 llvm::Constant * 507 CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD, 508 const VTableComponent *Components, 509 unsigned NumComponents, 510 const VTableLayout::VTableThunkTy *VTableThunks, 511 unsigned NumVTableThunks) { 512 SmallVector<llvm::Constant *, 64> Inits; 513 514 llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext()); 515 516 llvm::Type *PtrDiffTy = 517 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); 518 519 QualType ClassType = CGM.getContext().getTagDeclType(RD); 520 llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType); 521 522 unsigned NextVTableThunkIndex = 0; 523 524 llvm::Constant* PureVirtualFn = 0; 525 526 for (unsigned I = 0; I != NumComponents; ++I) { 527 VTableComponent Component = Components[I]; 528 529 llvm::Constant *Init = 0; 530 531 switch (Component.getKind()) { 532 case VTableComponent::CK_VCallOffset: 533 Init = llvm::ConstantInt::get(PtrDiffTy, 534 Component.getVCallOffset().getQuantity()); 535 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); 536 break; 537 case VTableComponent::CK_VBaseOffset: 538 Init = llvm::ConstantInt::get(PtrDiffTy, 539 Component.getVBaseOffset().getQuantity()); 540 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); 541 break; 542 case VTableComponent::CK_OffsetToTop: 543 Init = llvm::ConstantInt::get(PtrDiffTy, 544 Component.getOffsetToTop().getQuantity()); 545 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); 546 break; 547 case VTableComponent::CK_RTTI: 548 Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy); 549 break; 550 case VTableComponent::CK_FunctionPointer: 551 case VTableComponent::CK_CompleteDtorPointer: 552 case VTableComponent::CK_DeletingDtorPointer: { 553 GlobalDecl GD; 554 555 // Get the right global decl. 556 switch (Component.getKind()) { 557 default: 558 llvm_unreachable("Unexpected vtable component kind"); 559 case VTableComponent::CK_FunctionPointer: 560 GD = Component.getFunctionDecl(); 561 break; 562 case VTableComponent::CK_CompleteDtorPointer: 563 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete); 564 break; 565 case VTableComponent::CK_DeletingDtorPointer: 566 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting); 567 break; 568 } 569 570 if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) { 571 // We have a pure virtual member function. 572 if (!PureVirtualFn) { 573 llvm::FunctionType *Ty = 574 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()), 575 /*isVarArg=*/false); 576 PureVirtualFn = 577 CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual"); 578 PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn, 579 Int8PtrTy); 580 } 581 582 Init = PureVirtualFn; 583 } else { 584 // Check if we should use a thunk. 585 if (NextVTableThunkIndex < NumVTableThunks && 586 VTableThunks[NextVTableThunkIndex].first == I) { 587 const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second; 588 589 Init = CGM.GetAddrOfThunk(GD, Thunk); 590 MaybeEmitThunkAvailableExternally(GD, Thunk); 591 592 NextVTableThunkIndex++; 593 } else { 594 llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD); 595 596 Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); 597 } 598 599 Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy); 600 } 601 break; 602 } 603 604 case VTableComponent::CK_UnusedFunctionPointer: 605 Init = llvm::ConstantExpr::getNullValue(Int8PtrTy); 606 break; 607 }; 608 609 Inits.push_back(Init); 610 } 611 612 llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents); 613 return llvm::ConstantArray::get(ArrayType, Inits); 614 } 615 616 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) { 617 llvm::GlobalVariable *&VTable = VTables[RD]; 618 if (VTable) 619 return VTable; 620 621 // We may need to generate a definition for this vtable. 622 if (ShouldEmitVTableInThisTU(RD)) 623 CGM.DeferredVTables.push_back(RD); 624 625 llvm::SmallString<256> OutName; 626 llvm::raw_svector_ostream Out(OutName); 627 CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out); 628 Out.flush(); 629 StringRef Name = OutName.str(); 630 631 llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext()); 632 llvm::ArrayType *ArrayType = 633 llvm::ArrayType::get(Int8PtrTy, 634 VTContext.getVTableLayout(RD).getNumVTableComponents()); 635 636 VTable = 637 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, 638 llvm::GlobalValue::ExternalLinkage); 639 VTable->setUnnamedAddr(true); 640 return VTable; 641 } 642 643 void 644 CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable, 645 llvm::GlobalVariable::LinkageTypes Linkage, 646 const CXXRecordDecl *RD) { 647 const VTableLayout &VTLayout = VTContext.getVTableLayout(RD); 648 649 // Create and set the initializer. 650 llvm::Constant *Init = 651 CreateVTableInitializer(RD, 652 VTLayout.vtable_component_begin(), 653 VTLayout.getNumVTableComponents(), 654 VTLayout.vtable_thunk_begin(), 655 VTLayout.getNumVTableThunks()); 656 VTable->setInitializer(Init); 657 658 // Set the correct linkage. 659 VTable->setLinkage(Linkage); 660 661 // Set the right visibility. 662 CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable); 663 } 664 665 llvm::GlobalVariable * 666 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, 667 const BaseSubobject &Base, 668 bool BaseIsVirtual, 669 llvm::GlobalVariable::LinkageTypes Linkage, 670 VTableAddressPointsMapTy& AddressPoints) { 671 llvm::OwningPtr<VTableLayout> VTLayout( 672 VTContext.createConstructionVTableLayout(Base.getBase(), 673 Base.getBaseOffset(), 674 BaseIsVirtual, RD)); 675 676 // Add the address points. 677 AddressPoints = VTLayout->getAddressPoints(); 678 679 // Get the mangled construction vtable name. 680 llvm::SmallString<256> OutName; 681 llvm::raw_svector_ostream Out(OutName); 682 CGM.getCXXABI().getMangleContext(). 683 mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(), 684 Out); 685 Out.flush(); 686 StringRef Name = OutName.str(); 687 688 llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext()); 689 llvm::ArrayType *ArrayType = 690 llvm::ArrayType::get(Int8PtrTy, VTLayout->getNumVTableComponents()); 691 692 // Create the variable that will hold the construction vtable. 693 llvm::GlobalVariable *VTable = 694 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage); 695 CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable); 696 697 // V-tables are always unnamed_addr. 698 VTable->setUnnamedAddr(true); 699 700 // Create and set the initializer. 701 llvm::Constant *Init = 702 CreateVTableInitializer(Base.getBase(), 703 VTLayout->vtable_component_begin(), 704 VTLayout->getNumVTableComponents(), 705 VTLayout->vtable_thunk_begin(), 706 VTLayout->getNumVTableThunks()); 707 VTable->setInitializer(Init); 708 709 return VTable; 710 } 711 712 void 713 CodeGenVTables::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage, 714 const CXXRecordDecl *RD) { 715 llvm::GlobalVariable *VTable = GetAddrOfVTable(RD); 716 if (VTable->hasInitializer()) 717 return; 718 719 EmitVTableDefinition(VTable, Linkage, RD); 720 721 if (RD->getNumVBases()) { 722 llvm::GlobalVariable *VTT = GetAddrOfVTT(RD); 723 EmitVTTDefinition(VTT, Linkage, RD); 724 } 725 726 // If this is the magic class __cxxabiv1::__fundamental_type_info, 727 // we will emit the typeinfo for the fundamental types. This is the 728 // same behaviour as GCC. 729 const DeclContext *DC = RD->getDeclContext(); 730 if (RD->getIdentifier() && 731 RD->getIdentifier()->isStr("__fundamental_type_info") && 732 isa<NamespaceDecl>(DC) && 733 cast<NamespaceDecl>(DC)->getIdentifier() && 734 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") && 735 DC->getParent()->isTranslationUnit()) 736 CGM.EmitFundamentalRTTIDescriptors(); 737 } 738