VTableBuilder.cpp revision 276479
1226586Sdim//===--- VTableBuilder.cpp - C++ vtable layout builder --------------------===// 2226586Sdim// 3226586Sdim// The LLVM Compiler Infrastructure 4226586Sdim// 5226586Sdim// This file is distributed under the University of Illinois Open Source 6226586Sdim// License. See LICENSE.TXT for details. 7226586Sdim// 8226586Sdim//===----------------------------------------------------------------------===// 9226586Sdim// 10226586Sdim// This contains code dealing with generation of the layout of virtual tables. 11226586Sdim// 12226586Sdim//===----------------------------------------------------------------------===// 13226586Sdim 14226586Sdim#include "clang/AST/VTableBuilder.h" 15239462Sdim#include "clang/AST/ASTContext.h" 16226586Sdim#include "clang/AST/CXXInheritance.h" 17226586Sdim#include "clang/AST/RecordLayout.h" 18226586Sdim#include "clang/Basic/TargetInfo.h" 19276479Sdim#include "llvm/ADT/SmallPtrSet.h" 20226586Sdim#include "llvm/Support/Format.h" 21249423Sdim#include "llvm/Support/raw_ostream.h" 22226586Sdim#include <algorithm> 23226586Sdim#include <cstdio> 24226586Sdim 25226586Sdimusing namespace clang; 26226586Sdim 27226586Sdim#define DUMP_OVERRIDERS 0 28226586Sdim 29226586Sdimnamespace { 30226586Sdim 31226586Sdim/// BaseOffset - Represents an offset from a derived class to a direct or 32226586Sdim/// indirect base class. 33226586Sdimstruct BaseOffset { 34226586Sdim /// DerivedClass - The derived class. 35226586Sdim const CXXRecordDecl *DerivedClass; 36226586Sdim 37226586Sdim /// VirtualBase - If the path from the derived class to the base class 38261991Sdim /// involves virtual base classes, this holds the declaration of the last 39261991Sdim /// virtual base in this path (i.e. closest to the base class). 40226586Sdim const CXXRecordDecl *VirtualBase; 41226586Sdim 42226586Sdim /// NonVirtualOffset - The offset from the derived class to the base class. 43226586Sdim /// (Or the offset from the virtual base class to the base class, if the 44226586Sdim /// path from the derived class to the base class involves a virtual base 45226586Sdim /// class. 46226586Sdim CharUnits NonVirtualOffset; 47276479Sdim 48276479Sdim BaseOffset() : DerivedClass(nullptr), VirtualBase(nullptr), 49276479Sdim NonVirtualOffset(CharUnits::Zero()) { } 50226586Sdim BaseOffset(const CXXRecordDecl *DerivedClass, 51226586Sdim const CXXRecordDecl *VirtualBase, CharUnits NonVirtualOffset) 52226586Sdim : DerivedClass(DerivedClass), VirtualBase(VirtualBase), 53226586Sdim NonVirtualOffset(NonVirtualOffset) { } 54226586Sdim 55226586Sdim bool isEmpty() const { return NonVirtualOffset.isZero() && !VirtualBase; } 56226586Sdim}; 57226586Sdim 58226586Sdim/// FinalOverriders - Contains the final overrider member functions for all 59226586Sdim/// member functions in the base subobjects of a class. 60226586Sdimclass FinalOverriders { 61226586Sdimpublic: 62226586Sdim /// OverriderInfo - Information about a final overrider. 63226586Sdim struct OverriderInfo { 64226586Sdim /// Method - The method decl of the overrider. 65226586Sdim const CXXMethodDecl *Method; 66226586Sdim 67276479Sdim /// VirtualBase - The virtual base class subobject of this overridder. 68276479Sdim /// Note that this records the closest derived virtual base class subobject. 69276479Sdim const CXXRecordDecl *VirtualBase; 70276479Sdim 71261991Sdim /// Offset - the base offset of the overrider's parent in the layout class. 72226586Sdim CharUnits Offset; 73276479Sdim 74276479Sdim OverriderInfo() : Method(nullptr), VirtualBase(nullptr), 75276479Sdim Offset(CharUnits::Zero()) { } 76226586Sdim }; 77226586Sdim 78226586Sdimprivate: 79226586Sdim /// MostDerivedClass - The most derived class for which the final overriders 80226586Sdim /// are stored. 81226586Sdim const CXXRecordDecl *MostDerivedClass; 82226586Sdim 83226586Sdim /// MostDerivedClassOffset - If we're building final overriders for a 84226586Sdim /// construction vtable, this holds the offset from the layout class to the 85226586Sdim /// most derived class. 86226586Sdim const CharUnits MostDerivedClassOffset; 87226586Sdim 88226586Sdim /// LayoutClass - The class we're using for layout information. Will be 89226586Sdim /// different than the most derived class if the final overriders are for a 90226586Sdim /// construction vtable. 91226586Sdim const CXXRecordDecl *LayoutClass; 92226586Sdim 93226586Sdim ASTContext &Context; 94226586Sdim 95226586Sdim /// MostDerivedClassLayout - the AST record layout of the most derived class. 96226586Sdim const ASTRecordLayout &MostDerivedClassLayout; 97226586Sdim 98226586Sdim /// MethodBaseOffsetPairTy - Uniquely identifies a member function 99226586Sdim /// in a base subobject. 100226586Sdim typedef std::pair<const CXXMethodDecl *, CharUnits> MethodBaseOffsetPairTy; 101226586Sdim 102226586Sdim typedef llvm::DenseMap<MethodBaseOffsetPairTy, 103226586Sdim OverriderInfo> OverridersMapTy; 104226586Sdim 105226586Sdim /// OverridersMap - The final overriders for all virtual member functions of 106226586Sdim /// all the base subobjects of the most derived class. 107226586Sdim OverridersMapTy OverridersMap; 108226586Sdim 109226586Sdim /// SubobjectsToOffsetsMapTy - A mapping from a base subobject (represented 110226586Sdim /// as a record decl and a subobject number) and its offsets in the most 111226586Sdim /// derived class as well as the layout class. 112226586Sdim typedef llvm::DenseMap<std::pair<const CXXRecordDecl *, unsigned>, 113226586Sdim CharUnits> SubobjectOffsetMapTy; 114226586Sdim 115226586Sdim typedef llvm::DenseMap<const CXXRecordDecl *, unsigned> SubobjectCountMapTy; 116226586Sdim 117226586Sdim /// ComputeBaseOffsets - Compute the offsets for all base subobjects of the 118226586Sdim /// given base. 119226586Sdim void ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual, 120226586Sdim CharUnits OffsetInLayoutClass, 121226586Sdim SubobjectOffsetMapTy &SubobjectOffsets, 122226586Sdim SubobjectOffsetMapTy &SubobjectLayoutClassOffsets, 123226586Sdim SubobjectCountMapTy &SubobjectCounts); 124226586Sdim 125226586Sdim typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy; 126226586Sdim 127226586Sdim /// dump - dump the final overriders for a base subobject, and all its direct 128226586Sdim /// and indirect base subobjects. 129226586Sdim void dump(raw_ostream &Out, BaseSubobject Base, 130226586Sdim VisitedVirtualBasesSetTy& VisitedVirtualBases); 131226586Sdim 132226586Sdimpublic: 133226586Sdim FinalOverriders(const CXXRecordDecl *MostDerivedClass, 134226586Sdim CharUnits MostDerivedClassOffset, 135226586Sdim const CXXRecordDecl *LayoutClass); 136226586Sdim 137226586Sdim /// getOverrider - Get the final overrider for the given method declaration in 138226586Sdim /// the subobject with the given base offset. 139226586Sdim OverriderInfo getOverrider(const CXXMethodDecl *MD, 140226586Sdim CharUnits BaseOffset) const { 141226586Sdim assert(OverridersMap.count(std::make_pair(MD, BaseOffset)) && 142226586Sdim "Did not find overrider!"); 143226586Sdim 144226586Sdim return OverridersMap.lookup(std::make_pair(MD, BaseOffset)); 145226586Sdim } 146226586Sdim 147226586Sdim /// dump - dump the final overriders. 148226586Sdim void dump() { 149226586Sdim VisitedVirtualBasesSetTy VisitedVirtualBases; 150226586Sdim dump(llvm::errs(), BaseSubobject(MostDerivedClass, CharUnits::Zero()), 151226586Sdim VisitedVirtualBases); 152226586Sdim } 153226586Sdim 154226586Sdim}; 155226586Sdim 156226586SdimFinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass, 157226586Sdim CharUnits MostDerivedClassOffset, 158226586Sdim const CXXRecordDecl *LayoutClass) 159226586Sdim : MostDerivedClass(MostDerivedClass), 160226586Sdim MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass), 161226586Sdim Context(MostDerivedClass->getASTContext()), 162226586Sdim MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) { 163226586Sdim 164226586Sdim // Compute base offsets. 165226586Sdim SubobjectOffsetMapTy SubobjectOffsets; 166226586Sdim SubobjectOffsetMapTy SubobjectLayoutClassOffsets; 167226586Sdim SubobjectCountMapTy SubobjectCounts; 168226586Sdim ComputeBaseOffsets(BaseSubobject(MostDerivedClass, CharUnits::Zero()), 169226586Sdim /*IsVirtual=*/false, 170226586Sdim MostDerivedClassOffset, 171226586Sdim SubobjectOffsets, SubobjectLayoutClassOffsets, 172226586Sdim SubobjectCounts); 173226586Sdim 174239462Sdim // Get the final overriders. 175226586Sdim CXXFinalOverriderMap FinalOverriders; 176226586Sdim MostDerivedClass->getFinalOverriders(FinalOverriders); 177226586Sdim 178226586Sdim for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(), 179226586Sdim E = FinalOverriders.end(); I != E; ++I) { 180226586Sdim const CXXMethodDecl *MD = I->first; 181226586Sdim const OverridingMethods& Methods = I->second; 182226586Sdim 183226586Sdim for (OverridingMethods::const_iterator I = Methods.begin(), 184226586Sdim E = Methods.end(); I != E; ++I) { 185226586Sdim unsigned SubobjectNumber = I->first; 186226586Sdim assert(SubobjectOffsets.count(std::make_pair(MD->getParent(), 187226586Sdim SubobjectNumber)) && 188226586Sdim "Did not find subobject offset!"); 189226586Sdim 190226586Sdim CharUnits BaseOffset = SubobjectOffsets[std::make_pair(MD->getParent(), 191226586Sdim SubobjectNumber)]; 192226586Sdim 193226586Sdim assert(I->second.size() == 1 && "Final overrider is not unique!"); 194226586Sdim const UniqueVirtualMethod &Method = I->second.front(); 195226586Sdim 196226586Sdim const CXXRecordDecl *OverriderRD = Method.Method->getParent(); 197226586Sdim assert(SubobjectLayoutClassOffsets.count( 198226586Sdim std::make_pair(OverriderRD, Method.Subobject)) 199226586Sdim && "Did not find subobject offset!"); 200226586Sdim CharUnits OverriderOffset = 201226586Sdim SubobjectLayoutClassOffsets[std::make_pair(OverriderRD, 202226586Sdim Method.Subobject)]; 203226586Sdim 204226586Sdim OverriderInfo& Overrider = OverridersMap[std::make_pair(MD, BaseOffset)]; 205226586Sdim assert(!Overrider.Method && "Overrider should not exist yet!"); 206226586Sdim 207226586Sdim Overrider.Offset = OverriderOffset; 208226586Sdim Overrider.Method = Method.Method; 209276479Sdim Overrider.VirtualBase = Method.InVirtualSubobject; 210226586Sdim } 211226586Sdim } 212226586Sdim 213226586Sdim#if DUMP_OVERRIDERS 214226586Sdim // And dump them (for now). 215226586Sdim dump(); 216226586Sdim#endif 217226586Sdim} 218226586Sdim 219226586Sdimstatic BaseOffset ComputeBaseOffset(ASTContext &Context, 220226586Sdim const CXXRecordDecl *DerivedRD, 221226586Sdim const CXXBasePath &Path) { 222226586Sdim CharUnits NonVirtualOffset = CharUnits::Zero(); 223226586Sdim 224226586Sdim unsigned NonVirtualStart = 0; 225276479Sdim const CXXRecordDecl *VirtualBase = nullptr; 226276479Sdim 227226586Sdim // First, look for the virtual base class. 228261991Sdim for (int I = Path.size(), E = 0; I != E; --I) { 229261991Sdim const CXXBasePathElement &Element = Path[I - 1]; 230261991Sdim 231226586Sdim if (Element.Base->isVirtual()) { 232261991Sdim NonVirtualStart = I; 233226586Sdim QualType VBaseType = Element.Base->getType(); 234261991Sdim VirtualBase = VBaseType->getAsCXXRecordDecl(); 235261991Sdim break; 236226586Sdim } 237226586Sdim } 238226586Sdim 239226586Sdim // Now compute the non-virtual offset. 240226586Sdim for (unsigned I = NonVirtualStart, E = Path.size(); I != E; ++I) { 241226586Sdim const CXXBasePathElement &Element = Path[I]; 242226586Sdim 243226586Sdim // Check the base class offset. 244226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(Element.Class); 245226586Sdim 246261991Sdim const CXXRecordDecl *Base = Element.Base->getType()->getAsCXXRecordDecl(); 247226586Sdim 248226586Sdim NonVirtualOffset += Layout.getBaseClassOffset(Base); 249226586Sdim } 250226586Sdim 251226586Sdim // FIXME: This should probably use CharUnits or something. Maybe we should 252226586Sdim // even change the base offsets in ASTRecordLayout to be specified in 253226586Sdim // CharUnits. 254226586Sdim return BaseOffset(DerivedRD, VirtualBase, NonVirtualOffset); 255226586Sdim 256226586Sdim} 257226586Sdim 258226586Sdimstatic BaseOffset ComputeBaseOffset(ASTContext &Context, 259226586Sdim const CXXRecordDecl *BaseRD, 260226586Sdim const CXXRecordDecl *DerivedRD) { 261226586Sdim CXXBasePaths Paths(/*FindAmbiguities=*/false, 262226586Sdim /*RecordPaths=*/true, /*DetectVirtual=*/false); 263249423Sdim 264249423Sdim if (!DerivedRD->isDerivedFrom(BaseRD, Paths)) 265226586Sdim llvm_unreachable("Class must be derived from the passed in base class!"); 266226586Sdim 267226586Sdim return ComputeBaseOffset(Context, DerivedRD, Paths.front()); 268226586Sdim} 269226586Sdim 270226586Sdimstatic BaseOffset 271226586SdimComputeReturnAdjustmentBaseOffset(ASTContext &Context, 272226586Sdim const CXXMethodDecl *DerivedMD, 273226586Sdim const CXXMethodDecl *BaseMD) { 274226586Sdim const FunctionType *BaseFT = BaseMD->getType()->getAs<FunctionType>(); 275226586Sdim const FunctionType *DerivedFT = DerivedMD->getType()->getAs<FunctionType>(); 276226586Sdim 277226586Sdim // Canonicalize the return types. 278276479Sdim CanQualType CanDerivedReturnType = 279276479Sdim Context.getCanonicalType(DerivedFT->getReturnType()); 280276479Sdim CanQualType CanBaseReturnType = 281276479Sdim Context.getCanonicalType(BaseFT->getReturnType()); 282276479Sdim 283226586Sdim assert(CanDerivedReturnType->getTypeClass() == 284226586Sdim CanBaseReturnType->getTypeClass() && 285226586Sdim "Types must have same type class!"); 286226586Sdim 287226586Sdim if (CanDerivedReturnType == CanBaseReturnType) { 288226586Sdim // No adjustment needed. 289226586Sdim return BaseOffset(); 290226586Sdim } 291226586Sdim 292226586Sdim if (isa<ReferenceType>(CanDerivedReturnType)) { 293226586Sdim CanDerivedReturnType = 294226586Sdim CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType(); 295226586Sdim CanBaseReturnType = 296226586Sdim CanBaseReturnType->getAs<ReferenceType>()->getPointeeType(); 297226586Sdim } else if (isa<PointerType>(CanDerivedReturnType)) { 298226586Sdim CanDerivedReturnType = 299226586Sdim CanDerivedReturnType->getAs<PointerType>()->getPointeeType(); 300226586Sdim CanBaseReturnType = 301226586Sdim CanBaseReturnType->getAs<PointerType>()->getPointeeType(); 302226586Sdim } else { 303226586Sdim llvm_unreachable("Unexpected return type!"); 304226586Sdim } 305226586Sdim 306226586Sdim // We need to compare unqualified types here; consider 307226586Sdim // const T *Base::foo(); 308226586Sdim // T *Derived::foo(); 309226586Sdim if (CanDerivedReturnType.getUnqualifiedType() == 310226586Sdim CanBaseReturnType.getUnqualifiedType()) { 311226586Sdim // No adjustment needed. 312226586Sdim return BaseOffset(); 313226586Sdim } 314226586Sdim 315226586Sdim const CXXRecordDecl *DerivedRD = 316226586Sdim cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl()); 317226586Sdim 318226586Sdim const CXXRecordDecl *BaseRD = 319226586Sdim cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl()); 320226586Sdim 321226586Sdim return ComputeBaseOffset(Context, BaseRD, DerivedRD); 322226586Sdim} 323226586Sdim 324226586Sdimvoid 325226586SdimFinalOverriders::ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual, 326226586Sdim CharUnits OffsetInLayoutClass, 327226586Sdim SubobjectOffsetMapTy &SubobjectOffsets, 328226586Sdim SubobjectOffsetMapTy &SubobjectLayoutClassOffsets, 329226586Sdim SubobjectCountMapTy &SubobjectCounts) { 330226586Sdim const CXXRecordDecl *RD = Base.getBase(); 331226586Sdim 332226586Sdim unsigned SubobjectNumber = 0; 333226586Sdim if (!IsVirtual) 334226586Sdim SubobjectNumber = ++SubobjectCounts[RD]; 335226586Sdim 336226586Sdim // Set up the subobject to offset mapping. 337226586Sdim assert(!SubobjectOffsets.count(std::make_pair(RD, SubobjectNumber)) 338226586Sdim && "Subobject offset already exists!"); 339226586Sdim assert(!SubobjectLayoutClassOffsets.count(std::make_pair(RD, SubobjectNumber)) 340226586Sdim && "Subobject offset already exists!"); 341226586Sdim 342226586Sdim SubobjectOffsets[std::make_pair(RD, SubobjectNumber)] = Base.getBaseOffset(); 343226586Sdim SubobjectLayoutClassOffsets[std::make_pair(RD, SubobjectNumber)] = 344226586Sdim OffsetInLayoutClass; 345226586Sdim 346226586Sdim // Traverse our bases. 347276479Sdim for (const auto &B : RD->bases()) { 348276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 349226586Sdim 350226586Sdim CharUnits BaseOffset; 351226586Sdim CharUnits BaseOffsetInLayoutClass; 352276479Sdim if (B.isVirtual()) { 353226586Sdim // Check if we've visited this virtual base before. 354226586Sdim if (SubobjectOffsets.count(std::make_pair(BaseDecl, 0))) 355226586Sdim continue; 356226586Sdim 357226586Sdim const ASTRecordLayout &LayoutClassLayout = 358226586Sdim Context.getASTRecordLayout(LayoutClass); 359226586Sdim 360226586Sdim BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl); 361226586Sdim BaseOffsetInLayoutClass = 362226586Sdim LayoutClassLayout.getVBaseClassOffset(BaseDecl); 363226586Sdim } else { 364226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 365226586Sdim CharUnits Offset = Layout.getBaseClassOffset(BaseDecl); 366226586Sdim 367226586Sdim BaseOffset = Base.getBaseOffset() + Offset; 368226586Sdim BaseOffsetInLayoutClass = OffsetInLayoutClass + Offset; 369226586Sdim } 370226586Sdim 371226586Sdim ComputeBaseOffsets(BaseSubobject(BaseDecl, BaseOffset), 372276479Sdim B.isVirtual(), BaseOffsetInLayoutClass, 373226586Sdim SubobjectOffsets, SubobjectLayoutClassOffsets, 374226586Sdim SubobjectCounts); 375226586Sdim } 376226586Sdim} 377226586Sdim 378226586Sdimvoid FinalOverriders::dump(raw_ostream &Out, BaseSubobject Base, 379226586Sdim VisitedVirtualBasesSetTy &VisitedVirtualBases) { 380226586Sdim const CXXRecordDecl *RD = Base.getBase(); 381226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 382226586Sdim 383276479Sdim for (const auto &B : RD->bases()) { 384276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 385226586Sdim 386226586Sdim // Ignore bases that don't have any virtual member functions. 387226586Sdim if (!BaseDecl->isPolymorphic()) 388226586Sdim continue; 389226586Sdim 390226586Sdim CharUnits BaseOffset; 391276479Sdim if (B.isVirtual()) { 392226586Sdim if (!VisitedVirtualBases.insert(BaseDecl)) { 393226586Sdim // We've visited this base before. 394226586Sdim continue; 395226586Sdim } 396226586Sdim 397226586Sdim BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl); 398226586Sdim } else { 399226586Sdim BaseOffset = Layout.getBaseClassOffset(BaseDecl) + Base.getBaseOffset(); 400226586Sdim } 401226586Sdim 402226586Sdim dump(Out, BaseSubobject(BaseDecl, BaseOffset), VisitedVirtualBases); 403226586Sdim } 404226586Sdim 405276479Sdim Out << "Final overriders for ("; 406276479Sdim RD->printQualifiedName(Out); 407276479Sdim Out << ", "; 408226586Sdim Out << Base.getBaseOffset().getQuantity() << ")\n"; 409226586Sdim 410226586Sdim // Now dump the overriders for this base subobject. 411276479Sdim for (const auto *MD : RD->methods()) { 412226586Sdim if (!MD->isVirtual()) 413226586Sdim continue; 414226586Sdim 415226586Sdim OverriderInfo Overrider = getOverrider(MD, Base.getBaseOffset()); 416226586Sdim 417276479Sdim Out << " "; 418276479Sdim MD->printQualifiedName(Out); 419276479Sdim Out << " - ("; 420276479Sdim Overrider.Method->printQualifiedName(Out); 421261991Sdim Out << ", " << Overrider.Offset.getQuantity() << ')'; 422226586Sdim 423226586Sdim BaseOffset Offset; 424226586Sdim if (!Overrider.Method->isPure()) 425226586Sdim Offset = ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method, MD); 426226586Sdim 427226586Sdim if (!Offset.isEmpty()) { 428226586Sdim Out << " [ret-adj: "; 429276479Sdim if (Offset.VirtualBase) { 430276479Sdim Offset.VirtualBase->printQualifiedName(Out); 431276479Sdim Out << " vbase, "; 432276479Sdim } 433226586Sdim 434226586Sdim Out << Offset.NonVirtualOffset.getQuantity() << " nv]"; 435226586Sdim } 436226586Sdim 437226586Sdim Out << "\n"; 438226586Sdim } 439226586Sdim} 440226586Sdim 441226586Sdim/// VCallOffsetMap - Keeps track of vcall offsets when building a vtable. 442226586Sdimstruct VCallOffsetMap { 443226586Sdim 444226586Sdim typedef std::pair<const CXXMethodDecl *, CharUnits> MethodAndOffsetPairTy; 445226586Sdim 446226586Sdim /// Offsets - Keeps track of methods and their offsets. 447226586Sdim // FIXME: This should be a real map and not a vector. 448226586Sdim SmallVector<MethodAndOffsetPairTy, 16> Offsets; 449226586Sdim 450226586Sdim /// MethodsCanShareVCallOffset - Returns whether two virtual member functions 451226586Sdim /// can share the same vcall offset. 452226586Sdim static bool MethodsCanShareVCallOffset(const CXXMethodDecl *LHS, 453226586Sdim const CXXMethodDecl *RHS); 454226586Sdim 455226586Sdimpublic: 456226586Sdim /// AddVCallOffset - Adds a vcall offset to the map. Returns true if the 457226586Sdim /// add was successful, or false if there was already a member function with 458226586Sdim /// the same signature in the map. 459226586Sdim bool AddVCallOffset(const CXXMethodDecl *MD, CharUnits OffsetOffset); 460226586Sdim 461226586Sdim /// getVCallOffsetOffset - Returns the vcall offset offset (relative to the 462226586Sdim /// vtable address point) for the given virtual member function. 463226586Sdim CharUnits getVCallOffsetOffset(const CXXMethodDecl *MD); 464226586Sdim 465226586Sdim // empty - Return whether the offset map is empty or not. 466226586Sdim bool empty() const { return Offsets.empty(); } 467226586Sdim}; 468226586Sdim 469226586Sdimstatic bool HasSameVirtualSignature(const CXXMethodDecl *LHS, 470226586Sdim const CXXMethodDecl *RHS) { 471234353Sdim const FunctionProtoType *LT = 472234353Sdim cast<FunctionProtoType>(LHS->getType().getCanonicalType()); 473234353Sdim const FunctionProtoType *RT = 474234353Sdim cast<FunctionProtoType>(RHS->getType().getCanonicalType()); 475226586Sdim 476226586Sdim // Fast-path matches in the canonical types. 477226586Sdim if (LT == RT) return true; 478226586Sdim 479226586Sdim // Force the signatures to match. We can't rely on the overrides 480226586Sdim // list here because there isn't necessarily an inheritance 481226586Sdim // relationship between the two methods. 482234353Sdim if (LT->getTypeQuals() != RT->getTypeQuals() || 483276479Sdim LT->getNumParams() != RT->getNumParams()) 484226586Sdim return false; 485276479Sdim for (unsigned I = 0, E = LT->getNumParams(); I != E; ++I) 486276479Sdim if (LT->getParamType(I) != RT->getParamType(I)) 487226586Sdim return false; 488226586Sdim return true; 489226586Sdim} 490226586Sdim 491226586Sdimbool VCallOffsetMap::MethodsCanShareVCallOffset(const CXXMethodDecl *LHS, 492226586Sdim const CXXMethodDecl *RHS) { 493226586Sdim assert(LHS->isVirtual() && "LHS must be virtual!"); 494226586Sdim assert(RHS->isVirtual() && "LHS must be virtual!"); 495226586Sdim 496226586Sdim // A destructor can share a vcall offset with another destructor. 497226586Sdim if (isa<CXXDestructorDecl>(LHS)) 498226586Sdim return isa<CXXDestructorDecl>(RHS); 499226586Sdim 500226586Sdim // FIXME: We need to check more things here. 501226586Sdim 502226586Sdim // The methods must have the same name. 503226586Sdim DeclarationName LHSName = LHS->getDeclName(); 504226586Sdim DeclarationName RHSName = RHS->getDeclName(); 505226586Sdim if (LHSName != RHSName) 506226586Sdim return false; 507226586Sdim 508226586Sdim // And the same signatures. 509226586Sdim return HasSameVirtualSignature(LHS, RHS); 510226586Sdim} 511226586Sdim 512226586Sdimbool VCallOffsetMap::AddVCallOffset(const CXXMethodDecl *MD, 513226586Sdim CharUnits OffsetOffset) { 514226586Sdim // Check if we can reuse an offset. 515226586Sdim for (unsigned I = 0, E = Offsets.size(); I != E; ++I) { 516226586Sdim if (MethodsCanShareVCallOffset(Offsets[I].first, MD)) 517226586Sdim return false; 518226586Sdim } 519226586Sdim 520226586Sdim // Add the offset. 521226586Sdim Offsets.push_back(MethodAndOffsetPairTy(MD, OffsetOffset)); 522226586Sdim return true; 523226586Sdim} 524226586Sdim 525226586SdimCharUnits VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) { 526226586Sdim // Look for an offset. 527226586Sdim for (unsigned I = 0, E = Offsets.size(); I != E; ++I) { 528226586Sdim if (MethodsCanShareVCallOffset(Offsets[I].first, MD)) 529226586Sdim return Offsets[I].second; 530226586Sdim } 531226586Sdim 532226586Sdim llvm_unreachable("Should always find a vcall offset offset!"); 533226586Sdim} 534226586Sdim 535226586Sdim/// VCallAndVBaseOffsetBuilder - Class for building vcall and vbase offsets. 536226586Sdimclass VCallAndVBaseOffsetBuilder { 537226586Sdimpublic: 538226586Sdim typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> 539226586Sdim VBaseOffsetOffsetsMapTy; 540226586Sdim 541226586Sdimprivate: 542226586Sdim /// MostDerivedClass - The most derived class for which we're building vcall 543226586Sdim /// and vbase offsets. 544226586Sdim const CXXRecordDecl *MostDerivedClass; 545226586Sdim 546226586Sdim /// LayoutClass - The class we're using for layout information. Will be 547226586Sdim /// different than the most derived class if we're building a construction 548226586Sdim /// vtable. 549226586Sdim const CXXRecordDecl *LayoutClass; 550226586Sdim 551226586Sdim /// Context - The ASTContext which we will use for layout information. 552226586Sdim ASTContext &Context; 553226586Sdim 554226586Sdim /// Components - vcall and vbase offset components 555226586Sdim typedef SmallVector<VTableComponent, 64> VTableComponentVectorTy; 556226586Sdim VTableComponentVectorTy Components; 557226586Sdim 558226586Sdim /// VisitedVirtualBases - Visited virtual bases. 559226586Sdim llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases; 560226586Sdim 561226586Sdim /// VCallOffsets - Keeps track of vcall offsets. 562226586Sdim VCallOffsetMap VCallOffsets; 563226586Sdim 564226586Sdim 565226586Sdim /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets, 566226586Sdim /// relative to the address point. 567226586Sdim VBaseOffsetOffsetsMapTy VBaseOffsetOffsets; 568226586Sdim 569226586Sdim /// FinalOverriders - The final overriders of the most derived class. 570226586Sdim /// (Can be null when we're not building a vtable of the most derived class). 571226586Sdim const FinalOverriders *Overriders; 572226586Sdim 573226586Sdim /// AddVCallAndVBaseOffsets - Add vcall offsets and vbase offsets for the 574226586Sdim /// given base subobject. 575226586Sdim void AddVCallAndVBaseOffsets(BaseSubobject Base, bool BaseIsVirtual, 576226586Sdim CharUnits RealBaseOffset); 577226586Sdim 578226586Sdim /// AddVCallOffsets - Add vcall offsets for the given base subobject. 579226586Sdim void AddVCallOffsets(BaseSubobject Base, CharUnits VBaseOffset); 580226586Sdim 581226586Sdim /// AddVBaseOffsets - Add vbase offsets for the given class. 582226586Sdim void AddVBaseOffsets(const CXXRecordDecl *Base, 583226586Sdim CharUnits OffsetInLayoutClass); 584226586Sdim 585226586Sdim /// getCurrentOffsetOffset - Get the current vcall or vbase offset offset in 586226586Sdim /// chars, relative to the vtable address point. 587226586Sdim CharUnits getCurrentOffsetOffset() const; 588226586Sdim 589226586Sdimpublic: 590226586Sdim VCallAndVBaseOffsetBuilder(const CXXRecordDecl *MostDerivedClass, 591226586Sdim const CXXRecordDecl *LayoutClass, 592226586Sdim const FinalOverriders *Overriders, 593226586Sdim BaseSubobject Base, bool BaseIsVirtual, 594226586Sdim CharUnits OffsetInLayoutClass) 595226586Sdim : MostDerivedClass(MostDerivedClass), LayoutClass(LayoutClass), 596226586Sdim Context(MostDerivedClass->getASTContext()), Overriders(Overriders) { 597226586Sdim 598226586Sdim // Add vcall and vbase offsets. 599226586Sdim AddVCallAndVBaseOffsets(Base, BaseIsVirtual, OffsetInLayoutClass); 600226586Sdim } 601226586Sdim 602226586Sdim /// Methods for iterating over the components. 603226586Sdim typedef VTableComponentVectorTy::const_reverse_iterator const_iterator; 604226586Sdim const_iterator components_begin() const { return Components.rbegin(); } 605226586Sdim const_iterator components_end() const { return Components.rend(); } 606226586Sdim 607226586Sdim const VCallOffsetMap &getVCallOffsets() const { return VCallOffsets; } 608226586Sdim const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const { 609226586Sdim return VBaseOffsetOffsets; 610226586Sdim } 611226586Sdim}; 612226586Sdim 613226586Sdimvoid 614226586SdimVCallAndVBaseOffsetBuilder::AddVCallAndVBaseOffsets(BaseSubobject Base, 615226586Sdim bool BaseIsVirtual, 616226586Sdim CharUnits RealBaseOffset) { 617226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base.getBase()); 618226586Sdim 619226586Sdim // Itanium C++ ABI 2.5.2: 620226586Sdim // ..in classes sharing a virtual table with a primary base class, the vcall 621226586Sdim // and vbase offsets added by the derived class all come before the vcall 622226586Sdim // and vbase offsets required by the base class, so that the latter may be 623226586Sdim // laid out as required by the base class without regard to additions from 624226586Sdim // the derived class(es). 625226586Sdim 626226586Sdim // (Since we're emitting the vcall and vbase offsets in reverse order, we'll 627226586Sdim // emit them for the primary base first). 628226586Sdim if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) { 629226586Sdim bool PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual(); 630226586Sdim 631226586Sdim CharUnits PrimaryBaseOffset; 632226586Sdim 633226586Sdim // Get the base offset of the primary base. 634226586Sdim if (PrimaryBaseIsVirtual) { 635239462Sdim assert(Layout.getVBaseClassOffset(PrimaryBase).isZero() && 636226586Sdim "Primary vbase should have a zero offset!"); 637226586Sdim 638226586Sdim const ASTRecordLayout &MostDerivedClassLayout = 639226586Sdim Context.getASTRecordLayout(MostDerivedClass); 640226586Sdim 641226586Sdim PrimaryBaseOffset = 642226586Sdim MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase); 643226586Sdim } else { 644239462Sdim assert(Layout.getBaseClassOffset(PrimaryBase).isZero() && 645226586Sdim "Primary base should have a zero offset!"); 646226586Sdim 647226586Sdim PrimaryBaseOffset = Base.getBaseOffset(); 648226586Sdim } 649226586Sdim 650226586Sdim AddVCallAndVBaseOffsets( 651226586Sdim BaseSubobject(PrimaryBase,PrimaryBaseOffset), 652226586Sdim PrimaryBaseIsVirtual, RealBaseOffset); 653226586Sdim } 654226586Sdim 655226586Sdim AddVBaseOffsets(Base.getBase(), RealBaseOffset); 656226586Sdim 657226586Sdim // We only want to add vcall offsets for virtual bases. 658226586Sdim if (BaseIsVirtual) 659226586Sdim AddVCallOffsets(Base, RealBaseOffset); 660226586Sdim} 661226586Sdim 662226586SdimCharUnits VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const { 663226586Sdim // OffsetIndex is the index of this vcall or vbase offset, relative to the 664226586Sdim // vtable address point. (We subtract 3 to account for the information just 665226586Sdim // above the address point, the RTTI info, the offset to top, and the 666226586Sdim // vcall offset itself). 667226586Sdim int64_t OffsetIndex = -(int64_t)(3 + Components.size()); 668226586Sdim 669226586Sdim CharUnits PointerWidth = 670226586Sdim Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); 671226586Sdim CharUnits OffsetOffset = PointerWidth * OffsetIndex; 672226586Sdim return OffsetOffset; 673226586Sdim} 674226586Sdim 675226586Sdimvoid VCallAndVBaseOffsetBuilder::AddVCallOffsets(BaseSubobject Base, 676226586Sdim CharUnits VBaseOffset) { 677226586Sdim const CXXRecordDecl *RD = Base.getBase(); 678226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 679226586Sdim 680226586Sdim const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 681226586Sdim 682226586Sdim // Handle the primary base first. 683226586Sdim // We only want to add vcall offsets if the base is non-virtual; a virtual 684226586Sdim // primary base will have its vcall and vbase offsets emitted already. 685226586Sdim if (PrimaryBase && !Layout.isPrimaryBaseVirtual()) { 686226586Sdim // Get the base offset of the primary base. 687239462Sdim assert(Layout.getBaseClassOffset(PrimaryBase).isZero() && 688226586Sdim "Primary base should have a zero offset!"); 689226586Sdim 690226586Sdim AddVCallOffsets(BaseSubobject(PrimaryBase, Base.getBaseOffset()), 691226586Sdim VBaseOffset); 692226586Sdim } 693226586Sdim 694226586Sdim // Add the vcall offsets. 695276479Sdim for (const auto *MD : RD->methods()) { 696226586Sdim if (!MD->isVirtual()) 697226586Sdim continue; 698226586Sdim 699226586Sdim CharUnits OffsetOffset = getCurrentOffsetOffset(); 700226586Sdim 701226586Sdim // Don't add a vcall offset if we already have one for this member function 702226586Sdim // signature. 703226586Sdim if (!VCallOffsets.AddVCallOffset(MD, OffsetOffset)) 704226586Sdim continue; 705226586Sdim 706226586Sdim CharUnits Offset = CharUnits::Zero(); 707226586Sdim 708226586Sdim if (Overriders) { 709226586Sdim // Get the final overrider. 710226586Sdim FinalOverriders::OverriderInfo Overrider = 711226586Sdim Overriders->getOverrider(MD, Base.getBaseOffset()); 712226586Sdim 713226586Sdim /// The vcall offset is the offset from the virtual base to the object 714226586Sdim /// where the function was overridden. 715226586Sdim Offset = Overrider.Offset - VBaseOffset; 716226586Sdim } 717226586Sdim 718226586Sdim Components.push_back( 719226586Sdim VTableComponent::MakeVCallOffset(Offset)); 720226586Sdim } 721226586Sdim 722226586Sdim // And iterate over all non-virtual bases (ignoring the primary base). 723276479Sdim for (const auto &B : RD->bases()) { 724276479Sdim if (B.isVirtual()) 725226586Sdim continue; 726226586Sdim 727276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 728226586Sdim if (BaseDecl == PrimaryBase) 729226586Sdim continue; 730226586Sdim 731226586Sdim // Get the base offset of this base. 732226586Sdim CharUnits BaseOffset = Base.getBaseOffset() + 733226586Sdim Layout.getBaseClassOffset(BaseDecl); 734226586Sdim 735226586Sdim AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset), 736226586Sdim VBaseOffset); 737226586Sdim } 738226586Sdim} 739226586Sdim 740226586Sdimvoid 741226586SdimVCallAndVBaseOffsetBuilder::AddVBaseOffsets(const CXXRecordDecl *RD, 742226586Sdim CharUnits OffsetInLayoutClass) { 743226586Sdim const ASTRecordLayout &LayoutClassLayout = 744226586Sdim Context.getASTRecordLayout(LayoutClass); 745226586Sdim 746226586Sdim // Add vbase offsets. 747276479Sdim for (const auto &B : RD->bases()) { 748276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 749226586Sdim 750226586Sdim // Check if this is a virtual base that we haven't visited before. 751276479Sdim if (B.isVirtual() && VisitedVirtualBases.insert(BaseDecl)) { 752226586Sdim CharUnits Offset = 753226586Sdim LayoutClassLayout.getVBaseClassOffset(BaseDecl) - OffsetInLayoutClass; 754226586Sdim 755226586Sdim // Add the vbase offset offset. 756226586Sdim assert(!VBaseOffsetOffsets.count(BaseDecl) && 757226586Sdim "vbase offset offset already exists!"); 758226586Sdim 759226586Sdim CharUnits VBaseOffsetOffset = getCurrentOffsetOffset(); 760226586Sdim VBaseOffsetOffsets.insert( 761226586Sdim std::make_pair(BaseDecl, VBaseOffsetOffset)); 762226586Sdim 763226586Sdim Components.push_back( 764226586Sdim VTableComponent::MakeVBaseOffset(Offset)); 765226586Sdim } 766226586Sdim 767226586Sdim // Check the base class looking for more vbase offsets. 768226586Sdim AddVBaseOffsets(BaseDecl, OffsetInLayoutClass); 769226586Sdim } 770226586Sdim} 771226586Sdim 772261991Sdim/// ItaniumVTableBuilder - Class for building vtable layout information. 773261991Sdimclass ItaniumVTableBuilder { 774226586Sdimpublic: 775226586Sdim /// PrimaryBasesSetVectorTy - A set vector of direct and indirect 776226586Sdim /// primary bases. 777226586Sdim typedef llvm::SmallSetVector<const CXXRecordDecl *, 8> 778226586Sdim PrimaryBasesSetVectorTy; 779226586Sdim 780226586Sdim typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> 781226586Sdim VBaseOffsetOffsetsMapTy; 782226586Sdim 783226586Sdim typedef llvm::DenseMap<BaseSubobject, uint64_t> 784226586Sdim AddressPointsMapTy; 785226586Sdim 786261991Sdim typedef llvm::DenseMap<GlobalDecl, int64_t> MethodVTableIndicesTy; 787261991Sdim 788226586Sdimprivate: 789226586Sdim /// VTables - Global vtable information. 790261991Sdim ItaniumVTableContext &VTables; 791226586Sdim 792226586Sdim /// MostDerivedClass - The most derived class for which we're building this 793226586Sdim /// vtable. 794226586Sdim const CXXRecordDecl *MostDerivedClass; 795226586Sdim 796226586Sdim /// MostDerivedClassOffset - If we're building a construction vtable, this 797226586Sdim /// holds the offset from the layout class to the most derived class. 798226586Sdim const CharUnits MostDerivedClassOffset; 799226586Sdim 800226586Sdim /// MostDerivedClassIsVirtual - Whether the most derived class is a virtual 801226586Sdim /// base. (This only makes sense when building a construction vtable). 802226586Sdim bool MostDerivedClassIsVirtual; 803226586Sdim 804226586Sdim /// LayoutClass - The class we're using for layout information. Will be 805226586Sdim /// different than the most derived class if we're building a construction 806226586Sdim /// vtable. 807226586Sdim const CXXRecordDecl *LayoutClass; 808226586Sdim 809226586Sdim /// Context - The ASTContext which we will use for layout information. 810226586Sdim ASTContext &Context; 811226586Sdim 812226586Sdim /// FinalOverriders - The final overriders of the most derived class. 813226586Sdim const FinalOverriders Overriders; 814226586Sdim 815226586Sdim /// VCallOffsetsForVBases - Keeps track of vcall offsets for the virtual 816226586Sdim /// bases in this vtable. 817226586Sdim llvm::DenseMap<const CXXRecordDecl *, VCallOffsetMap> VCallOffsetsForVBases; 818226586Sdim 819226586Sdim /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets for 820226586Sdim /// the most derived class. 821226586Sdim VBaseOffsetOffsetsMapTy VBaseOffsetOffsets; 822226586Sdim 823226586Sdim /// Components - The components of the vtable being built. 824226586Sdim SmallVector<VTableComponent, 64> Components; 825226586Sdim 826226586Sdim /// AddressPoints - Address points for the vtable being built. 827226586Sdim AddressPointsMapTy AddressPoints; 828226586Sdim 829226586Sdim /// MethodInfo - Contains information about a method in a vtable. 830226586Sdim /// (Used for computing 'this' pointer adjustment thunks. 831226586Sdim struct MethodInfo { 832226586Sdim /// BaseOffset - The base offset of this method. 833226586Sdim const CharUnits BaseOffset; 834226586Sdim 835226586Sdim /// BaseOffsetInLayoutClass - The base offset in the layout class of this 836226586Sdim /// method. 837226586Sdim const CharUnits BaseOffsetInLayoutClass; 838226586Sdim 839226586Sdim /// VTableIndex - The index in the vtable that this method has. 840226586Sdim /// (For destructors, this is the index of the complete destructor). 841226586Sdim const uint64_t VTableIndex; 842226586Sdim 843226586Sdim MethodInfo(CharUnits BaseOffset, CharUnits BaseOffsetInLayoutClass, 844226586Sdim uint64_t VTableIndex) 845226586Sdim : BaseOffset(BaseOffset), 846226586Sdim BaseOffsetInLayoutClass(BaseOffsetInLayoutClass), 847226586Sdim VTableIndex(VTableIndex) { } 848226586Sdim 849226586Sdim MethodInfo() 850226586Sdim : BaseOffset(CharUnits::Zero()), 851226586Sdim BaseOffsetInLayoutClass(CharUnits::Zero()), 852226586Sdim VTableIndex(0) { } 853226586Sdim }; 854226586Sdim 855226586Sdim typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy; 856226586Sdim 857226586Sdim /// MethodInfoMap - The information for all methods in the vtable we're 858226586Sdim /// currently building. 859226586Sdim MethodInfoMapTy MethodInfoMap; 860261991Sdim 861261991Sdim /// MethodVTableIndices - Contains the index (relative to the vtable address 862261991Sdim /// point) where the function pointer for a virtual function is stored. 863261991Sdim MethodVTableIndicesTy MethodVTableIndices; 864261991Sdim 865226586Sdim typedef llvm::DenseMap<uint64_t, ThunkInfo> VTableThunksMapTy; 866226586Sdim 867226586Sdim /// VTableThunks - The thunks by vtable index in the vtable currently being 868226586Sdim /// built. 869226586Sdim VTableThunksMapTy VTableThunks; 870226586Sdim 871226586Sdim typedef SmallVector<ThunkInfo, 1> ThunkInfoVectorTy; 872226586Sdim typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy; 873226586Sdim 874226586Sdim /// Thunks - A map that contains all the thunks needed for all methods in the 875226586Sdim /// most derived class for which the vtable is currently being built. 876226586Sdim ThunksMapTy Thunks; 877226586Sdim 878226586Sdim /// AddThunk - Add a thunk for the given method. 879226586Sdim void AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk); 880226586Sdim 881226586Sdim /// ComputeThisAdjustments - Compute the 'this' pointer adjustments for the 882226586Sdim /// part of the vtable we're currently building. 883226586Sdim void ComputeThisAdjustments(); 884226586Sdim 885226586Sdim typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy; 886226586Sdim 887226586Sdim /// PrimaryVirtualBases - All known virtual bases who are a primary base of 888226586Sdim /// some other base. 889226586Sdim VisitedVirtualBasesSetTy PrimaryVirtualBases; 890226586Sdim 891226586Sdim /// ComputeReturnAdjustment - Compute the return adjustment given a return 892226586Sdim /// adjustment base offset. 893226586Sdim ReturnAdjustment ComputeReturnAdjustment(BaseOffset Offset); 894226586Sdim 895226586Sdim /// ComputeThisAdjustmentBaseOffset - Compute the base offset for adjusting 896226586Sdim /// the 'this' pointer from the base subobject to the derived subobject. 897226586Sdim BaseOffset ComputeThisAdjustmentBaseOffset(BaseSubobject Base, 898226586Sdim BaseSubobject Derived) const; 899226586Sdim 900226586Sdim /// ComputeThisAdjustment - Compute the 'this' pointer adjustment for the 901226586Sdim /// given virtual member function, its offset in the layout class and its 902226586Sdim /// final overrider. 903226586Sdim ThisAdjustment 904226586Sdim ComputeThisAdjustment(const CXXMethodDecl *MD, 905226586Sdim CharUnits BaseOffsetInLayoutClass, 906226586Sdim FinalOverriders::OverriderInfo Overrider); 907226586Sdim 908226586Sdim /// AddMethod - Add a single virtual member function to the vtable 909226586Sdim /// components vector. 910226586Sdim void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment); 911226586Sdim 912226586Sdim /// IsOverriderUsed - Returns whether the overrider will ever be used in this 913226586Sdim /// part of the vtable. 914226586Sdim /// 915226586Sdim /// Itanium C++ ABI 2.5.2: 916226586Sdim /// 917226586Sdim /// struct A { virtual void f(); }; 918226586Sdim /// struct B : virtual public A { int i; }; 919226586Sdim /// struct C : virtual public A { int j; }; 920226586Sdim /// struct D : public B, public C {}; 921226586Sdim /// 922226586Sdim /// When B and C are declared, A is a primary base in each case, so although 923226586Sdim /// vcall offsets are allocated in the A-in-B and A-in-C vtables, no this 924226586Sdim /// adjustment is required and no thunk is generated. However, inside D 925226586Sdim /// objects, A is no longer a primary base of C, so if we allowed calls to 926226586Sdim /// C::f() to use the copy of A's vtable in the C subobject, we would need 927226586Sdim /// to adjust this from C* to B::A*, which would require a third-party 928226586Sdim /// thunk. Since we require that a call to C::f() first convert to A*, 929226586Sdim /// C-in-D's copy of A's vtable is never referenced, so this is not 930226586Sdim /// necessary. 931226586Sdim bool IsOverriderUsed(const CXXMethodDecl *Overrider, 932226586Sdim CharUnits BaseOffsetInLayoutClass, 933226586Sdim const CXXRecordDecl *FirstBaseInPrimaryBaseChain, 934226586Sdim CharUnits FirstBaseOffsetInLayoutClass) const; 935226586Sdim 936226586Sdim 937226586Sdim /// AddMethods - Add the methods of this base subobject and all its 938226586Sdim /// primary bases to the vtable components vector. 939226586Sdim void AddMethods(BaseSubobject Base, CharUnits BaseOffsetInLayoutClass, 940226586Sdim const CXXRecordDecl *FirstBaseInPrimaryBaseChain, 941226586Sdim CharUnits FirstBaseOffsetInLayoutClass, 942226586Sdim PrimaryBasesSetVectorTy &PrimaryBases); 943226586Sdim 944226586Sdim // LayoutVTable - Layout the vtable for the given base class, including its 945226586Sdim // secondary vtables and any vtables for virtual bases. 946226586Sdim void LayoutVTable(); 947226586Sdim 948226586Sdim /// LayoutPrimaryAndSecondaryVTables - Layout the primary vtable for the 949226586Sdim /// given base subobject, as well as all its secondary vtables. 950226586Sdim /// 951226586Sdim /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base 952226586Sdim /// or a direct or indirect base of a virtual base. 953226586Sdim /// 954226586Sdim /// \param BaseIsVirtualInLayoutClass - Whether the base subobject is virtual 955226586Sdim /// in the layout class. 956226586Sdim void LayoutPrimaryAndSecondaryVTables(BaseSubobject Base, 957226586Sdim bool BaseIsMorallyVirtual, 958226586Sdim bool BaseIsVirtualInLayoutClass, 959226586Sdim CharUnits OffsetInLayoutClass); 960226586Sdim 961226586Sdim /// LayoutSecondaryVTables - Layout the secondary vtables for the given base 962226586Sdim /// subobject. 963226586Sdim /// 964226586Sdim /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base 965226586Sdim /// or a direct or indirect base of a virtual base. 966226586Sdim void LayoutSecondaryVTables(BaseSubobject Base, bool BaseIsMorallyVirtual, 967226586Sdim CharUnits OffsetInLayoutClass); 968226586Sdim 969226586Sdim /// DeterminePrimaryVirtualBases - Determine the primary virtual bases in this 970226586Sdim /// class hierarchy. 971226586Sdim void DeterminePrimaryVirtualBases(const CXXRecordDecl *RD, 972226586Sdim CharUnits OffsetInLayoutClass, 973226586Sdim VisitedVirtualBasesSetTy &VBases); 974226586Sdim 975226586Sdim /// LayoutVTablesForVirtualBases - Layout vtables for all virtual bases of the 976226586Sdim /// given base (excluding any primary bases). 977226586Sdim void LayoutVTablesForVirtualBases(const CXXRecordDecl *RD, 978226586Sdim VisitedVirtualBasesSetTy &VBases); 979226586Sdim 980226586Sdim /// isBuildingConstructionVTable - Return whether this vtable builder is 981226586Sdim /// building a construction vtable. 982226586Sdim bool isBuildingConstructorVTable() const { 983226586Sdim return MostDerivedClass != LayoutClass; 984226586Sdim } 985226586Sdim 986226586Sdimpublic: 987261991Sdim ItaniumVTableBuilder(ItaniumVTableContext &VTables, 988261991Sdim const CXXRecordDecl *MostDerivedClass, 989261991Sdim CharUnits MostDerivedClassOffset, 990261991Sdim bool MostDerivedClassIsVirtual, 991261991Sdim const CXXRecordDecl *LayoutClass) 992261991Sdim : VTables(VTables), MostDerivedClass(MostDerivedClass), 993261991Sdim MostDerivedClassOffset(MostDerivedClassOffset), 994261991Sdim MostDerivedClassIsVirtual(MostDerivedClassIsVirtual), 995261991Sdim LayoutClass(LayoutClass), Context(MostDerivedClass->getASTContext()), 996261991Sdim Overriders(MostDerivedClass, MostDerivedClassOffset, LayoutClass) { 997261991Sdim assert(!Context.getTargetInfo().getCXXABI().isMicrosoft()); 998226586Sdim 999226586Sdim LayoutVTable(); 1000226586Sdim 1001234353Sdim if (Context.getLangOpts().DumpVTableLayouts) 1002261991Sdim dumpLayout(llvm::outs()); 1003226586Sdim } 1004226586Sdim 1005226586Sdim uint64_t getNumThunks() const { 1006226586Sdim return Thunks.size(); 1007226586Sdim } 1008226586Sdim 1009226586Sdim ThunksMapTy::const_iterator thunks_begin() const { 1010226586Sdim return Thunks.begin(); 1011226586Sdim } 1012226586Sdim 1013226586Sdim ThunksMapTy::const_iterator thunks_end() const { 1014226586Sdim return Thunks.end(); 1015226586Sdim } 1016226586Sdim 1017226586Sdim const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const { 1018226586Sdim return VBaseOffsetOffsets; 1019226586Sdim } 1020226586Sdim 1021226586Sdim const AddressPointsMapTy &getAddressPoints() const { 1022226586Sdim return AddressPoints; 1023226586Sdim } 1024226586Sdim 1025261991Sdim MethodVTableIndicesTy::const_iterator vtable_indices_begin() const { 1026261991Sdim return MethodVTableIndices.begin(); 1027261991Sdim } 1028261991Sdim 1029261991Sdim MethodVTableIndicesTy::const_iterator vtable_indices_end() const { 1030261991Sdim return MethodVTableIndices.end(); 1031261991Sdim } 1032261991Sdim 1033226586Sdim /// getNumVTableComponents - Return the number of components in the vtable 1034226586Sdim /// currently built. 1035226586Sdim uint64_t getNumVTableComponents() const { 1036226586Sdim return Components.size(); 1037226586Sdim } 1038226586Sdim 1039226586Sdim const VTableComponent *vtable_component_begin() const { 1040226586Sdim return Components.begin(); 1041226586Sdim } 1042226586Sdim 1043226586Sdim const VTableComponent *vtable_component_end() const { 1044226586Sdim return Components.end(); 1045226586Sdim } 1046226586Sdim 1047226586Sdim AddressPointsMapTy::const_iterator address_points_begin() const { 1048226586Sdim return AddressPoints.begin(); 1049226586Sdim } 1050226586Sdim 1051226586Sdim AddressPointsMapTy::const_iterator address_points_end() const { 1052226586Sdim return AddressPoints.end(); 1053226586Sdim } 1054226586Sdim 1055226586Sdim VTableThunksMapTy::const_iterator vtable_thunks_begin() const { 1056226586Sdim return VTableThunks.begin(); 1057226586Sdim } 1058226586Sdim 1059226586Sdim VTableThunksMapTy::const_iterator vtable_thunks_end() const { 1060226586Sdim return VTableThunks.end(); 1061226586Sdim } 1062226586Sdim 1063226586Sdim /// dumpLayout - Dump the vtable layout. 1064226586Sdim void dumpLayout(raw_ostream&); 1065226586Sdim}; 1066226586Sdim 1067261991Sdimvoid ItaniumVTableBuilder::AddThunk(const CXXMethodDecl *MD, 1068261991Sdim const ThunkInfo &Thunk) { 1069226586Sdim assert(!isBuildingConstructorVTable() && 1070226586Sdim "Can't add thunks for construction vtable"); 1071226586Sdim 1072261991Sdim SmallVectorImpl<ThunkInfo> &ThunksVector = Thunks[MD]; 1073261991Sdim 1074226586Sdim // Check if we have this thunk already. 1075226586Sdim if (std::find(ThunksVector.begin(), ThunksVector.end(), Thunk) != 1076226586Sdim ThunksVector.end()) 1077226586Sdim return; 1078226586Sdim 1079226586Sdim ThunksVector.push_back(Thunk); 1080226586Sdim} 1081226586Sdim 1082226586Sdimtypedef llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverriddenMethodsSetTy; 1083226586Sdim 1084261991Sdim/// Visit all the methods overridden by the given method recursively, 1085261991Sdim/// in a depth-first pre-order. The Visitor's visitor method returns a bool 1086261991Sdim/// indicating whether to continue the recursion for the given overridden 1087261991Sdim/// method (i.e. returning false stops the iteration). 1088261991Sdimtemplate <class VisitorTy> 1089261991Sdimstatic void 1090261991SdimvisitAllOverriddenMethods(const CXXMethodDecl *MD, VisitorTy &Visitor) { 1091226586Sdim assert(MD->isVirtual() && "Method is not virtual!"); 1092226586Sdim 1093226586Sdim for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 1094226586Sdim E = MD->end_overridden_methods(); I != E; ++I) { 1095226586Sdim const CXXMethodDecl *OverriddenMD = *I; 1096261991Sdim if (!Visitor.visit(OverriddenMD)) 1097261991Sdim continue; 1098261991Sdim visitAllOverriddenMethods(OverriddenMD, Visitor); 1099226586Sdim } 1100226586Sdim} 1101226586Sdim 1102261991Sdimnamespace { 1103261991Sdim struct OverriddenMethodsCollector { 1104261991Sdim OverriddenMethodsSetTy *Methods; 1105261991Sdim 1106261991Sdim bool visit(const CXXMethodDecl *MD) { 1107261991Sdim // Don't recurse on this method if we've already collected it. 1108261991Sdim return Methods->insert(MD); 1109261991Sdim } 1110261991Sdim }; 1111261991Sdim} 1112261991Sdim 1113261991Sdim/// ComputeAllOverriddenMethods - Given a method decl, will return a set of all 1114261991Sdim/// the overridden methods that the function decl overrides. 1115261991Sdimstatic void 1116261991SdimComputeAllOverriddenMethods(const CXXMethodDecl *MD, 1117261991Sdim OverriddenMethodsSetTy& OverriddenMethods) { 1118261991Sdim OverriddenMethodsCollector Collector = { &OverriddenMethods }; 1119261991Sdim visitAllOverriddenMethods(MD, Collector); 1120261991Sdim} 1121261991Sdim 1122261991Sdimvoid ItaniumVTableBuilder::ComputeThisAdjustments() { 1123226586Sdim // Now go through the method info map and see if any of the methods need 1124226586Sdim // 'this' pointer adjustments. 1125226586Sdim for (MethodInfoMapTy::const_iterator I = MethodInfoMap.begin(), 1126226586Sdim E = MethodInfoMap.end(); I != E; ++I) { 1127226586Sdim const CXXMethodDecl *MD = I->first; 1128226586Sdim const MethodInfo &MethodInfo = I->second; 1129226586Sdim 1130226586Sdim // Ignore adjustments for unused function pointers. 1131226586Sdim uint64_t VTableIndex = MethodInfo.VTableIndex; 1132226586Sdim if (Components[VTableIndex].getKind() == 1133226586Sdim VTableComponent::CK_UnusedFunctionPointer) 1134226586Sdim continue; 1135226586Sdim 1136226586Sdim // Get the final overrider for this method. 1137226586Sdim FinalOverriders::OverriderInfo Overrider = 1138226586Sdim Overriders.getOverrider(MD, MethodInfo.BaseOffset); 1139226586Sdim 1140226586Sdim // Check if we need an adjustment at all. 1141226586Sdim if (MethodInfo.BaseOffsetInLayoutClass == Overrider.Offset) { 1142226586Sdim // When a return thunk is needed by a derived class that overrides a 1143226586Sdim // virtual base, gcc uses a virtual 'this' adjustment as well. 1144226586Sdim // While the thunk itself might be needed by vtables in subclasses or 1145226586Sdim // in construction vtables, there doesn't seem to be a reason for using 1146226586Sdim // the thunk in this vtable. Still, we do so to match gcc. 1147226586Sdim if (VTableThunks.lookup(VTableIndex).Return.isEmpty()) 1148226586Sdim continue; 1149226586Sdim } 1150226586Sdim 1151226586Sdim ThisAdjustment ThisAdjustment = 1152226586Sdim ComputeThisAdjustment(MD, MethodInfo.BaseOffsetInLayoutClass, Overrider); 1153226586Sdim 1154226586Sdim if (ThisAdjustment.isEmpty()) 1155226586Sdim continue; 1156226586Sdim 1157226586Sdim // Add it. 1158226586Sdim VTableThunks[VTableIndex].This = ThisAdjustment; 1159226586Sdim 1160226586Sdim if (isa<CXXDestructorDecl>(MD)) { 1161226586Sdim // Add an adjustment for the deleting destructor as well. 1162226586Sdim VTableThunks[VTableIndex + 1].This = ThisAdjustment; 1163226586Sdim } 1164226586Sdim } 1165226586Sdim 1166226586Sdim /// Clear the method info map. 1167226586Sdim MethodInfoMap.clear(); 1168226586Sdim 1169226586Sdim if (isBuildingConstructorVTable()) { 1170226586Sdim // We don't need to store thunk information for construction vtables. 1171226586Sdim return; 1172226586Sdim } 1173226586Sdim 1174226586Sdim for (VTableThunksMapTy::const_iterator I = VTableThunks.begin(), 1175226586Sdim E = VTableThunks.end(); I != E; ++I) { 1176226586Sdim const VTableComponent &Component = Components[I->first]; 1177226586Sdim const ThunkInfo &Thunk = I->second; 1178226586Sdim const CXXMethodDecl *MD; 1179226586Sdim 1180226586Sdim switch (Component.getKind()) { 1181226586Sdim default: 1182226586Sdim llvm_unreachable("Unexpected vtable component kind!"); 1183226586Sdim case VTableComponent::CK_FunctionPointer: 1184226586Sdim MD = Component.getFunctionDecl(); 1185226586Sdim break; 1186226586Sdim case VTableComponent::CK_CompleteDtorPointer: 1187226586Sdim MD = Component.getDestructorDecl(); 1188226586Sdim break; 1189226586Sdim case VTableComponent::CK_DeletingDtorPointer: 1190226586Sdim // We've already added the thunk when we saw the complete dtor pointer. 1191226586Sdim continue; 1192226586Sdim } 1193226586Sdim 1194226586Sdim if (MD->getParent() == MostDerivedClass) 1195226586Sdim AddThunk(MD, Thunk); 1196226586Sdim } 1197226586Sdim} 1198226586Sdim 1199261991SdimReturnAdjustment 1200261991SdimItaniumVTableBuilder::ComputeReturnAdjustment(BaseOffset Offset) { 1201226586Sdim ReturnAdjustment Adjustment; 1202226586Sdim 1203226586Sdim if (!Offset.isEmpty()) { 1204226586Sdim if (Offset.VirtualBase) { 1205226586Sdim // Get the virtual base offset offset. 1206226586Sdim if (Offset.DerivedClass == MostDerivedClass) { 1207226586Sdim // We can get the offset offset directly from our map. 1208261991Sdim Adjustment.Virtual.Itanium.VBaseOffsetOffset = 1209226586Sdim VBaseOffsetOffsets.lookup(Offset.VirtualBase).getQuantity(); 1210226586Sdim } else { 1211261991Sdim Adjustment.Virtual.Itanium.VBaseOffsetOffset = 1212226586Sdim VTables.getVirtualBaseOffsetOffset(Offset.DerivedClass, 1213226586Sdim Offset.VirtualBase).getQuantity(); 1214226586Sdim } 1215226586Sdim } 1216226586Sdim 1217226586Sdim Adjustment.NonVirtual = Offset.NonVirtualOffset.getQuantity(); 1218226586Sdim } 1219226586Sdim 1220226586Sdim return Adjustment; 1221226586Sdim} 1222226586Sdim 1223261991SdimBaseOffset ItaniumVTableBuilder::ComputeThisAdjustmentBaseOffset( 1224261991Sdim BaseSubobject Base, BaseSubobject Derived) const { 1225226586Sdim const CXXRecordDecl *BaseRD = Base.getBase(); 1226226586Sdim const CXXRecordDecl *DerivedRD = Derived.getBase(); 1227226586Sdim 1228226586Sdim CXXBasePaths Paths(/*FindAmbiguities=*/true, 1229226586Sdim /*RecordPaths=*/true, /*DetectVirtual=*/true); 1230226586Sdim 1231249423Sdim if (!DerivedRD->isDerivedFrom(BaseRD, Paths)) 1232226586Sdim llvm_unreachable("Class must be derived from the passed in base class!"); 1233226586Sdim 1234226586Sdim // We have to go through all the paths, and see which one leads us to the 1235226586Sdim // right base subobject. 1236226586Sdim for (CXXBasePaths::const_paths_iterator I = Paths.begin(), E = Paths.end(); 1237226586Sdim I != E; ++I) { 1238226586Sdim BaseOffset Offset = ComputeBaseOffset(Context, DerivedRD, *I); 1239226586Sdim 1240226586Sdim CharUnits OffsetToBaseSubobject = Offset.NonVirtualOffset; 1241226586Sdim 1242226586Sdim if (Offset.VirtualBase) { 1243226586Sdim // If we have a virtual base class, the non-virtual offset is relative 1244226586Sdim // to the virtual base class offset. 1245226586Sdim const ASTRecordLayout &LayoutClassLayout = 1246226586Sdim Context.getASTRecordLayout(LayoutClass); 1247226586Sdim 1248226586Sdim /// Get the virtual base offset, relative to the most derived class 1249226586Sdim /// layout. 1250226586Sdim OffsetToBaseSubobject += 1251226586Sdim LayoutClassLayout.getVBaseClassOffset(Offset.VirtualBase); 1252226586Sdim } else { 1253226586Sdim // Otherwise, the non-virtual offset is relative to the derived class 1254226586Sdim // offset. 1255226586Sdim OffsetToBaseSubobject += Derived.getBaseOffset(); 1256226586Sdim } 1257226586Sdim 1258226586Sdim // Check if this path gives us the right base subobject. 1259226586Sdim if (OffsetToBaseSubobject == Base.getBaseOffset()) { 1260226586Sdim // Since we're going from the base class _to_ the derived class, we'll 1261226586Sdim // invert the non-virtual offset here. 1262226586Sdim Offset.NonVirtualOffset = -Offset.NonVirtualOffset; 1263226586Sdim return Offset; 1264226586Sdim } 1265226586Sdim } 1266226586Sdim 1267226586Sdim return BaseOffset(); 1268226586Sdim} 1269261991Sdim 1270261991SdimThisAdjustment ItaniumVTableBuilder::ComputeThisAdjustment( 1271261991Sdim const CXXMethodDecl *MD, CharUnits BaseOffsetInLayoutClass, 1272261991Sdim FinalOverriders::OverriderInfo Overrider) { 1273226586Sdim // Ignore adjustments for pure virtual member functions. 1274226586Sdim if (Overrider.Method->isPure()) 1275226586Sdim return ThisAdjustment(); 1276226586Sdim 1277226586Sdim BaseSubobject OverriddenBaseSubobject(MD->getParent(), 1278226586Sdim BaseOffsetInLayoutClass); 1279226586Sdim 1280226586Sdim BaseSubobject OverriderBaseSubobject(Overrider.Method->getParent(), 1281226586Sdim Overrider.Offset); 1282226586Sdim 1283226586Sdim // Compute the adjustment offset. 1284226586Sdim BaseOffset Offset = ComputeThisAdjustmentBaseOffset(OverriddenBaseSubobject, 1285226586Sdim OverriderBaseSubobject); 1286226586Sdim if (Offset.isEmpty()) 1287226586Sdim return ThisAdjustment(); 1288226586Sdim 1289226586Sdim ThisAdjustment Adjustment; 1290226586Sdim 1291226586Sdim if (Offset.VirtualBase) { 1292226586Sdim // Get the vcall offset map for this virtual base. 1293226586Sdim VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Offset.VirtualBase]; 1294226586Sdim 1295226586Sdim if (VCallOffsets.empty()) { 1296226586Sdim // We don't have vcall offsets for this virtual base, go ahead and 1297226586Sdim // build them. 1298226586Sdim VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, MostDerivedClass, 1299276479Sdim /*FinalOverriders=*/nullptr, 1300226586Sdim BaseSubobject(Offset.VirtualBase, 1301226586Sdim CharUnits::Zero()), 1302226586Sdim /*BaseIsVirtual=*/true, 1303226586Sdim /*OffsetInLayoutClass=*/ 1304226586Sdim CharUnits::Zero()); 1305226586Sdim 1306226586Sdim VCallOffsets = Builder.getVCallOffsets(); 1307226586Sdim } 1308226586Sdim 1309261991Sdim Adjustment.Virtual.Itanium.VCallOffsetOffset = 1310226586Sdim VCallOffsets.getVCallOffsetOffset(MD).getQuantity(); 1311226586Sdim } 1312226586Sdim 1313226586Sdim // Set the non-virtual part of the adjustment. 1314226586Sdim Adjustment.NonVirtual = Offset.NonVirtualOffset.getQuantity(); 1315226586Sdim 1316226586Sdim return Adjustment; 1317226586Sdim} 1318261991Sdim 1319261991Sdimvoid ItaniumVTableBuilder::AddMethod(const CXXMethodDecl *MD, 1320261991Sdim ReturnAdjustment ReturnAdjustment) { 1321226586Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 1322226586Sdim assert(ReturnAdjustment.isEmpty() && 1323226586Sdim "Destructor can't have return adjustment!"); 1324226586Sdim 1325261991Sdim // Add both the complete destructor and the deleting destructor. 1326261991Sdim Components.push_back(VTableComponent::MakeCompleteDtor(DD)); 1327261991Sdim Components.push_back(VTableComponent::MakeDeletingDtor(DD)); 1328226586Sdim } else { 1329226586Sdim // Add the return adjustment if necessary. 1330226586Sdim if (!ReturnAdjustment.isEmpty()) 1331226586Sdim VTableThunks[Components.size()].Return = ReturnAdjustment; 1332226586Sdim 1333226586Sdim // Add the function. 1334226586Sdim Components.push_back(VTableComponent::MakeFunction(MD)); 1335226586Sdim } 1336226586Sdim} 1337226586Sdim 1338226586Sdim/// OverridesIndirectMethodInBase - Return whether the given member function 1339226586Sdim/// overrides any methods in the set of given bases. 1340226586Sdim/// Unlike OverridesMethodInBase, this checks "overriders of overriders". 1341226586Sdim/// For example, if we have: 1342226586Sdim/// 1343226586Sdim/// struct A { virtual void f(); } 1344226586Sdim/// struct B : A { virtual void f(); } 1345226586Sdim/// struct C : B { virtual void f(); } 1346226586Sdim/// 1347226586Sdim/// OverridesIndirectMethodInBase will return true if given C::f as the method 1348226586Sdim/// and { A } as the set of bases. 1349261991Sdimstatic bool OverridesIndirectMethodInBases( 1350261991Sdim const CXXMethodDecl *MD, 1351261991Sdim ItaniumVTableBuilder::PrimaryBasesSetVectorTy &Bases) { 1352226586Sdim if (Bases.count(MD->getParent())) 1353226586Sdim return true; 1354226586Sdim 1355226586Sdim for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 1356226586Sdim E = MD->end_overridden_methods(); I != E; ++I) { 1357226586Sdim const CXXMethodDecl *OverriddenMD = *I; 1358226586Sdim 1359226586Sdim // Check "indirect overriders". 1360226586Sdim if (OverridesIndirectMethodInBases(OverriddenMD, Bases)) 1361226586Sdim return true; 1362226586Sdim } 1363226586Sdim 1364226586Sdim return false; 1365226586Sdim} 1366226586Sdim 1367261991Sdimbool ItaniumVTableBuilder::IsOverriderUsed( 1368261991Sdim const CXXMethodDecl *Overrider, CharUnits BaseOffsetInLayoutClass, 1369261991Sdim const CXXRecordDecl *FirstBaseInPrimaryBaseChain, 1370261991Sdim CharUnits FirstBaseOffsetInLayoutClass) const { 1371226586Sdim // If the base and the first base in the primary base chain have the same 1372226586Sdim // offsets, then this overrider will be used. 1373226586Sdim if (BaseOffsetInLayoutClass == FirstBaseOffsetInLayoutClass) 1374226586Sdim return true; 1375226586Sdim 1376226586Sdim // We know now that Base (or a direct or indirect base of it) is a primary 1377226586Sdim // base in part of the class hierarchy, but not a primary base in the most 1378226586Sdim // derived class. 1379226586Sdim 1380226586Sdim // If the overrider is the first base in the primary base chain, we know 1381226586Sdim // that the overrider will be used. 1382226586Sdim if (Overrider->getParent() == FirstBaseInPrimaryBaseChain) 1383226586Sdim return true; 1384226586Sdim 1385261991Sdim ItaniumVTableBuilder::PrimaryBasesSetVectorTy PrimaryBases; 1386261991Sdim 1387226586Sdim const CXXRecordDecl *RD = FirstBaseInPrimaryBaseChain; 1388226586Sdim PrimaryBases.insert(RD); 1389226586Sdim 1390226586Sdim // Now traverse the base chain, starting with the first base, until we find 1391226586Sdim // the base that is no longer a primary base. 1392226586Sdim while (true) { 1393226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1394226586Sdim const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 1395226586Sdim 1396226586Sdim if (!PrimaryBase) 1397226586Sdim break; 1398226586Sdim 1399226586Sdim if (Layout.isPrimaryBaseVirtual()) { 1400239462Sdim assert(Layout.getVBaseClassOffset(PrimaryBase).isZero() && 1401226586Sdim "Primary base should always be at offset 0!"); 1402226586Sdim 1403226586Sdim const ASTRecordLayout &LayoutClassLayout = 1404226586Sdim Context.getASTRecordLayout(LayoutClass); 1405226586Sdim 1406226586Sdim // Now check if this is the primary base that is not a primary base in the 1407226586Sdim // most derived class. 1408226586Sdim if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) != 1409226586Sdim FirstBaseOffsetInLayoutClass) { 1410226586Sdim // We found it, stop walking the chain. 1411226586Sdim break; 1412226586Sdim } 1413226586Sdim } else { 1414239462Sdim assert(Layout.getBaseClassOffset(PrimaryBase).isZero() && 1415226586Sdim "Primary base should always be at offset 0!"); 1416226586Sdim } 1417226586Sdim 1418226586Sdim if (!PrimaryBases.insert(PrimaryBase)) 1419226586Sdim llvm_unreachable("Found a duplicate primary base!"); 1420226586Sdim 1421226586Sdim RD = PrimaryBase; 1422226586Sdim } 1423226586Sdim 1424226586Sdim // If the final overrider is an override of one of the primary bases, 1425226586Sdim // then we know that it will be used. 1426226586Sdim return OverridesIndirectMethodInBases(Overrider, PrimaryBases); 1427226586Sdim} 1428226586Sdim 1429261991Sdimtypedef llvm::SmallSetVector<const CXXRecordDecl *, 8> BasesSetVectorTy; 1430261991Sdim 1431226586Sdim/// FindNearestOverriddenMethod - Given a method, returns the overridden method 1432226586Sdim/// from the nearest base. Returns null if no method was found. 1433261991Sdim/// The Bases are expected to be sorted in a base-to-derived order. 1434261991Sdimstatic const CXXMethodDecl * 1435226586SdimFindNearestOverriddenMethod(const CXXMethodDecl *MD, 1436261991Sdim BasesSetVectorTy &Bases) { 1437226586Sdim OverriddenMethodsSetTy OverriddenMethods; 1438226586Sdim ComputeAllOverriddenMethods(MD, OverriddenMethods); 1439226586Sdim 1440226586Sdim for (int I = Bases.size(), E = 0; I != E; --I) { 1441226586Sdim const CXXRecordDecl *PrimaryBase = Bases[I - 1]; 1442226586Sdim 1443261991Sdim // Now check the overridden methods. 1444226586Sdim for (OverriddenMethodsSetTy::const_iterator I = OverriddenMethods.begin(), 1445226586Sdim E = OverriddenMethods.end(); I != E; ++I) { 1446226586Sdim const CXXMethodDecl *OverriddenMD = *I; 1447226586Sdim 1448226586Sdim // We found our overridden method. 1449226586Sdim if (OverriddenMD->getParent() == PrimaryBase) 1450226586Sdim return OverriddenMD; 1451226586Sdim } 1452226586Sdim } 1453276479Sdim 1454276479Sdim return nullptr; 1455261991Sdim} 1456226586Sdim 1457261991Sdimvoid ItaniumVTableBuilder::AddMethods( 1458261991Sdim BaseSubobject Base, CharUnits BaseOffsetInLayoutClass, 1459261991Sdim const CXXRecordDecl *FirstBaseInPrimaryBaseChain, 1460261991Sdim CharUnits FirstBaseOffsetInLayoutClass, 1461261991Sdim PrimaryBasesSetVectorTy &PrimaryBases) { 1462261991Sdim // Itanium C++ ABI 2.5.2: 1463261991Sdim // The order of the virtual function pointers in a virtual table is the 1464261991Sdim // order of declaration of the corresponding member functions in the class. 1465261991Sdim // 1466261991Sdim // There is an entry for any virtual function declared in a class, 1467261991Sdim // whether it is a new function or overrides a base class function, 1468261991Sdim // unless it overrides a function from the primary base, and conversion 1469261991Sdim // between their return types does not require an adjustment. 1470261991Sdim 1471226586Sdim const CXXRecordDecl *RD = Base.getBase(); 1472226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1473226586Sdim 1474226586Sdim if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) { 1475226586Sdim CharUnits PrimaryBaseOffset; 1476226586Sdim CharUnits PrimaryBaseOffsetInLayoutClass; 1477226586Sdim if (Layout.isPrimaryBaseVirtual()) { 1478239462Sdim assert(Layout.getVBaseClassOffset(PrimaryBase).isZero() && 1479226586Sdim "Primary vbase should have a zero offset!"); 1480226586Sdim 1481226586Sdim const ASTRecordLayout &MostDerivedClassLayout = 1482226586Sdim Context.getASTRecordLayout(MostDerivedClass); 1483226586Sdim 1484226586Sdim PrimaryBaseOffset = 1485226586Sdim MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase); 1486226586Sdim 1487226586Sdim const ASTRecordLayout &LayoutClassLayout = 1488226586Sdim Context.getASTRecordLayout(LayoutClass); 1489226586Sdim 1490226586Sdim PrimaryBaseOffsetInLayoutClass = 1491226586Sdim LayoutClassLayout.getVBaseClassOffset(PrimaryBase); 1492226586Sdim } else { 1493239462Sdim assert(Layout.getBaseClassOffset(PrimaryBase).isZero() && 1494226586Sdim "Primary base should have a zero offset!"); 1495226586Sdim 1496226586Sdim PrimaryBaseOffset = Base.getBaseOffset(); 1497226586Sdim PrimaryBaseOffsetInLayoutClass = BaseOffsetInLayoutClass; 1498226586Sdim } 1499226586Sdim 1500226586Sdim AddMethods(BaseSubobject(PrimaryBase, PrimaryBaseOffset), 1501226586Sdim PrimaryBaseOffsetInLayoutClass, FirstBaseInPrimaryBaseChain, 1502226586Sdim FirstBaseOffsetInLayoutClass, PrimaryBases); 1503226586Sdim 1504226586Sdim if (!PrimaryBases.insert(PrimaryBase)) 1505226586Sdim llvm_unreachable("Found a duplicate primary base!"); 1506226586Sdim } 1507226586Sdim 1508276479Sdim const CXXDestructorDecl *ImplicitVirtualDtor = nullptr; 1509261991Sdim 1510261991Sdim typedef llvm::SmallVector<const CXXMethodDecl *, 8> NewVirtualFunctionsTy; 1511261991Sdim NewVirtualFunctionsTy NewVirtualFunctions; 1512261991Sdim 1513226586Sdim // Now go through all virtual member functions and add them. 1514276479Sdim for (const auto *MD : RD->methods()) { 1515226586Sdim if (!MD->isVirtual()) 1516226586Sdim continue; 1517226586Sdim 1518226586Sdim // Get the final overrider. 1519226586Sdim FinalOverriders::OverriderInfo Overrider = 1520226586Sdim Overriders.getOverrider(MD, Base.getBaseOffset()); 1521226586Sdim 1522226586Sdim // Check if this virtual member function overrides a method in a primary 1523226586Sdim // base. If this is the case, and the return type doesn't require adjustment 1524226586Sdim // then we can just use the member function from the primary base. 1525226586Sdim if (const CXXMethodDecl *OverriddenMD = 1526226586Sdim FindNearestOverriddenMethod(MD, PrimaryBases)) { 1527226586Sdim if (ComputeReturnAdjustmentBaseOffset(Context, MD, 1528226586Sdim OverriddenMD).isEmpty()) { 1529226586Sdim // Replace the method info of the overridden method with our own 1530226586Sdim // method. 1531226586Sdim assert(MethodInfoMap.count(OverriddenMD) && 1532226586Sdim "Did not find the overridden method!"); 1533226586Sdim MethodInfo &OverriddenMethodInfo = MethodInfoMap[OverriddenMD]; 1534226586Sdim 1535226586Sdim MethodInfo MethodInfo(Base.getBaseOffset(), BaseOffsetInLayoutClass, 1536226586Sdim OverriddenMethodInfo.VTableIndex); 1537226586Sdim 1538226586Sdim assert(!MethodInfoMap.count(MD) && 1539226586Sdim "Should not have method info for this method yet!"); 1540226586Sdim 1541226586Sdim MethodInfoMap.insert(std::make_pair(MD, MethodInfo)); 1542226586Sdim MethodInfoMap.erase(OverriddenMD); 1543226586Sdim 1544226586Sdim // If the overridden method exists in a virtual base class or a direct 1545226586Sdim // or indirect base class of a virtual base class, we need to emit a 1546226586Sdim // thunk if we ever have a class hierarchy where the base class is not 1547226586Sdim // a primary base in the complete object. 1548226586Sdim if (!isBuildingConstructorVTable() && OverriddenMD != MD) { 1549226586Sdim // Compute the this adjustment. 1550226586Sdim ThisAdjustment ThisAdjustment = 1551226586Sdim ComputeThisAdjustment(OverriddenMD, BaseOffsetInLayoutClass, 1552226586Sdim Overrider); 1553226586Sdim 1554261991Sdim if (ThisAdjustment.Virtual.Itanium.VCallOffsetOffset && 1555226586Sdim Overrider.Method->getParent() == MostDerivedClass) { 1556226586Sdim 1557226586Sdim // There's no return adjustment from OverriddenMD and MD, 1558226586Sdim // but that doesn't mean there isn't one between MD and 1559226586Sdim // the final overrider. 1560226586Sdim BaseOffset ReturnAdjustmentOffset = 1561226586Sdim ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method, MD); 1562226586Sdim ReturnAdjustment ReturnAdjustment = 1563226586Sdim ComputeReturnAdjustment(ReturnAdjustmentOffset); 1564226586Sdim 1565226586Sdim // This is a virtual thunk for the most derived class, add it. 1566226586Sdim AddThunk(Overrider.Method, 1567226586Sdim ThunkInfo(ThisAdjustment, ReturnAdjustment)); 1568226586Sdim } 1569226586Sdim } 1570226586Sdim 1571226586Sdim continue; 1572226586Sdim } 1573226586Sdim } 1574226586Sdim 1575261991Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 1576261991Sdim if (MD->isImplicit()) { 1577261991Sdim // Itanium C++ ABI 2.5.2: 1578261991Sdim // If a class has an implicitly-defined virtual destructor, 1579261991Sdim // its entries come after the declared virtual function pointers. 1580261991Sdim 1581261991Sdim assert(!ImplicitVirtualDtor && 1582261991Sdim "Did already see an implicit virtual dtor!"); 1583261991Sdim ImplicitVirtualDtor = DD; 1584261991Sdim continue; 1585261991Sdim } 1586261991Sdim } 1587261991Sdim 1588261991Sdim NewVirtualFunctions.push_back(MD); 1589261991Sdim } 1590261991Sdim 1591261991Sdim if (ImplicitVirtualDtor) 1592261991Sdim NewVirtualFunctions.push_back(ImplicitVirtualDtor); 1593261991Sdim 1594261991Sdim for (NewVirtualFunctionsTy::const_iterator I = NewVirtualFunctions.begin(), 1595261991Sdim E = NewVirtualFunctions.end(); I != E; ++I) { 1596261991Sdim const CXXMethodDecl *MD = *I; 1597261991Sdim 1598261991Sdim // Get the final overrider. 1599261991Sdim FinalOverriders::OverriderInfo Overrider = 1600261991Sdim Overriders.getOverrider(MD, Base.getBaseOffset()); 1601261991Sdim 1602226586Sdim // Insert the method info for this method. 1603226586Sdim MethodInfo MethodInfo(Base.getBaseOffset(), BaseOffsetInLayoutClass, 1604226586Sdim Components.size()); 1605226586Sdim 1606226586Sdim assert(!MethodInfoMap.count(MD) && 1607226586Sdim "Should not have method info for this method yet!"); 1608226586Sdim MethodInfoMap.insert(std::make_pair(MD, MethodInfo)); 1609226586Sdim 1610226586Sdim // Check if this overrider is going to be used. 1611226586Sdim const CXXMethodDecl *OverriderMD = Overrider.Method; 1612226586Sdim if (!IsOverriderUsed(OverriderMD, BaseOffsetInLayoutClass, 1613226586Sdim FirstBaseInPrimaryBaseChain, 1614226586Sdim FirstBaseOffsetInLayoutClass)) { 1615226586Sdim Components.push_back(VTableComponent::MakeUnusedFunction(OverriderMD)); 1616226586Sdim continue; 1617226586Sdim } 1618261991Sdim 1619226586Sdim // Check if this overrider needs a return adjustment. 1620226586Sdim // We don't want to do this for pure virtual member functions. 1621226586Sdim BaseOffset ReturnAdjustmentOffset; 1622226586Sdim if (!OverriderMD->isPure()) { 1623226586Sdim ReturnAdjustmentOffset = 1624226586Sdim ComputeReturnAdjustmentBaseOffset(Context, OverriderMD, MD); 1625226586Sdim } 1626226586Sdim 1627226586Sdim ReturnAdjustment ReturnAdjustment = 1628226586Sdim ComputeReturnAdjustment(ReturnAdjustmentOffset); 1629226586Sdim 1630226586Sdim AddMethod(Overrider.Method, ReturnAdjustment); 1631226586Sdim } 1632226586Sdim} 1633226586Sdim 1634261991Sdimvoid ItaniumVTableBuilder::LayoutVTable() { 1635226586Sdim LayoutPrimaryAndSecondaryVTables(BaseSubobject(MostDerivedClass, 1636226586Sdim CharUnits::Zero()), 1637226586Sdim /*BaseIsMorallyVirtual=*/false, 1638226586Sdim MostDerivedClassIsVirtual, 1639226586Sdim MostDerivedClassOffset); 1640226586Sdim 1641226586Sdim VisitedVirtualBasesSetTy VBases; 1642226586Sdim 1643226586Sdim // Determine the primary virtual bases. 1644226586Sdim DeterminePrimaryVirtualBases(MostDerivedClass, MostDerivedClassOffset, 1645226586Sdim VBases); 1646226586Sdim VBases.clear(); 1647226586Sdim 1648226586Sdim LayoutVTablesForVirtualBases(MostDerivedClass, VBases); 1649226586Sdim 1650226586Sdim // -fapple-kext adds an extra entry at end of vtbl. 1651234353Sdim bool IsAppleKext = Context.getLangOpts().AppleKext; 1652226586Sdim if (IsAppleKext) 1653226586Sdim Components.push_back(VTableComponent::MakeVCallOffset(CharUnits::Zero())); 1654226586Sdim} 1655261991Sdim 1656261991Sdimvoid ItaniumVTableBuilder::LayoutPrimaryAndSecondaryVTables( 1657261991Sdim BaseSubobject Base, bool BaseIsMorallyVirtual, 1658261991Sdim bool BaseIsVirtualInLayoutClass, CharUnits OffsetInLayoutClass) { 1659226586Sdim assert(Base.getBase()->isDynamicClass() && "class does not have a vtable!"); 1660226586Sdim 1661226586Sdim // Add vcall and vbase offsets for this vtable. 1662226586Sdim VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, LayoutClass, &Overriders, 1663226586Sdim Base, BaseIsVirtualInLayoutClass, 1664226586Sdim OffsetInLayoutClass); 1665226586Sdim Components.append(Builder.components_begin(), Builder.components_end()); 1666226586Sdim 1667226586Sdim // Check if we need to add these vcall offsets. 1668226586Sdim if (BaseIsVirtualInLayoutClass && !Builder.getVCallOffsets().empty()) { 1669226586Sdim VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Base.getBase()]; 1670226586Sdim 1671226586Sdim if (VCallOffsets.empty()) 1672226586Sdim VCallOffsets = Builder.getVCallOffsets(); 1673226586Sdim } 1674226586Sdim 1675226586Sdim // If we're laying out the most derived class we want to keep track of the 1676226586Sdim // virtual base class offset offsets. 1677226586Sdim if (Base.getBase() == MostDerivedClass) 1678226586Sdim VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets(); 1679226586Sdim 1680261991Sdim // Add the offset to top. 1681261991Sdim CharUnits OffsetToTop = MostDerivedClassOffset - OffsetInLayoutClass; 1682261991Sdim Components.push_back(VTableComponent::MakeOffsetToTop(OffsetToTop)); 1683249423Sdim 1684261991Sdim // Next, add the RTTI. 1685261991Sdim Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass)); 1686249423Sdim 1687226586Sdim uint64_t AddressPoint = Components.size(); 1688226586Sdim 1689226586Sdim // Now go through all virtual member functions and add them. 1690226586Sdim PrimaryBasesSetVectorTy PrimaryBases; 1691226586Sdim AddMethods(Base, OffsetInLayoutClass, 1692226586Sdim Base.getBase(), OffsetInLayoutClass, 1693226586Sdim PrimaryBases); 1694226586Sdim 1695261991Sdim const CXXRecordDecl *RD = Base.getBase(); 1696261991Sdim if (RD == MostDerivedClass) { 1697261991Sdim assert(MethodVTableIndices.empty()); 1698261991Sdim for (MethodInfoMapTy::const_iterator I = MethodInfoMap.begin(), 1699261991Sdim E = MethodInfoMap.end(); I != E; ++I) { 1700261991Sdim const CXXMethodDecl *MD = I->first; 1701261991Sdim const MethodInfo &MI = I->second; 1702261991Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 1703261991Sdim MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] 1704261991Sdim = MI.VTableIndex - AddressPoint; 1705261991Sdim MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] 1706261991Sdim = MI.VTableIndex + 1 - AddressPoint; 1707261991Sdim } else { 1708261991Sdim MethodVTableIndices[MD] = MI.VTableIndex - AddressPoint; 1709261991Sdim } 1710261991Sdim } 1711261991Sdim } 1712261991Sdim 1713226586Sdim // Compute 'this' pointer adjustments. 1714226586Sdim ComputeThisAdjustments(); 1715226586Sdim 1716226586Sdim // Add all address points. 1717226586Sdim while (true) { 1718226586Sdim AddressPoints.insert(std::make_pair( 1719226586Sdim BaseSubobject(RD, OffsetInLayoutClass), 1720226586Sdim AddressPoint)); 1721226586Sdim 1722226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1723226586Sdim const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 1724226586Sdim 1725226586Sdim if (!PrimaryBase) 1726226586Sdim break; 1727226586Sdim 1728226586Sdim if (Layout.isPrimaryBaseVirtual()) { 1729226586Sdim // Check if this virtual primary base is a primary base in the layout 1730226586Sdim // class. If it's not, we don't want to add it. 1731226586Sdim const ASTRecordLayout &LayoutClassLayout = 1732226586Sdim Context.getASTRecordLayout(LayoutClass); 1733226586Sdim 1734226586Sdim if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) != 1735226586Sdim OffsetInLayoutClass) { 1736226586Sdim // We don't want to add this class (or any of its primary bases). 1737226586Sdim break; 1738226586Sdim } 1739226586Sdim } 1740226586Sdim 1741226586Sdim RD = PrimaryBase; 1742226586Sdim } 1743226586Sdim 1744226586Sdim // Layout secondary vtables. 1745226586Sdim LayoutSecondaryVTables(Base, BaseIsMorallyVirtual, OffsetInLayoutClass); 1746226586Sdim} 1747226586Sdim 1748261991Sdimvoid 1749261991SdimItaniumVTableBuilder::LayoutSecondaryVTables(BaseSubobject Base, 1750261991Sdim bool BaseIsMorallyVirtual, 1751261991Sdim CharUnits OffsetInLayoutClass) { 1752226586Sdim // Itanium C++ ABI 2.5.2: 1753226586Sdim // Following the primary virtual table of a derived class are secondary 1754226586Sdim // virtual tables for each of its proper base classes, except any primary 1755226586Sdim // base(s) with which it shares its primary virtual table. 1756226586Sdim 1757226586Sdim const CXXRecordDecl *RD = Base.getBase(); 1758226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1759226586Sdim const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 1760226586Sdim 1761276479Sdim for (const auto &B : RD->bases()) { 1762226586Sdim // Ignore virtual bases, we'll emit them later. 1763276479Sdim if (B.isVirtual()) 1764226586Sdim continue; 1765226586Sdim 1766276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 1767226586Sdim 1768226586Sdim // Ignore bases that don't have a vtable. 1769226586Sdim if (!BaseDecl->isDynamicClass()) 1770226586Sdim continue; 1771226586Sdim 1772226586Sdim if (isBuildingConstructorVTable()) { 1773226586Sdim // Itanium C++ ABI 2.6.4: 1774226586Sdim // Some of the base class subobjects may not need construction virtual 1775226586Sdim // tables, which will therefore not be present in the construction 1776226586Sdim // virtual table group, even though the subobject virtual tables are 1777226586Sdim // present in the main virtual table group for the complete object. 1778226586Sdim if (!BaseIsMorallyVirtual && !BaseDecl->getNumVBases()) 1779226586Sdim continue; 1780226586Sdim } 1781226586Sdim 1782226586Sdim // Get the base offset of this base. 1783226586Sdim CharUnits RelativeBaseOffset = Layout.getBaseClassOffset(BaseDecl); 1784226586Sdim CharUnits BaseOffset = Base.getBaseOffset() + RelativeBaseOffset; 1785226586Sdim 1786226586Sdim CharUnits BaseOffsetInLayoutClass = 1787226586Sdim OffsetInLayoutClass + RelativeBaseOffset; 1788226586Sdim 1789226586Sdim // Don't emit a secondary vtable for a primary base. We might however want 1790226586Sdim // to emit secondary vtables for other bases of this base. 1791226586Sdim if (BaseDecl == PrimaryBase) { 1792226586Sdim LayoutSecondaryVTables(BaseSubobject(BaseDecl, BaseOffset), 1793226586Sdim BaseIsMorallyVirtual, BaseOffsetInLayoutClass); 1794226586Sdim continue; 1795226586Sdim } 1796226586Sdim 1797226586Sdim // Layout the primary vtable (and any secondary vtables) for this base. 1798226586Sdim LayoutPrimaryAndSecondaryVTables( 1799226586Sdim BaseSubobject(BaseDecl, BaseOffset), 1800226586Sdim BaseIsMorallyVirtual, 1801226586Sdim /*BaseIsVirtualInLayoutClass=*/false, 1802226586Sdim BaseOffsetInLayoutClass); 1803226586Sdim } 1804226586Sdim} 1805226586Sdim 1806261991Sdimvoid ItaniumVTableBuilder::DeterminePrimaryVirtualBases( 1807261991Sdim const CXXRecordDecl *RD, CharUnits OffsetInLayoutClass, 1808261991Sdim VisitedVirtualBasesSetTy &VBases) { 1809226586Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1810226586Sdim 1811226586Sdim // Check if this base has a primary base. 1812226586Sdim if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) { 1813226586Sdim 1814226586Sdim // Check if it's virtual. 1815226586Sdim if (Layout.isPrimaryBaseVirtual()) { 1816226586Sdim bool IsPrimaryVirtualBase = true; 1817226586Sdim 1818226586Sdim if (isBuildingConstructorVTable()) { 1819226586Sdim // Check if the base is actually a primary base in the class we use for 1820226586Sdim // layout. 1821226586Sdim const ASTRecordLayout &LayoutClassLayout = 1822226586Sdim Context.getASTRecordLayout(LayoutClass); 1823226586Sdim 1824226586Sdim CharUnits PrimaryBaseOffsetInLayoutClass = 1825226586Sdim LayoutClassLayout.getVBaseClassOffset(PrimaryBase); 1826226586Sdim 1827226586Sdim // We know that the base is not a primary base in the layout class if 1828226586Sdim // the base offsets are different. 1829226586Sdim if (PrimaryBaseOffsetInLayoutClass != OffsetInLayoutClass) 1830226586Sdim IsPrimaryVirtualBase = false; 1831226586Sdim } 1832226586Sdim 1833226586Sdim if (IsPrimaryVirtualBase) 1834226586Sdim PrimaryVirtualBases.insert(PrimaryBase); 1835226586Sdim } 1836226586Sdim } 1837226586Sdim 1838226586Sdim // Traverse bases, looking for more primary virtual bases. 1839276479Sdim for (const auto &B : RD->bases()) { 1840276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 1841226586Sdim 1842226586Sdim CharUnits BaseOffsetInLayoutClass; 1843226586Sdim 1844276479Sdim if (B.isVirtual()) { 1845226586Sdim if (!VBases.insert(BaseDecl)) 1846226586Sdim continue; 1847226586Sdim 1848226586Sdim const ASTRecordLayout &LayoutClassLayout = 1849226586Sdim Context.getASTRecordLayout(LayoutClass); 1850226586Sdim 1851226586Sdim BaseOffsetInLayoutClass = 1852226586Sdim LayoutClassLayout.getVBaseClassOffset(BaseDecl); 1853226586Sdim } else { 1854226586Sdim BaseOffsetInLayoutClass = 1855226586Sdim OffsetInLayoutClass + Layout.getBaseClassOffset(BaseDecl); 1856226586Sdim } 1857226586Sdim 1858226586Sdim DeterminePrimaryVirtualBases(BaseDecl, BaseOffsetInLayoutClass, VBases); 1859226586Sdim } 1860226586Sdim} 1861226586Sdim 1862261991Sdimvoid ItaniumVTableBuilder::LayoutVTablesForVirtualBases( 1863261991Sdim const CXXRecordDecl *RD, VisitedVirtualBasesSetTy &VBases) { 1864226586Sdim // Itanium C++ ABI 2.5.2: 1865226586Sdim // Then come the virtual base virtual tables, also in inheritance graph 1866226586Sdim // order, and again excluding primary bases (which share virtual tables with 1867226586Sdim // the classes for which they are primary). 1868276479Sdim for (const auto &B : RD->bases()) { 1869276479Sdim const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl(); 1870226586Sdim 1871226586Sdim // Check if this base needs a vtable. (If it's virtual, not a primary base 1872226586Sdim // of some other class, and we haven't visited it before). 1873276479Sdim if (B.isVirtual() && BaseDecl->isDynamicClass() && 1874226586Sdim !PrimaryVirtualBases.count(BaseDecl) && VBases.insert(BaseDecl)) { 1875226586Sdim const ASTRecordLayout &MostDerivedClassLayout = 1876226586Sdim Context.getASTRecordLayout(MostDerivedClass); 1877226586Sdim CharUnits BaseOffset = 1878226586Sdim MostDerivedClassLayout.getVBaseClassOffset(BaseDecl); 1879226586Sdim 1880226586Sdim const ASTRecordLayout &LayoutClassLayout = 1881226586Sdim Context.getASTRecordLayout(LayoutClass); 1882226586Sdim CharUnits BaseOffsetInLayoutClass = 1883226586Sdim LayoutClassLayout.getVBaseClassOffset(BaseDecl); 1884226586Sdim 1885226586Sdim LayoutPrimaryAndSecondaryVTables( 1886226586Sdim BaseSubobject(BaseDecl, BaseOffset), 1887226586Sdim /*BaseIsMorallyVirtual=*/true, 1888226586Sdim /*BaseIsVirtualInLayoutClass=*/true, 1889226586Sdim BaseOffsetInLayoutClass); 1890226586Sdim } 1891226586Sdim 1892226586Sdim // We only need to check the base for virtual base vtables if it actually 1893226586Sdim // has virtual bases. 1894226586Sdim if (BaseDecl->getNumVBases()) 1895226586Sdim LayoutVTablesForVirtualBases(BaseDecl, VBases); 1896226586Sdim } 1897226586Sdim} 1898226586Sdim 1899226586Sdim/// dumpLayout - Dump the vtable layout. 1900261991Sdimvoid ItaniumVTableBuilder::dumpLayout(raw_ostream &Out) { 1901261991Sdim // FIXME: write more tests that actually use the dumpLayout output to prevent 1902261991Sdim // ItaniumVTableBuilder regressions. 1903226586Sdim 1904226586Sdim if (isBuildingConstructorVTable()) { 1905226586Sdim Out << "Construction vtable for ('"; 1906276479Sdim MostDerivedClass->printQualifiedName(Out); 1907276479Sdim Out << "', "; 1908226586Sdim Out << MostDerivedClassOffset.getQuantity() << ") in '"; 1909276479Sdim LayoutClass->printQualifiedName(Out); 1910226586Sdim } else { 1911226586Sdim Out << "Vtable for '"; 1912276479Sdim MostDerivedClass->printQualifiedName(Out); 1913226586Sdim } 1914226586Sdim Out << "' (" << Components.size() << " entries).\n"; 1915226586Sdim 1916226586Sdim // Iterate through the address points and insert them into a new map where 1917226586Sdim // they are keyed by the index and not the base object. 1918226586Sdim // Since an address point can be shared by multiple subobjects, we use an 1919226586Sdim // STL multimap. 1920226586Sdim std::multimap<uint64_t, BaseSubobject> AddressPointsByIndex; 1921226586Sdim for (AddressPointsMapTy::const_iterator I = AddressPoints.begin(), 1922226586Sdim E = AddressPoints.end(); I != E; ++I) { 1923226586Sdim const BaseSubobject& Base = I->first; 1924226586Sdim uint64_t Index = I->second; 1925226586Sdim 1926226586Sdim AddressPointsByIndex.insert(std::make_pair(Index, Base)); 1927226586Sdim } 1928226586Sdim 1929226586Sdim for (unsigned I = 0, E = Components.size(); I != E; ++I) { 1930226586Sdim uint64_t Index = I; 1931226586Sdim 1932226586Sdim Out << llvm::format("%4d | ", I); 1933226586Sdim 1934226586Sdim const VTableComponent &Component = Components[I]; 1935226586Sdim 1936226586Sdim // Dump the component. 1937226586Sdim switch (Component.getKind()) { 1938226586Sdim 1939226586Sdim case VTableComponent::CK_VCallOffset: 1940226586Sdim Out << "vcall_offset (" 1941226586Sdim << Component.getVCallOffset().getQuantity() 1942226586Sdim << ")"; 1943226586Sdim break; 1944226586Sdim 1945226586Sdim case VTableComponent::CK_VBaseOffset: 1946226586Sdim Out << "vbase_offset (" 1947226586Sdim << Component.getVBaseOffset().getQuantity() 1948226586Sdim << ")"; 1949226586Sdim break; 1950226586Sdim 1951226586Sdim case VTableComponent::CK_OffsetToTop: 1952226586Sdim Out << "offset_to_top (" 1953226586Sdim << Component.getOffsetToTop().getQuantity() 1954226586Sdim << ")"; 1955226586Sdim break; 1956226586Sdim 1957226586Sdim case VTableComponent::CK_RTTI: 1958276479Sdim Component.getRTTIDecl()->printQualifiedName(Out); 1959276479Sdim Out << " RTTI"; 1960226586Sdim break; 1961226586Sdim 1962226586Sdim case VTableComponent::CK_FunctionPointer: { 1963226586Sdim const CXXMethodDecl *MD = Component.getFunctionDecl(); 1964226586Sdim 1965226586Sdim std::string Str = 1966226586Sdim PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual, 1967226586Sdim MD); 1968226586Sdim Out << Str; 1969226586Sdim if (MD->isPure()) 1970226586Sdim Out << " [pure]"; 1971226586Sdim 1972243830Sdim if (MD->isDeleted()) 1973243830Sdim Out << " [deleted]"; 1974243830Sdim 1975226586Sdim ThunkInfo Thunk = VTableThunks.lookup(I); 1976226586Sdim if (!Thunk.isEmpty()) { 1977226586Sdim // If this function pointer has a return adjustment, dump it. 1978226586Sdim if (!Thunk.Return.isEmpty()) { 1979226586Sdim Out << "\n [return adjustment: "; 1980226586Sdim Out << Thunk.Return.NonVirtual << " non-virtual"; 1981226586Sdim 1982261991Sdim if (Thunk.Return.Virtual.Itanium.VBaseOffsetOffset) { 1983261991Sdim Out << ", " << Thunk.Return.Virtual.Itanium.VBaseOffsetOffset; 1984226586Sdim Out << " vbase offset offset"; 1985226586Sdim } 1986226586Sdim 1987226586Sdim Out << ']'; 1988226586Sdim } 1989226586Sdim 1990226586Sdim // If this function pointer has a 'this' pointer adjustment, dump it. 1991226586Sdim if (!Thunk.This.isEmpty()) { 1992226586Sdim Out << "\n [this adjustment: "; 1993226586Sdim Out << Thunk.This.NonVirtual << " non-virtual"; 1994226586Sdim 1995261991Sdim if (Thunk.This.Virtual.Itanium.VCallOffsetOffset) { 1996261991Sdim Out << ", " << Thunk.This.Virtual.Itanium.VCallOffsetOffset; 1997226586Sdim Out << " vcall offset offset"; 1998226586Sdim } 1999226586Sdim 2000226586Sdim Out << ']'; 2001226586Sdim } 2002226586Sdim } 2003226586Sdim 2004226586Sdim break; 2005226586Sdim } 2006226586Sdim 2007226586Sdim case VTableComponent::CK_CompleteDtorPointer: 2008226586Sdim case VTableComponent::CK_DeletingDtorPointer: { 2009226586Sdim bool IsComplete = 2010226586Sdim Component.getKind() == VTableComponent::CK_CompleteDtorPointer; 2011226586Sdim 2012226586Sdim const CXXDestructorDecl *DD = Component.getDestructorDecl(); 2013226586Sdim 2014276479Sdim DD->printQualifiedName(Out); 2015226586Sdim if (IsComplete) 2016226586Sdim Out << "() [complete]"; 2017226586Sdim else 2018226586Sdim Out << "() [deleting]"; 2019226586Sdim 2020226586Sdim if (DD->isPure()) 2021226586Sdim Out << " [pure]"; 2022226586Sdim 2023226586Sdim ThunkInfo Thunk = VTableThunks.lookup(I); 2024226586Sdim if (!Thunk.isEmpty()) { 2025226586Sdim // If this destructor has a 'this' pointer adjustment, dump it. 2026226586Sdim if (!Thunk.This.isEmpty()) { 2027226586Sdim Out << "\n [this adjustment: "; 2028226586Sdim Out << Thunk.This.NonVirtual << " non-virtual"; 2029226586Sdim 2030261991Sdim if (Thunk.This.Virtual.Itanium.VCallOffsetOffset) { 2031261991Sdim Out << ", " << Thunk.This.Virtual.Itanium.VCallOffsetOffset; 2032226586Sdim Out << " vcall offset offset"; 2033226586Sdim } 2034226586Sdim 2035226586Sdim Out << ']'; 2036226586Sdim } 2037226586Sdim } 2038226586Sdim 2039226586Sdim break; 2040226586Sdim } 2041226586Sdim 2042226586Sdim case VTableComponent::CK_UnusedFunctionPointer: { 2043226586Sdim const CXXMethodDecl *MD = Component.getUnusedFunctionDecl(); 2044226586Sdim 2045226586Sdim std::string Str = 2046226586Sdim PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual, 2047226586Sdim MD); 2048226586Sdim Out << "[unused] " << Str; 2049226586Sdim if (MD->isPure()) 2050226586Sdim Out << " [pure]"; 2051226586Sdim } 2052226586Sdim 2053226586Sdim } 2054226586Sdim 2055226586Sdim Out << '\n'; 2056226586Sdim 2057226586Sdim // Dump the next address point. 2058226586Sdim uint64_t NextIndex = Index + 1; 2059226586Sdim if (AddressPointsByIndex.count(NextIndex)) { 2060226586Sdim if (AddressPointsByIndex.count(NextIndex) == 1) { 2061226586Sdim const BaseSubobject &Base = 2062226586Sdim AddressPointsByIndex.find(NextIndex)->second; 2063226586Sdim 2064276479Sdim Out << " -- ("; 2065276479Sdim Base.getBase()->printQualifiedName(Out); 2066226586Sdim Out << ", " << Base.getBaseOffset().getQuantity(); 2067226586Sdim Out << ") vtable address --\n"; 2068226586Sdim } else { 2069226586Sdim CharUnits BaseOffset = 2070226586Sdim AddressPointsByIndex.lower_bound(NextIndex)->second.getBaseOffset(); 2071226586Sdim 2072226586Sdim // We store the class names in a set to get a stable order. 2073226586Sdim std::set<std::string> ClassNames; 2074226586Sdim for (std::multimap<uint64_t, BaseSubobject>::const_iterator I = 2075226586Sdim AddressPointsByIndex.lower_bound(NextIndex), E = 2076226586Sdim AddressPointsByIndex.upper_bound(NextIndex); I != E; ++I) { 2077226586Sdim assert(I->second.getBaseOffset() == BaseOffset && 2078226586Sdim "Invalid base offset!"); 2079226586Sdim const CXXRecordDecl *RD = I->second.getBase(); 2080226586Sdim ClassNames.insert(RD->getQualifiedNameAsString()); 2081226586Sdim } 2082226586Sdim 2083226586Sdim for (std::set<std::string>::const_iterator I = ClassNames.begin(), 2084226586Sdim E = ClassNames.end(); I != E; ++I) { 2085226586Sdim Out << " -- (" << *I; 2086226586Sdim Out << ", " << BaseOffset.getQuantity() << ") vtable address --\n"; 2087226586Sdim } 2088226586Sdim } 2089226586Sdim } 2090226586Sdim } 2091226586Sdim 2092226586Sdim Out << '\n'; 2093226586Sdim 2094226586Sdim if (isBuildingConstructorVTable()) 2095226586Sdim return; 2096226586Sdim 2097226586Sdim if (MostDerivedClass->getNumVBases()) { 2098226586Sdim // We store the virtual base class names and their offsets in a map to get 2099226586Sdim // a stable order. 2100226586Sdim 2101226586Sdim std::map<std::string, CharUnits> ClassNamesAndOffsets; 2102226586Sdim for (VBaseOffsetOffsetsMapTy::const_iterator I = VBaseOffsetOffsets.begin(), 2103226586Sdim E = VBaseOffsetOffsets.end(); I != E; ++I) { 2104226586Sdim std::string ClassName = I->first->getQualifiedNameAsString(); 2105226586Sdim CharUnits OffsetOffset = I->second; 2106226586Sdim ClassNamesAndOffsets.insert( 2107226586Sdim std::make_pair(ClassName, OffsetOffset)); 2108226586Sdim } 2109226586Sdim 2110226586Sdim Out << "Virtual base offset offsets for '"; 2111276479Sdim MostDerivedClass->printQualifiedName(Out); 2112276479Sdim Out << "' ("; 2113226586Sdim Out << ClassNamesAndOffsets.size(); 2114226586Sdim Out << (ClassNamesAndOffsets.size() == 1 ? " entry" : " entries") << ").\n"; 2115226586Sdim 2116226586Sdim for (std::map<std::string, CharUnits>::const_iterator I = 2117226586Sdim ClassNamesAndOffsets.begin(), E = ClassNamesAndOffsets.end(); 2118226586Sdim I != E; ++I) 2119226586Sdim Out << " " << I->first << " | " << I->second.getQuantity() << '\n'; 2120226586Sdim 2121226586Sdim Out << "\n"; 2122226586Sdim } 2123226586Sdim 2124226586Sdim if (!Thunks.empty()) { 2125226586Sdim // We store the method names in a map to get a stable order. 2126226586Sdim std::map<std::string, const CXXMethodDecl *> MethodNamesAndDecls; 2127226586Sdim 2128226586Sdim for (ThunksMapTy::const_iterator I = Thunks.begin(), E = Thunks.end(); 2129226586Sdim I != E; ++I) { 2130226586Sdim const CXXMethodDecl *MD = I->first; 2131226586Sdim std::string MethodName = 2132226586Sdim PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual, 2133226586Sdim MD); 2134226586Sdim 2135226586Sdim MethodNamesAndDecls.insert(std::make_pair(MethodName, MD)); 2136226586Sdim } 2137226586Sdim 2138226586Sdim for (std::map<std::string, const CXXMethodDecl *>::const_iterator I = 2139226586Sdim MethodNamesAndDecls.begin(), E = MethodNamesAndDecls.end(); 2140226586Sdim I != E; ++I) { 2141226586Sdim const std::string &MethodName = I->first; 2142226586Sdim const CXXMethodDecl *MD = I->second; 2143226586Sdim 2144226586Sdim ThunkInfoVectorTy ThunksVector = Thunks[MD]; 2145261991Sdim std::sort(ThunksVector.begin(), ThunksVector.end(), 2146276479Sdim [](const ThunkInfo &LHS, const ThunkInfo &RHS) { 2147276479Sdim assert(LHS.Method == nullptr && RHS.Method == nullptr); 2148276479Sdim return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return); 2149276479Sdim }); 2150226586Sdim 2151226586Sdim Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size(); 2152226586Sdim Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n"; 2153226586Sdim 2154226586Sdim for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) { 2155226586Sdim const ThunkInfo &Thunk = ThunksVector[I]; 2156226586Sdim 2157226586Sdim Out << llvm::format("%4d | ", I); 2158226586Sdim 2159226586Sdim // If this function pointer has a return pointer adjustment, dump it. 2160226586Sdim if (!Thunk.Return.isEmpty()) { 2161261991Sdim Out << "return adjustment: " << Thunk.Return.NonVirtual; 2162226586Sdim Out << " non-virtual"; 2163261991Sdim if (Thunk.Return.Virtual.Itanium.VBaseOffsetOffset) { 2164261991Sdim Out << ", " << Thunk.Return.Virtual.Itanium.VBaseOffsetOffset; 2165226586Sdim Out << " vbase offset offset"; 2166226586Sdim } 2167226586Sdim 2168226586Sdim if (!Thunk.This.isEmpty()) 2169226586Sdim Out << "\n "; 2170226586Sdim } 2171226586Sdim 2172226586Sdim // If this function pointer has a 'this' pointer adjustment, dump it. 2173226586Sdim if (!Thunk.This.isEmpty()) { 2174226586Sdim Out << "this adjustment: "; 2175226586Sdim Out << Thunk.This.NonVirtual << " non-virtual"; 2176226586Sdim 2177261991Sdim if (Thunk.This.Virtual.Itanium.VCallOffsetOffset) { 2178261991Sdim Out << ", " << Thunk.This.Virtual.Itanium.VCallOffsetOffset; 2179226586Sdim Out << " vcall offset offset"; 2180226586Sdim } 2181226586Sdim } 2182226586Sdim 2183226586Sdim Out << '\n'; 2184226586Sdim } 2185226586Sdim 2186226586Sdim Out << '\n'; 2187226586Sdim } 2188226586Sdim } 2189226586Sdim 2190226586Sdim // Compute the vtable indices for all the member functions. 2191226586Sdim // Store them in a map keyed by the index so we'll get a sorted table. 2192226586Sdim std::map<uint64_t, std::string> IndicesMap; 2193226586Sdim 2194276479Sdim for (const auto *MD : MostDerivedClass->methods()) { 2195226586Sdim // We only want virtual member functions. 2196226586Sdim if (!MD->isVirtual()) 2197226586Sdim continue; 2198226586Sdim 2199226586Sdim std::string MethodName = 2200226586Sdim PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual, 2201226586Sdim MD); 2202226586Sdim 2203226586Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 2204261991Sdim GlobalDecl GD(DD, Dtor_Complete); 2205261991Sdim assert(MethodVTableIndices.count(GD)); 2206261991Sdim uint64_t VTableIndex = MethodVTableIndices[GD]; 2207261991Sdim IndicesMap[VTableIndex] = MethodName + " [complete]"; 2208261991Sdim IndicesMap[VTableIndex + 1] = MethodName + " [deleting]"; 2209226586Sdim } else { 2210261991Sdim assert(MethodVTableIndices.count(MD)); 2211261991Sdim IndicesMap[MethodVTableIndices[MD]] = MethodName; 2212226586Sdim } 2213226586Sdim } 2214226586Sdim 2215226586Sdim // Print the vtable indices for all the member functions. 2216226586Sdim if (!IndicesMap.empty()) { 2217226586Sdim Out << "VTable indices for '"; 2218276479Sdim MostDerivedClass->printQualifiedName(Out); 2219226586Sdim Out << "' (" << IndicesMap.size() << " entries).\n"; 2220226586Sdim 2221226586Sdim for (std::map<uint64_t, std::string>::const_iterator I = IndicesMap.begin(), 2222226586Sdim E = IndicesMap.end(); I != E; ++I) { 2223226586Sdim uint64_t VTableIndex = I->first; 2224226586Sdim const std::string &MethodName = I->second; 2225226586Sdim 2226261991Sdim Out << llvm::format("%4" PRIu64 " | ", VTableIndex) << MethodName 2227234353Sdim << '\n'; 2228226586Sdim } 2229226586Sdim } 2230226586Sdim 2231226586Sdim Out << '\n'; 2232226586Sdim} 2233226586Sdim} 2234226586Sdim 2235226586SdimVTableLayout::VTableLayout(uint64_t NumVTableComponents, 2236226586Sdim const VTableComponent *VTableComponents, 2237226586Sdim uint64_t NumVTableThunks, 2238226586Sdim const VTableThunkTy *VTableThunks, 2239249423Sdim const AddressPointsMapTy &AddressPoints, 2240249423Sdim bool IsMicrosoftABI) 2241226586Sdim : NumVTableComponents(NumVTableComponents), 2242226586Sdim VTableComponents(new VTableComponent[NumVTableComponents]), 2243226586Sdim NumVTableThunks(NumVTableThunks), 2244226586Sdim VTableThunks(new VTableThunkTy[NumVTableThunks]), 2245249423Sdim AddressPoints(AddressPoints), 2246249423Sdim IsMicrosoftABI(IsMicrosoftABI) { 2247226586Sdim std::copy(VTableComponents, VTableComponents+NumVTableComponents, 2248234982Sdim this->VTableComponents.get()); 2249234982Sdim std::copy(VTableThunks, VTableThunks+NumVTableThunks, 2250234982Sdim this->VTableThunks.get()); 2251261991Sdim std::sort(this->VTableThunks.get(), 2252261991Sdim this->VTableThunks.get() + NumVTableThunks, 2253276479Sdim [](const VTableLayout::VTableThunkTy &LHS, 2254276479Sdim const VTableLayout::VTableThunkTy &RHS) { 2255276479Sdim assert((LHS.first != RHS.first || LHS.second == RHS.second) && 2256276479Sdim "Different thunks should have unique indices!"); 2257276479Sdim return LHS.first < RHS.first; 2258276479Sdim }); 2259226586Sdim} 2260226586Sdim 2261234982SdimVTableLayout::~VTableLayout() { } 2262226586Sdim 2263261991SdimItaniumVTableContext::ItaniumVTableContext(ASTContext &Context) 2264276479Sdim : VTableContextBase(/*MS=*/false) {} 2265249423Sdim 2266261991SdimItaniumVTableContext::~ItaniumVTableContext() { 2267226586Sdim llvm::DeleteContainerSeconds(VTableLayouts); 2268226586Sdim} 2269226586Sdim 2270261991Sdimuint64_t ItaniumVTableContext::getMethodVTableIndex(GlobalDecl GD) { 2271226586Sdim MethodVTableIndicesTy::iterator I = MethodVTableIndices.find(GD); 2272226586Sdim if (I != MethodVTableIndices.end()) 2273226586Sdim return I->second; 2274226586Sdim 2275226586Sdim const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent(); 2276226586Sdim 2277261991Sdim computeVTableRelatedInformation(RD); 2278226586Sdim 2279226586Sdim I = MethodVTableIndices.find(GD); 2280226586Sdim assert(I != MethodVTableIndices.end() && "Did not find index!"); 2281226586Sdim return I->second; 2282226586Sdim} 2283226586Sdim 2284261991SdimCharUnits 2285261991SdimItaniumVTableContext::getVirtualBaseOffsetOffset(const CXXRecordDecl *RD, 2286261991Sdim const CXXRecordDecl *VBase) { 2287226586Sdim ClassPairTy ClassPair(RD, VBase); 2288226586Sdim 2289226586Sdim VirtualBaseClassOffsetOffsetsMapTy::iterator I = 2290226586Sdim VirtualBaseClassOffsetOffsets.find(ClassPair); 2291226586Sdim if (I != VirtualBaseClassOffsetOffsets.end()) 2292226586Sdim return I->second; 2293276479Sdim 2294276479Sdim VCallAndVBaseOffsetBuilder Builder(RD, RD, /*FinalOverriders=*/nullptr, 2295226586Sdim BaseSubobject(RD, CharUnits::Zero()), 2296226586Sdim /*BaseIsVirtual=*/false, 2297226586Sdim /*OffsetInLayoutClass=*/CharUnits::Zero()); 2298226586Sdim 2299226586Sdim for (VCallAndVBaseOffsetBuilder::VBaseOffsetOffsetsMapTy::const_iterator I = 2300226586Sdim Builder.getVBaseOffsetOffsets().begin(), 2301226586Sdim E = Builder.getVBaseOffsetOffsets().end(); I != E; ++I) { 2302226586Sdim // Insert all types. 2303226586Sdim ClassPairTy ClassPair(RD, I->first); 2304226586Sdim 2305226586Sdim VirtualBaseClassOffsetOffsets.insert( 2306226586Sdim std::make_pair(ClassPair, I->second)); 2307226586Sdim } 2308226586Sdim 2309226586Sdim I = VirtualBaseClassOffsetOffsets.find(ClassPair); 2310226586Sdim assert(I != VirtualBaseClassOffsetOffsets.end() && "Did not find index!"); 2311226586Sdim 2312226586Sdim return I->second; 2313226586Sdim} 2314226586Sdim 2315261991Sdimstatic VTableLayout *CreateVTableLayout(const ItaniumVTableBuilder &Builder) { 2316226586Sdim SmallVector<VTableLayout::VTableThunkTy, 1> 2317226586Sdim VTableThunks(Builder.vtable_thunks_begin(), Builder.vtable_thunks_end()); 2318226586Sdim 2319226586Sdim return new VTableLayout(Builder.getNumVTableComponents(), 2320226586Sdim Builder.vtable_component_begin(), 2321226586Sdim VTableThunks.size(), 2322226586Sdim VTableThunks.data(), 2323249423Sdim Builder.getAddressPoints(), 2324261991Sdim /*IsMicrosoftABI=*/false); 2325226586Sdim} 2326226586Sdim 2327261991Sdimvoid 2328261991SdimItaniumVTableContext::computeVTableRelatedInformation(const CXXRecordDecl *RD) { 2329226586Sdim const VTableLayout *&Entry = VTableLayouts[RD]; 2330226586Sdim 2331226586Sdim // Check if we've computed this information before. 2332226586Sdim if (Entry) 2333226586Sdim return; 2334226586Sdim 2335261991Sdim ItaniumVTableBuilder Builder(*this, RD, CharUnits::Zero(), 2336261991Sdim /*MostDerivedClassIsVirtual=*/0, RD); 2337226586Sdim Entry = CreateVTableLayout(Builder); 2338226586Sdim 2339261991Sdim MethodVTableIndices.insert(Builder.vtable_indices_begin(), 2340261991Sdim Builder.vtable_indices_end()); 2341261991Sdim 2342226586Sdim // Add the known thunks. 2343226586Sdim Thunks.insert(Builder.thunks_begin(), Builder.thunks_end()); 2344226586Sdim 2345226586Sdim // If we don't have the vbase information for this class, insert it. 2346226586Sdim // getVirtualBaseOffsetOffset will compute it separately without computing 2347226586Sdim // the rest of the vtable related information. 2348226586Sdim if (!RD->getNumVBases()) 2349226586Sdim return; 2350226586Sdim 2351261991Sdim const CXXRecordDecl *VBase = 2352261991Sdim RD->vbases_begin()->getType()->getAsCXXRecordDecl(); 2353226586Sdim 2354226586Sdim if (VirtualBaseClassOffsetOffsets.count(std::make_pair(RD, VBase))) 2355226586Sdim return; 2356261991Sdim 2357261991Sdim for (ItaniumVTableBuilder::VBaseOffsetOffsetsMapTy::const_iterator 2358261991Sdim I = Builder.getVBaseOffsetOffsets().begin(), 2359261991Sdim E = Builder.getVBaseOffsetOffsets().end(); 2360261991Sdim I != E; ++I) { 2361226586Sdim // Insert all types. 2362226586Sdim ClassPairTy ClassPair(RD, I->first); 2363226586Sdim 2364226586Sdim VirtualBaseClassOffsetOffsets.insert(std::make_pair(ClassPair, I->second)); 2365226586Sdim } 2366226586Sdim} 2367226586Sdim 2368261991SdimVTableLayout *ItaniumVTableContext::createConstructionVTableLayout( 2369261991Sdim const CXXRecordDecl *MostDerivedClass, CharUnits MostDerivedClassOffset, 2370261991Sdim bool MostDerivedClassIsVirtual, const CXXRecordDecl *LayoutClass) { 2371261991Sdim ItaniumVTableBuilder Builder(*this, MostDerivedClass, MostDerivedClassOffset, 2372261991Sdim MostDerivedClassIsVirtual, LayoutClass); 2373261991Sdim return CreateVTableLayout(Builder); 2374249423Sdim} 2375249423Sdim 2376261991Sdimnamespace { 2377261991Sdim 2378261991Sdim// Vtables in the Microsoft ABI are different from the Itanium ABI. 2379261991Sdim// 2380261991Sdim// The main differences are: 2381261991Sdim// 1. Separate vftable and vbtable. 2382261991Sdim// 2383261991Sdim// 2. Each subobject with a vfptr gets its own vftable rather than an address 2384261991Sdim// point in a single vtable shared between all the subobjects. 2385261991Sdim// Each vftable is represented by a separate section and virtual calls 2386261991Sdim// must be done using the vftable which has a slot for the function to be 2387261991Sdim// called. 2388261991Sdim// 2389261991Sdim// 3. Virtual method definitions expect their 'this' parameter to point to the 2390261991Sdim// first vfptr whose table provides a compatible overridden method. In many 2391261991Sdim// cases, this permits the original vf-table entry to directly call 2392261991Sdim// the method instead of passing through a thunk. 2393261991Sdim// 2394261991Sdim// A compatible overridden method is one which does not have a non-trivial 2395261991Sdim// covariant-return adjustment. 2396261991Sdim// 2397261991Sdim// The first vfptr is the one with the lowest offset in the complete-object 2398261991Sdim// layout of the defining class, and the method definition will subtract 2399261991Sdim// that constant offset from the parameter value to get the real 'this' 2400261991Sdim// value. Therefore, if the offset isn't really constant (e.g. if a virtual 2401261991Sdim// function defined in a virtual base is overridden in a more derived 2402261991Sdim// virtual base and these bases have a reverse order in the complete 2403261991Sdim// object), the vf-table may require a this-adjustment thunk. 2404261991Sdim// 2405261991Sdim// 4. vftables do not contain new entries for overrides that merely require 2406261991Sdim// this-adjustment. Together with #3, this keeps vf-tables smaller and 2407261991Sdim// eliminates the need for this-adjustment thunks in many cases, at the cost 2408261991Sdim// of often requiring redundant work to adjust the "this" pointer. 2409261991Sdim// 2410261991Sdim// 5. Instead of VTT and constructor vtables, vbtables and vtordisps are used. 2411261991Sdim// Vtordisps are emitted into the class layout if a class has 2412261991Sdim// a) a user-defined ctor/dtor 2413261991Sdim// and 2414261991Sdim// b) a method overriding a method in a virtual base. 2415261991Sdim 2416261991Sdimclass VFTableBuilder { 2417261991Sdimpublic: 2418261991Sdim typedef MicrosoftVTableContext::MethodVFTableLocation MethodVFTableLocation; 2419261991Sdim 2420261991Sdim typedef llvm::DenseMap<GlobalDecl, MethodVFTableLocation> 2421261991Sdim MethodVFTableLocationsTy; 2422261991Sdim 2423276479Sdim typedef llvm::iterator_range<MethodVFTableLocationsTy::const_iterator> 2424276479Sdim method_locations_range; 2425276479Sdim 2426261991Sdimprivate: 2427261991Sdim /// VTables - Global vtable information. 2428261991Sdim MicrosoftVTableContext &VTables; 2429261991Sdim 2430261991Sdim /// Context - The ASTContext which we will use for layout information. 2431261991Sdim ASTContext &Context; 2432261991Sdim 2433261991Sdim /// MostDerivedClass - The most derived class for which we're building this 2434261991Sdim /// vtable. 2435261991Sdim const CXXRecordDecl *MostDerivedClass; 2436261991Sdim 2437261991Sdim const ASTRecordLayout &MostDerivedClassLayout; 2438261991Sdim 2439276479Sdim const VPtrInfo &WhichVFPtr; 2440261991Sdim 2441261991Sdim /// FinalOverriders - The final overriders of the most derived class. 2442261991Sdim const FinalOverriders Overriders; 2443261991Sdim 2444261991Sdim /// Components - The components of the vftable being built. 2445261991Sdim SmallVector<VTableComponent, 64> Components; 2446261991Sdim 2447261991Sdim MethodVFTableLocationsTy MethodVFTableLocations; 2448261991Sdim 2449276479Sdim /// \brief Does this class have an RTTI component? 2450276479Sdim bool HasRTTIComponent; 2451276479Sdim 2452261991Sdim /// MethodInfo - Contains information about a method in a vtable. 2453261991Sdim /// (Used for computing 'this' pointer adjustment thunks. 2454261991Sdim struct MethodInfo { 2455261991Sdim /// VBTableIndex - The nonzero index in the vbtable that 2456261991Sdim /// this method's base has, or zero. 2457261991Sdim const uint64_t VBTableIndex; 2458261991Sdim 2459261991Sdim /// VFTableIndex - The index in the vftable that this method has. 2460261991Sdim const uint64_t VFTableIndex; 2461261991Sdim 2462261991Sdim /// Shadowed - Indicates if this vftable slot is shadowed by 2463261991Sdim /// a slot for a covariant-return override. If so, it shouldn't be printed 2464261991Sdim /// or used for vcalls in the most derived class. 2465261991Sdim bool Shadowed; 2466261991Sdim 2467261991Sdim MethodInfo(uint64_t VBTableIndex, uint64_t VFTableIndex) 2468261991Sdim : VBTableIndex(VBTableIndex), VFTableIndex(VFTableIndex), 2469261991Sdim Shadowed(false) {} 2470261991Sdim 2471261991Sdim MethodInfo() : VBTableIndex(0), VFTableIndex(0), Shadowed(false) {} 2472261991Sdim }; 2473261991Sdim 2474261991Sdim typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy; 2475261991Sdim 2476261991Sdim /// MethodInfoMap - The information for all methods in the vftable we're 2477261991Sdim /// currently building. 2478261991Sdim MethodInfoMapTy MethodInfoMap; 2479261991Sdim 2480261991Sdim typedef llvm::DenseMap<uint64_t, ThunkInfo> VTableThunksMapTy; 2481261991Sdim 2482261991Sdim /// VTableThunks - The thunks by vftable index in the vftable currently being 2483261991Sdim /// built. 2484261991Sdim VTableThunksMapTy VTableThunks; 2485261991Sdim 2486261991Sdim typedef SmallVector<ThunkInfo, 1> ThunkInfoVectorTy; 2487261991Sdim typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy; 2488261991Sdim 2489261991Sdim /// Thunks - A map that contains all the thunks needed for all methods in the 2490261991Sdim /// most derived class for which the vftable is currently being built. 2491261991Sdim ThunksMapTy Thunks; 2492261991Sdim 2493261991Sdim /// AddThunk - Add a thunk for the given method. 2494261991Sdim void AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk) { 2495261991Sdim SmallVector<ThunkInfo, 1> &ThunksVector = Thunks[MD]; 2496261991Sdim 2497261991Sdim // Check if we have this thunk already. 2498261991Sdim if (std::find(ThunksVector.begin(), ThunksVector.end(), Thunk) != 2499261991Sdim ThunksVector.end()) 2500261991Sdim return; 2501261991Sdim 2502261991Sdim ThunksVector.push_back(Thunk); 2503261991Sdim } 2504261991Sdim 2505261991Sdim /// ComputeThisOffset - Returns the 'this' argument offset for the given 2506276479Sdim /// method, relative to the beginning of the MostDerivedClass. 2507276479Sdim CharUnits ComputeThisOffset(FinalOverriders::OverriderInfo Overrider); 2508261991Sdim 2509261991Sdim void CalculateVtordispAdjustment(FinalOverriders::OverriderInfo Overrider, 2510261991Sdim CharUnits ThisOffset, ThisAdjustment &TA); 2511261991Sdim 2512261991Sdim /// AddMethod - Add a single virtual member function to the vftable 2513261991Sdim /// components vector. 2514261991Sdim void AddMethod(const CXXMethodDecl *MD, ThunkInfo TI) { 2515276479Sdim if (!TI.isEmpty()) { 2516276479Sdim VTableThunks[Components.size()] = TI; 2517276479Sdim AddThunk(MD, TI); 2518276479Sdim } 2519261991Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 2520261991Sdim assert(TI.Return.isEmpty() && 2521261991Sdim "Destructor can't have return adjustment!"); 2522261991Sdim Components.push_back(VTableComponent::MakeDeletingDtor(DD)); 2523261991Sdim } else { 2524261991Sdim Components.push_back(VTableComponent::MakeFunction(MD)); 2525261991Sdim } 2526261991Sdim } 2527261991Sdim 2528276479Sdim bool NeedsReturnAdjustingThunk(const CXXMethodDecl *MD); 2529276479Sdim 2530261991Sdim /// AddMethods - Add the methods of this base subobject and the relevant 2531261991Sdim /// subbases to the vftable we're currently laying out. 2532261991Sdim void AddMethods(BaseSubobject Base, unsigned BaseDepth, 2533261991Sdim const CXXRecordDecl *LastVBase, 2534261991Sdim BasesSetVectorTy &VisitedBases); 2535261991Sdim 2536261991Sdim void LayoutVFTable() { 2537261991Sdim // FIXME: add support for RTTI when we have proper LLVM support for symbols 2538261991Sdim // pointing to the middle of a section. 2539261991Sdim 2540261991Sdim BasesSetVectorTy VisitedBases; 2541276479Sdim AddMethods(BaseSubobject(MostDerivedClass, CharUnits::Zero()), 0, nullptr, 2542261991Sdim VisitedBases); 2543276479Sdim assert(Components.size() && "vftable can't be empty"); 2544261991Sdim 2545261991Sdim assert(MethodVFTableLocations.empty()); 2546261991Sdim for (MethodInfoMapTy::const_iterator I = MethodInfoMap.begin(), 2547261991Sdim E = MethodInfoMap.end(); I != E; ++I) { 2548261991Sdim const CXXMethodDecl *MD = I->first; 2549261991Sdim const MethodInfo &MI = I->second; 2550261991Sdim // Skip the methods that the MostDerivedClass didn't override 2551261991Sdim // and the entries shadowed by return adjusting thunks. 2552261991Sdim if (MD->getParent() != MostDerivedClass || MI.Shadowed) 2553261991Sdim continue; 2554276479Sdim MethodVFTableLocation Loc(MI.VBTableIndex, WhichVFPtr.getVBaseWithVPtr(), 2555276479Sdim WhichVFPtr.NonVirtualOffset, MI.VFTableIndex); 2556261991Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 2557261991Sdim MethodVFTableLocations[GlobalDecl(DD, Dtor_Deleting)] = Loc; 2558261991Sdim } else { 2559261991Sdim MethodVFTableLocations[MD] = Loc; 2560261991Sdim } 2561261991Sdim } 2562261991Sdim } 2563261991Sdim 2564261991Sdim void ErrorUnsupported(StringRef Feature, SourceLocation Location) { 2565261991Sdim clang::DiagnosticsEngine &Diags = Context.getDiagnostics(); 2566261991Sdim unsigned DiagID = Diags.getCustomDiagID( 2567261991Sdim DiagnosticsEngine::Error, "v-table layout for %0 is not supported yet"); 2568261991Sdim Diags.Report(Context.getFullLoc(Location), DiagID) << Feature; 2569261991Sdim } 2570261991Sdim 2571261991Sdimpublic: 2572261991Sdim VFTableBuilder(MicrosoftVTableContext &VTables, 2573276479Sdim const CXXRecordDecl *MostDerivedClass, const VPtrInfo *Which) 2574261991Sdim : VTables(VTables), 2575261991Sdim Context(MostDerivedClass->getASTContext()), 2576261991Sdim MostDerivedClass(MostDerivedClass), 2577261991Sdim MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)), 2578276479Sdim WhichVFPtr(*Which), 2579261991Sdim Overriders(MostDerivedClass, CharUnits(), MostDerivedClass) { 2580276479Sdim // Only include the RTTI component if we know that we will provide a 2581276479Sdim // definition of the vftable. 2582276479Sdim HasRTTIComponent = Context.getLangOpts().RTTIData && 2583276479Sdim !MostDerivedClass->hasAttr<DLLImportAttr>(); 2584276479Sdim if (HasRTTIComponent) 2585276479Sdim Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass)); 2586276479Sdim 2587261991Sdim LayoutVFTable(); 2588261991Sdim 2589261991Sdim if (Context.getLangOpts().DumpVTableLayouts) 2590261991Sdim dumpLayout(llvm::outs()); 2591261991Sdim } 2592261991Sdim 2593261991Sdim uint64_t getNumThunks() const { return Thunks.size(); } 2594261991Sdim 2595261991Sdim ThunksMapTy::const_iterator thunks_begin() const { return Thunks.begin(); } 2596261991Sdim 2597261991Sdim ThunksMapTy::const_iterator thunks_end() const { return Thunks.end(); } 2598261991Sdim 2599276479Sdim method_locations_range vtable_locations() const { 2600276479Sdim return method_locations_range(MethodVFTableLocations.begin(), 2601276479Sdim MethodVFTableLocations.end()); 2602261991Sdim } 2603261991Sdim 2604261991Sdim uint64_t getNumVTableComponents() const { return Components.size(); } 2605261991Sdim 2606261991Sdim const VTableComponent *vtable_component_begin() const { 2607261991Sdim return Components.begin(); 2608261991Sdim } 2609261991Sdim 2610261991Sdim const VTableComponent *vtable_component_end() const { 2611261991Sdim return Components.end(); 2612261991Sdim } 2613261991Sdim 2614261991Sdim VTableThunksMapTy::const_iterator vtable_thunks_begin() const { 2615261991Sdim return VTableThunks.begin(); 2616261991Sdim } 2617261991Sdim 2618261991Sdim VTableThunksMapTy::const_iterator vtable_thunks_end() const { 2619261991Sdim return VTableThunks.end(); 2620261991Sdim } 2621261991Sdim 2622261991Sdim void dumpLayout(raw_ostream &); 2623261991Sdim}; 2624261991Sdim 2625276479Sdim} // end namespace 2626276479Sdim 2627261991Sdim/// InitialOverriddenDefinitionCollector - Finds the set of least derived bases 2628261991Sdim/// that define the given method. 2629261991Sdimstruct InitialOverriddenDefinitionCollector { 2630261991Sdim BasesSetVectorTy Bases; 2631261991Sdim OverriddenMethodsSetTy VisitedOverriddenMethods; 2632261991Sdim 2633261991Sdim bool visit(const CXXMethodDecl *OverriddenMD) { 2634261991Sdim if (OverriddenMD->size_overridden_methods() == 0) 2635261991Sdim Bases.insert(OverriddenMD->getParent()); 2636261991Sdim // Don't recurse on this method if we've already collected it. 2637261991Sdim return VisitedOverriddenMethods.insert(OverriddenMD); 2638261991Sdim } 2639261991Sdim}; 2640261991Sdim 2641261991Sdimstatic bool BaseInSet(const CXXBaseSpecifier *Specifier, 2642261991Sdim CXXBasePath &Path, void *BasesSet) { 2643261991Sdim BasesSetVectorTy *Bases = (BasesSetVectorTy *)BasesSet; 2644261991Sdim return Bases->count(Specifier->getType()->getAsCXXRecordDecl()); 2645226586Sdim} 2646261991Sdim 2647261991SdimCharUnits 2648276479SdimVFTableBuilder::ComputeThisOffset(FinalOverriders::OverriderInfo Overrider) { 2649261991Sdim InitialOverriddenDefinitionCollector Collector; 2650276479Sdim visitAllOverriddenMethods(Overrider.Method, Collector); 2651261991Sdim 2652276479Sdim // If there are no overrides then 'this' is located 2653276479Sdim // in the base that defines the method. 2654276479Sdim if (Collector.Bases.size() == 0) 2655276479Sdim return Overrider.Offset; 2656276479Sdim 2657261991Sdim CXXBasePaths Paths; 2658276479Sdim Overrider.Method->getParent()->lookupInBases(BaseInSet, &Collector.Bases, 2659276479Sdim Paths); 2660261991Sdim 2661261991Sdim // This will hold the smallest this offset among overridees of MD. 2662261991Sdim // This implies that an offset of a non-virtual base will dominate an offset 2663261991Sdim // of a virtual base to potentially reduce the number of thunks required 2664261991Sdim // in the derived classes that inherit this method. 2665261991Sdim CharUnits Ret; 2666261991Sdim bool First = true; 2667261991Sdim 2668276479Sdim const ASTRecordLayout &OverriderRDLayout = 2669276479Sdim Context.getASTRecordLayout(Overrider.Method->getParent()); 2670261991Sdim for (CXXBasePaths::paths_iterator I = Paths.begin(), E = Paths.end(); 2671261991Sdim I != E; ++I) { 2672261991Sdim const CXXBasePath &Path = (*I); 2673276479Sdim CharUnits ThisOffset = Overrider.Offset; 2674261991Sdim CharUnits LastVBaseOffset; 2675261991Sdim 2676261991Sdim // For each path from the overrider to the parents of the overridden methods, 2677261991Sdim // traverse the path, calculating the this offset in the most derived class. 2678261991Sdim for (int J = 0, F = Path.size(); J != F; ++J) { 2679261991Sdim const CXXBasePathElement &Element = Path[J]; 2680261991Sdim QualType CurTy = Element.Base->getType(); 2681261991Sdim const CXXRecordDecl *PrevRD = Element.Class, 2682261991Sdim *CurRD = CurTy->getAsCXXRecordDecl(); 2683261991Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(PrevRD); 2684261991Sdim 2685261991Sdim if (Element.Base->isVirtual()) { 2686276479Sdim // The interesting things begin when you have virtual inheritance. 2687276479Sdim // The final overrider will use a static adjustment equal to the offset 2688276479Sdim // of the vbase in the final overrider class. 2689276479Sdim // For example, if the final overrider is in a vbase B of the most 2690276479Sdim // derived class and it overrides a method of the B's own vbase A, 2691276479Sdim // it uses A* as "this". In its prologue, it can cast A* to B* with 2692276479Sdim // a static offset. This offset is used regardless of the actual 2693276479Sdim // offset of A from B in the most derived class, requiring an 2694276479Sdim // this-adjusting thunk in the vftable if A and B are laid out 2695276479Sdim // differently in the most derived class. 2696276479Sdim LastVBaseOffset = ThisOffset = 2697276479Sdim Overrider.Offset + OverriderRDLayout.getVBaseClassOffset(CurRD); 2698261991Sdim } else { 2699261991Sdim ThisOffset += Layout.getBaseClassOffset(CurRD); 2700261991Sdim } 2701261991Sdim } 2702261991Sdim 2703276479Sdim if (isa<CXXDestructorDecl>(Overrider.Method)) { 2704261991Sdim if (LastVBaseOffset.isZero()) { 2705261991Sdim // If a "Base" class has at least one non-virtual base with a virtual 2706261991Sdim // destructor, the "Base" virtual destructor will take the address 2707261991Sdim // of the "Base" subobject as the "this" argument. 2708276479Sdim ThisOffset = Overrider.Offset; 2709261991Sdim } else { 2710261991Sdim // A virtual destructor of a virtual base takes the address of the 2711261991Sdim // virtual base subobject as the "this" argument. 2712276479Sdim ThisOffset = LastVBaseOffset; 2713261991Sdim } 2714261991Sdim } 2715261991Sdim 2716261991Sdim if (Ret > ThisOffset || First) { 2717261991Sdim First = false; 2718261991Sdim Ret = ThisOffset; 2719261991Sdim } 2720261991Sdim } 2721261991Sdim 2722261991Sdim assert(!First && "Method not found in the given subobject?"); 2723261991Sdim return Ret; 2724261991Sdim} 2725261991Sdim 2726261991Sdimvoid VFTableBuilder::CalculateVtordispAdjustment( 2727261991Sdim FinalOverriders::OverriderInfo Overrider, CharUnits ThisOffset, 2728261991Sdim ThisAdjustment &TA) { 2729261991Sdim const ASTRecordLayout::VBaseOffsetsMapTy &VBaseMap = 2730261991Sdim MostDerivedClassLayout.getVBaseOffsetsMap(); 2731261991Sdim const ASTRecordLayout::VBaseOffsetsMapTy::const_iterator &VBaseMapEntry = 2732276479Sdim VBaseMap.find(WhichVFPtr.getVBaseWithVPtr()); 2733261991Sdim assert(VBaseMapEntry != VBaseMap.end()); 2734261991Sdim 2735276479Sdim // If there's no vtordisp or the final overrider is defined in the same vbase 2736276479Sdim // as the initial declaration, we don't need any vtordisp adjustment. 2737276479Sdim if (!VBaseMapEntry->second.hasVtorDisp() || 2738276479Sdim Overrider.VirtualBase == WhichVFPtr.getVBaseWithVPtr()) 2739261991Sdim return; 2740261991Sdim 2741276479Sdim // OK, now we know we need to use a vtordisp thunk. 2742276479Sdim // The implicit vtordisp field is located right before the vbase. 2743261991Sdim CharUnits VFPtrVBaseOffset = VBaseMapEntry->second.VBaseOffset; 2744261991Sdim TA.Virtual.Microsoft.VtordispOffset = 2745276479Sdim (VFPtrVBaseOffset - WhichVFPtr.FullOffsetInMDC).getQuantity() - 4; 2746261991Sdim 2747276479Sdim // A simple vtordisp thunk will suffice if the final overrider is defined 2748276479Sdim // in either the most derived class or its non-virtual base. 2749276479Sdim if (Overrider.Method->getParent() == MostDerivedClass || 2750276479Sdim !Overrider.VirtualBase) 2751261991Sdim return; 2752261991Sdim 2753261991Sdim // Otherwise, we need to do use the dynamic offset of the final overrider 2754261991Sdim // in order to get "this" adjustment right. 2755261991Sdim TA.Virtual.Microsoft.VBPtrOffset = 2756276479Sdim (VFPtrVBaseOffset + WhichVFPtr.NonVirtualOffset - 2757261991Sdim MostDerivedClassLayout.getVBPtrOffset()).getQuantity(); 2758261991Sdim TA.Virtual.Microsoft.VBOffsetOffset = 2759261991Sdim Context.getTypeSizeInChars(Context.IntTy).getQuantity() * 2760276479Sdim VTables.getVBTableIndex(MostDerivedClass, Overrider.VirtualBase); 2761261991Sdim 2762261991Sdim TA.NonVirtual = (ThisOffset - Overrider.Offset).getQuantity(); 2763261991Sdim} 2764261991Sdim 2765261991Sdimstatic void GroupNewVirtualOverloads( 2766261991Sdim const CXXRecordDecl *RD, 2767261991Sdim SmallVector<const CXXMethodDecl *, 10> &VirtualMethods) { 2768261991Sdim // Put the virtual methods into VirtualMethods in the proper order: 2769261991Sdim // 1) Group overloads by declaration name. New groups are added to the 2770261991Sdim // vftable in the order of their first declarations in this class 2771276479Sdim // (including overrides and non-virtual methods). 2772261991Sdim // 2) In each group, new overloads appear in the reverse order of declaration. 2773261991Sdim typedef SmallVector<const CXXMethodDecl *, 1> MethodGroup; 2774261991Sdim SmallVector<MethodGroup, 10> Groups; 2775261991Sdim typedef llvm::DenseMap<DeclarationName, unsigned> VisitedGroupIndicesTy; 2776261991Sdim VisitedGroupIndicesTy VisitedGroupIndices; 2777276479Sdim for (const auto *MD : RD->methods()) { 2778261991Sdim VisitedGroupIndicesTy::iterator J; 2779261991Sdim bool Inserted; 2780276479Sdim std::tie(J, Inserted) = VisitedGroupIndices.insert( 2781261991Sdim std::make_pair(MD->getDeclName(), Groups.size())); 2782261991Sdim if (Inserted) 2783276479Sdim Groups.push_back(MethodGroup()); 2784276479Sdim if (MD->isVirtual()) 2785261991Sdim Groups[J->second].push_back(MD); 2786261991Sdim } 2787261991Sdim 2788261991Sdim for (unsigned I = 0, E = Groups.size(); I != E; ++I) 2789261991Sdim VirtualMethods.append(Groups[I].rbegin(), Groups[I].rend()); 2790261991Sdim} 2791261991Sdim 2792276479Sdim/// We need a return adjusting thunk for this method if its return type is 2793276479Sdim/// not trivially convertible to the return type of any of its overridden 2794276479Sdim/// methods. 2795276479Sdimbool VFTableBuilder::NeedsReturnAdjustingThunk(const CXXMethodDecl *MD) { 2796276479Sdim OverriddenMethodsSetTy OverriddenMethods; 2797276479Sdim ComputeAllOverriddenMethods(MD, OverriddenMethods); 2798276479Sdim for (OverriddenMethodsSetTy::iterator I = OverriddenMethods.begin(), 2799276479Sdim E = OverriddenMethods.end(); 2800276479Sdim I != E; ++I) { 2801276479Sdim const CXXMethodDecl *OverriddenMD = *I; 2802276479Sdim BaseOffset Adjustment = 2803276479Sdim ComputeReturnAdjustmentBaseOffset(Context, MD, OverriddenMD); 2804276479Sdim if (!Adjustment.isEmpty()) 2805276479Sdim return true; 2806276479Sdim } 2807276479Sdim return false; 2808276479Sdim} 2809276479Sdim 2810276479Sdimstatic bool isDirectVBase(const CXXRecordDecl *Base, const CXXRecordDecl *RD) { 2811276479Sdim for (const auto &B : RD->bases()) { 2812276479Sdim if (B.isVirtual() && B.getType()->getAsCXXRecordDecl() == Base) 2813276479Sdim return true; 2814276479Sdim } 2815276479Sdim return false; 2816276479Sdim} 2817276479Sdim 2818261991Sdimvoid VFTableBuilder::AddMethods(BaseSubobject Base, unsigned BaseDepth, 2819261991Sdim const CXXRecordDecl *LastVBase, 2820261991Sdim BasesSetVectorTy &VisitedBases) { 2821261991Sdim const CXXRecordDecl *RD = Base.getBase(); 2822261991Sdim if (!RD->isPolymorphic()) 2823261991Sdim return; 2824261991Sdim 2825261991Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 2826261991Sdim 2827261991Sdim // See if this class expands a vftable of the base we look at, which is either 2828261991Sdim // the one defined by the vfptr base path or the primary base of the current class. 2829276479Sdim const CXXRecordDecl *NextBase = nullptr, *NextLastVBase = LastVBase; 2830261991Sdim CharUnits NextBaseOffset; 2831276479Sdim if (BaseDepth < WhichVFPtr.PathToBaseWithVPtr.size()) { 2832276479Sdim NextBase = WhichVFPtr.PathToBaseWithVPtr[BaseDepth]; 2833276479Sdim if (isDirectVBase(NextBase, RD)) { 2834261991Sdim NextLastVBase = NextBase; 2835261991Sdim NextBaseOffset = MostDerivedClassLayout.getVBaseClassOffset(NextBase); 2836261991Sdim } else { 2837261991Sdim NextBaseOffset = 2838261991Sdim Base.getBaseOffset() + Layout.getBaseClassOffset(NextBase); 2839261991Sdim } 2840261991Sdim } else if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) { 2841261991Sdim assert(!Layout.isPrimaryBaseVirtual() && 2842261991Sdim "No primary virtual bases in this ABI"); 2843261991Sdim NextBase = PrimaryBase; 2844261991Sdim NextBaseOffset = Base.getBaseOffset(); 2845261991Sdim } 2846261991Sdim 2847261991Sdim if (NextBase) { 2848261991Sdim AddMethods(BaseSubobject(NextBase, NextBaseOffset), BaseDepth + 1, 2849261991Sdim NextLastVBase, VisitedBases); 2850261991Sdim if (!VisitedBases.insert(NextBase)) 2851261991Sdim llvm_unreachable("Found a duplicate primary base!"); 2852261991Sdim } 2853261991Sdim 2854261991Sdim SmallVector<const CXXMethodDecl*, 10> VirtualMethods; 2855261991Sdim // Put virtual methods in the proper order. 2856261991Sdim GroupNewVirtualOverloads(RD, VirtualMethods); 2857261991Sdim 2858261991Sdim // Now go through all virtual member functions and add them to the current 2859261991Sdim // vftable. This is done by 2860261991Sdim // - replacing overridden methods in their existing slots, as long as they 2861261991Sdim // don't require return adjustment; calculating This adjustment if needed. 2862261991Sdim // - adding new slots for methods of the current base not present in any 2863261991Sdim // sub-bases; 2864261991Sdim // - adding new slots for methods that require Return adjustment. 2865261991Sdim // We keep track of the methods visited in the sub-bases in MethodInfoMap. 2866261991Sdim for (unsigned I = 0, E = VirtualMethods.size(); I != E; ++I) { 2867261991Sdim const CXXMethodDecl *MD = VirtualMethods[I]; 2868261991Sdim 2869261991Sdim FinalOverriders::OverriderInfo Overrider = 2870261991Sdim Overriders.getOverrider(MD, Base.getBaseOffset()); 2871276479Sdim const CXXMethodDecl *OverriderMD = Overrider.Method; 2872276479Sdim const CXXMethodDecl *OverriddenMD = 2873276479Sdim FindNearestOverriddenMethod(MD, VisitedBases); 2874276479Sdim 2875261991Sdim ThisAdjustment ThisAdjustmentOffset; 2876276479Sdim bool ReturnAdjustingThunk = false; 2877276479Sdim CharUnits ThisOffset = ComputeThisOffset(Overrider); 2878276479Sdim ThisAdjustmentOffset.NonVirtual = 2879276479Sdim (ThisOffset - WhichVFPtr.FullOffsetInMDC).getQuantity(); 2880276479Sdim if ((OverriddenMD || OverriderMD != MD) && 2881276479Sdim WhichVFPtr.getVBaseWithVPtr()) 2882276479Sdim CalculateVtordispAdjustment(Overrider, ThisOffset, ThisAdjustmentOffset); 2883261991Sdim 2884276479Sdim if (OverriddenMD) { 2885276479Sdim // If MD overrides anything in this vftable, we need to update the entries. 2886261991Sdim MethodInfoMapTy::iterator OverriddenMDIterator = 2887261991Sdim MethodInfoMap.find(OverriddenMD); 2888261991Sdim 2889261991Sdim // If the overridden method went to a different vftable, skip it. 2890261991Sdim if (OverriddenMDIterator == MethodInfoMap.end()) 2891261991Sdim continue; 2892261991Sdim 2893261991Sdim MethodInfo &OverriddenMethodInfo = OverriddenMDIterator->second; 2894261991Sdim 2895276479Sdim if (!NeedsReturnAdjustingThunk(MD)) { 2896261991Sdim // No return adjustment needed - just replace the overridden method info 2897261991Sdim // with the current info. 2898261991Sdim MethodInfo MI(OverriddenMethodInfo.VBTableIndex, 2899261991Sdim OverriddenMethodInfo.VFTableIndex); 2900261991Sdim MethodInfoMap.erase(OverriddenMDIterator); 2901261991Sdim 2902261991Sdim assert(!MethodInfoMap.count(MD) && 2903261991Sdim "Should not have method info for this method yet!"); 2904261991Sdim MethodInfoMap.insert(std::make_pair(MD, MI)); 2905261991Sdim continue; 2906276479Sdim } 2907261991Sdim 2908276479Sdim // In case we need a return adjustment, we'll add a new slot for 2909276479Sdim // the overrider. Mark the overriden method as shadowed by the new slot. 2910276479Sdim OverriddenMethodInfo.Shadowed = true; 2911276479Sdim 2912276479Sdim // Force a special name mangling for a return-adjusting thunk 2913276479Sdim // unless the method is the final overrider without this adjustment. 2914276479Sdim ReturnAdjustingThunk = 2915276479Sdim !(MD == OverriderMD && ThisAdjustmentOffset.isEmpty()); 2916276479Sdim } else if (Base.getBaseOffset() != WhichVFPtr.FullOffsetInMDC || 2917261991Sdim MD->size_overridden_methods()) { 2918261991Sdim // Skip methods that don't belong to the vftable of the current class, 2919261991Sdim // e.g. each method that wasn't seen in any of the visited sub-bases 2920261991Sdim // but overrides multiple methods of other sub-bases. 2921261991Sdim continue; 2922261991Sdim } 2923261991Sdim 2924261991Sdim // If we got here, MD is a method not seen in any of the sub-bases or 2925261991Sdim // it requires return adjustment. Insert the method info for this method. 2926261991Sdim unsigned VBIndex = 2927261991Sdim LastVBase ? VTables.getVBTableIndex(MostDerivedClass, LastVBase) : 0; 2928276479Sdim MethodInfo MI(VBIndex, 2929276479Sdim HasRTTIComponent ? Components.size() - 1 : Components.size()); 2930261991Sdim 2931261991Sdim assert(!MethodInfoMap.count(MD) && 2932261991Sdim "Should not have method info for this method yet!"); 2933261991Sdim MethodInfoMap.insert(std::make_pair(MD, MI)); 2934261991Sdim 2935261991Sdim // Check if this overrider needs a return adjustment. 2936261991Sdim // We don't want to do this for pure virtual member functions. 2937261991Sdim BaseOffset ReturnAdjustmentOffset; 2938261991Sdim ReturnAdjustment ReturnAdjustment; 2939261991Sdim if (!OverriderMD->isPure()) { 2940261991Sdim ReturnAdjustmentOffset = 2941261991Sdim ComputeReturnAdjustmentBaseOffset(Context, OverriderMD, MD); 2942261991Sdim } 2943261991Sdim if (!ReturnAdjustmentOffset.isEmpty()) { 2944276479Sdim ReturnAdjustingThunk = true; 2945261991Sdim ReturnAdjustment.NonVirtual = 2946261991Sdim ReturnAdjustmentOffset.NonVirtualOffset.getQuantity(); 2947261991Sdim if (ReturnAdjustmentOffset.VirtualBase) { 2948261991Sdim const ASTRecordLayout &DerivedLayout = 2949261991Sdim Context.getASTRecordLayout(ReturnAdjustmentOffset.DerivedClass); 2950261991Sdim ReturnAdjustment.Virtual.Microsoft.VBPtrOffset = 2951261991Sdim DerivedLayout.getVBPtrOffset().getQuantity(); 2952261991Sdim ReturnAdjustment.Virtual.Microsoft.VBIndex = 2953261991Sdim VTables.getVBTableIndex(ReturnAdjustmentOffset.DerivedClass, 2954261991Sdim ReturnAdjustmentOffset.VirtualBase); 2955261991Sdim } 2956261991Sdim } 2957261991Sdim 2958261991Sdim AddMethod(OverriderMD, ThunkInfo(ThisAdjustmentOffset, ReturnAdjustment, 2959276479Sdim ReturnAdjustingThunk ? MD : nullptr)); 2960261991Sdim } 2961261991Sdim} 2962261991Sdim 2963276479Sdimstatic void PrintBasePath(const VPtrInfo::BasePath &Path, raw_ostream &Out) { 2964276479Sdim for (VPtrInfo::BasePath::const_reverse_iterator I = Path.rbegin(), 2965261991Sdim E = Path.rend(); I != E; ++I) { 2966276479Sdim Out << "'"; 2967276479Sdim (*I)->printQualifiedName(Out); 2968276479Sdim Out << "' in "; 2969261991Sdim } 2970261991Sdim} 2971261991Sdim 2972261991Sdimstatic void dumpMicrosoftThunkAdjustment(const ThunkInfo &TI, raw_ostream &Out, 2973261991Sdim bool ContinueFirstLine) { 2974261991Sdim const ReturnAdjustment &R = TI.Return; 2975261991Sdim bool Multiline = false; 2976276479Sdim const char *LinePrefix = "\n "; 2977276479Sdim if (!R.isEmpty() || TI.Method) { 2978261991Sdim if (!ContinueFirstLine) 2979261991Sdim Out << LinePrefix; 2980276479Sdim Out << "[return adjustment (to type '" 2981276479Sdim << TI.Method->getReturnType().getCanonicalType().getAsString() 2982276479Sdim << "'): "; 2983261991Sdim if (R.Virtual.Microsoft.VBPtrOffset) 2984261991Sdim Out << "vbptr at offset " << R.Virtual.Microsoft.VBPtrOffset << ", "; 2985261991Sdim if (R.Virtual.Microsoft.VBIndex) 2986261991Sdim Out << "vbase #" << R.Virtual.Microsoft.VBIndex << ", "; 2987261991Sdim Out << R.NonVirtual << " non-virtual]"; 2988261991Sdim Multiline = true; 2989261991Sdim } 2990261991Sdim 2991261991Sdim const ThisAdjustment &T = TI.This; 2992261991Sdim if (!T.isEmpty()) { 2993261991Sdim if (Multiline || !ContinueFirstLine) 2994261991Sdim Out << LinePrefix; 2995261991Sdim Out << "[this adjustment: "; 2996261991Sdim if (!TI.This.Virtual.isEmpty()) { 2997261991Sdim assert(T.Virtual.Microsoft.VtordispOffset < 0); 2998261991Sdim Out << "vtordisp at " << T.Virtual.Microsoft.VtordispOffset << ", "; 2999261991Sdim if (T.Virtual.Microsoft.VBPtrOffset) { 3000261991Sdim Out << "vbptr at " << T.Virtual.Microsoft.VBPtrOffset 3001276479Sdim << " to the left,"; 3002261991Sdim assert(T.Virtual.Microsoft.VBOffsetOffset > 0); 3003261991Sdim Out << LinePrefix << " vboffset at " 3004261991Sdim << T.Virtual.Microsoft.VBOffsetOffset << " in the vbtable, "; 3005261991Sdim } 3006261991Sdim } 3007261991Sdim Out << T.NonVirtual << " non-virtual]"; 3008261991Sdim } 3009261991Sdim} 3010261991Sdim 3011261991Sdimvoid VFTableBuilder::dumpLayout(raw_ostream &Out) { 3012261991Sdim Out << "VFTable for "; 3013276479Sdim PrintBasePath(WhichVFPtr.PathToBaseWithVPtr, Out); 3014276479Sdim Out << "'"; 3015276479Sdim MostDerivedClass->printQualifiedName(Out); 3016276479Sdim Out << "' (" << Components.size() 3017276479Sdim << (Components.size() == 1 ? " entry" : " entries") << ").\n"; 3018261991Sdim 3019261991Sdim for (unsigned I = 0, E = Components.size(); I != E; ++I) { 3020261991Sdim Out << llvm::format("%4d | ", I); 3021261991Sdim 3022261991Sdim const VTableComponent &Component = Components[I]; 3023261991Sdim 3024261991Sdim // Dump the component. 3025261991Sdim switch (Component.getKind()) { 3026261991Sdim case VTableComponent::CK_RTTI: 3027276479Sdim Component.getRTTIDecl()->printQualifiedName(Out); 3028276479Sdim Out << " RTTI"; 3029261991Sdim break; 3030261991Sdim 3031261991Sdim case VTableComponent::CK_FunctionPointer: { 3032261991Sdim const CXXMethodDecl *MD = Component.getFunctionDecl(); 3033261991Sdim 3034276479Sdim // FIXME: Figure out how to print the real thunk type, since they can 3035276479Sdim // differ in the return type. 3036261991Sdim std::string Str = PredefinedExpr::ComputeName( 3037261991Sdim PredefinedExpr::PrettyFunctionNoVirtual, MD); 3038261991Sdim Out << Str; 3039261991Sdim if (MD->isPure()) 3040261991Sdim Out << " [pure]"; 3041261991Sdim 3042261991Sdim if (MD->isDeleted()) { 3043261991Sdim ErrorUnsupported("deleted methods", MD->getLocation()); 3044261991Sdim Out << " [deleted]"; 3045261991Sdim } 3046261991Sdim 3047261991Sdim ThunkInfo Thunk = VTableThunks.lookup(I); 3048261991Sdim if (!Thunk.isEmpty()) 3049261991Sdim dumpMicrosoftThunkAdjustment(Thunk, Out, /*ContinueFirstLine=*/false); 3050261991Sdim 3051261991Sdim break; 3052261991Sdim } 3053261991Sdim 3054261991Sdim case VTableComponent::CK_DeletingDtorPointer: { 3055261991Sdim const CXXDestructorDecl *DD = Component.getDestructorDecl(); 3056261991Sdim 3057276479Sdim DD->printQualifiedName(Out); 3058261991Sdim Out << "() [scalar deleting]"; 3059261991Sdim 3060261991Sdim if (DD->isPure()) 3061261991Sdim Out << " [pure]"; 3062261991Sdim 3063261991Sdim ThunkInfo Thunk = VTableThunks.lookup(I); 3064261991Sdim if (!Thunk.isEmpty()) { 3065261991Sdim assert(Thunk.Return.isEmpty() && 3066261991Sdim "No return adjustment needed for destructors!"); 3067261991Sdim dumpMicrosoftThunkAdjustment(Thunk, Out, /*ContinueFirstLine=*/false); 3068261991Sdim } 3069261991Sdim 3070261991Sdim break; 3071261991Sdim } 3072261991Sdim 3073261991Sdim default: 3074261991Sdim DiagnosticsEngine &Diags = Context.getDiagnostics(); 3075261991Sdim unsigned DiagID = Diags.getCustomDiagID( 3076261991Sdim DiagnosticsEngine::Error, 3077261991Sdim "Unexpected vftable component type %0 for component number %1"); 3078261991Sdim Diags.Report(MostDerivedClass->getLocation(), DiagID) 3079261991Sdim << I << Component.getKind(); 3080261991Sdim } 3081261991Sdim 3082261991Sdim Out << '\n'; 3083261991Sdim } 3084261991Sdim 3085261991Sdim Out << '\n'; 3086261991Sdim 3087261991Sdim if (!Thunks.empty()) { 3088261991Sdim // We store the method names in a map to get a stable order. 3089261991Sdim std::map<std::string, const CXXMethodDecl *> MethodNamesAndDecls; 3090261991Sdim 3091261991Sdim for (ThunksMapTy::const_iterator I = Thunks.begin(), E = Thunks.end(); 3092261991Sdim I != E; ++I) { 3093261991Sdim const CXXMethodDecl *MD = I->first; 3094261991Sdim std::string MethodName = PredefinedExpr::ComputeName( 3095261991Sdim PredefinedExpr::PrettyFunctionNoVirtual, MD); 3096261991Sdim 3097261991Sdim MethodNamesAndDecls.insert(std::make_pair(MethodName, MD)); 3098261991Sdim } 3099261991Sdim 3100261991Sdim for (std::map<std::string, const CXXMethodDecl *>::const_iterator 3101261991Sdim I = MethodNamesAndDecls.begin(), 3102261991Sdim E = MethodNamesAndDecls.end(); 3103261991Sdim I != E; ++I) { 3104261991Sdim const std::string &MethodName = I->first; 3105261991Sdim const CXXMethodDecl *MD = I->second; 3106261991Sdim 3107261991Sdim ThunkInfoVectorTy ThunksVector = Thunks[MD]; 3108261991Sdim std::stable_sort(ThunksVector.begin(), ThunksVector.end(), 3109276479Sdim [](const ThunkInfo &LHS, const ThunkInfo &RHS) { 3110276479Sdim // Keep different thunks with the same adjustments in the order they 3111276479Sdim // were put into the vector. 3112276479Sdim return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return); 3113276479Sdim }); 3114261991Sdim 3115261991Sdim Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size(); 3116261991Sdim Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n"; 3117261991Sdim 3118261991Sdim for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) { 3119261991Sdim const ThunkInfo &Thunk = ThunksVector[I]; 3120261991Sdim 3121261991Sdim Out << llvm::format("%4d | ", I); 3122261991Sdim dumpMicrosoftThunkAdjustment(Thunk, Out, /*ContinueFirstLine=*/true); 3123261991Sdim Out << '\n'; 3124261991Sdim } 3125261991Sdim 3126261991Sdim Out << '\n'; 3127261991Sdim } 3128261991Sdim } 3129276479Sdim 3130276479Sdim Out.flush(); 3131261991Sdim} 3132276479Sdim 3133276479Sdimstatic bool setsIntersect(const llvm::SmallPtrSet<const CXXRecordDecl *, 4> &A, 3134276479Sdim const ArrayRef<const CXXRecordDecl *> &B) { 3135276479Sdim for (ArrayRef<const CXXRecordDecl *>::iterator I = B.begin(), E = B.end(); 3136276479Sdim I != E; ++I) { 3137276479Sdim if (A.count(*I)) 3138276479Sdim return true; 3139276479Sdim } 3140276479Sdim return false; 3141261991Sdim} 3142261991Sdim 3143276479Sdimstatic bool rebucketPaths(VPtrInfoVector &Paths); 3144261991Sdim 3145276479Sdim/// Produces MSVC-compatible vbtable data. The symbols produced by this 3146276479Sdim/// algorithm match those produced by MSVC 2012 and newer, which is different 3147276479Sdim/// from MSVC 2010. 3148276479Sdim/// 3149276479Sdim/// MSVC 2012 appears to minimize the vbtable names using the following 3150276479Sdim/// algorithm. First, walk the class hierarchy in the usual order, depth first, 3151276479Sdim/// left to right, to find all of the subobjects which contain a vbptr field. 3152276479Sdim/// Visiting each class node yields a list of inheritance paths to vbptrs. Each 3153276479Sdim/// record with a vbptr creates an initially empty path. 3154276479Sdim/// 3155276479Sdim/// To combine paths from child nodes, the paths are compared to check for 3156276479Sdim/// ambiguity. Paths are "ambiguous" if multiple paths have the same set of 3157276479Sdim/// components in the same order. Each group of ambiguous paths is extended by 3158276479Sdim/// appending the class of the base from which it came. If the current class 3159276479Sdim/// node produced an ambiguous path, its path is extended with the current class. 3160276479Sdim/// After extending paths, MSVC again checks for ambiguity, and extends any 3161276479Sdim/// ambiguous path which wasn't already extended. Because each node yields an 3162276479Sdim/// unambiguous set of paths, MSVC doesn't need to extend any path more than once 3163276479Sdim/// to produce an unambiguous set of paths. 3164276479Sdim/// 3165276479Sdim/// TODO: Presumably vftables use the same algorithm. 3166276479Sdimvoid MicrosoftVTableContext::computeVTablePaths(bool ForVBTables, 3167276479Sdim const CXXRecordDecl *RD, 3168276479Sdim VPtrInfoVector &Paths) { 3169276479Sdim assert(Paths.empty()); 3170276479Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 3171261991Sdim 3172276479Sdim // Base case: this subobject has its own vptr. 3173276479Sdim if (ForVBTables ? Layout.hasOwnVBPtr() : Layout.hasOwnVFPtr()) 3174276479Sdim Paths.push_back(new VPtrInfo(RD)); 3175261991Sdim 3176276479Sdim // Recursive case: get all the vbtables from our bases and remove anything 3177276479Sdim // that shares a virtual base. 3178276479Sdim llvm::SmallPtrSet<const CXXRecordDecl*, 4> VBasesSeen; 3179276479Sdim for (const auto &B : RD->bases()) { 3180276479Sdim const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl(); 3181276479Sdim if (B.isVirtual() && VBasesSeen.count(Base)) 3182276479Sdim continue; 3183276479Sdim 3184276479Sdim if (!Base->isDynamicClass()) 3185276479Sdim continue; 3186276479Sdim 3187276479Sdim const VPtrInfoVector &BasePaths = 3188276479Sdim ForVBTables ? enumerateVBTables(Base) : getVFPtrOffsets(Base); 3189276479Sdim 3190276479Sdim for (VPtrInfo *BaseInfo : BasePaths) { 3191276479Sdim // Don't include the path if it goes through a virtual base that we've 3192276479Sdim // already included. 3193276479Sdim if (setsIntersect(VBasesSeen, BaseInfo->ContainingVBases)) 3194261991Sdim continue; 3195261991Sdim 3196276479Sdim // Copy the path and adjust it as necessary. 3197276479Sdim VPtrInfo *P = new VPtrInfo(*BaseInfo); 3198261991Sdim 3199276479Sdim // We mangle Base into the path if the path would've been ambiguous and it 3200276479Sdim // wasn't already extended with Base. 3201276479Sdim if (P->MangledPath.empty() || P->MangledPath.back() != Base) 3202276479Sdim P->NextBaseToMangle = Base; 3203261991Sdim 3204276479Sdim // Keep track of the full path. 3205276479Sdim // FIXME: Why do we need this? 3206276479Sdim P->PathToBaseWithVPtr.insert(P->PathToBaseWithVPtr.begin(), Base); 3207261991Sdim 3208276479Sdim // Keep track of which vtable the derived class is going to extend with 3209276479Sdim // new methods or bases. We append to either the vftable of our primary 3210276479Sdim // base, or the first non-virtual base that has a vbtable. 3211276479Sdim if (P->ReusingBase == Base && 3212276479Sdim Base == (ForVBTables ? Layout.getBaseSharingVBPtr() 3213276479Sdim : Layout.getPrimaryBase())) 3214276479Sdim P->ReusingBase = RD; 3215261991Sdim 3216276479Sdim // Keep track of the full adjustment from the MDC to this vtable. The 3217276479Sdim // adjustment is captured by an optional vbase and a non-virtual offset. 3218276479Sdim if (B.isVirtual()) 3219276479Sdim P->ContainingVBases.push_back(Base); 3220276479Sdim else if (P->ContainingVBases.empty()) 3221276479Sdim P->NonVirtualOffset += Layout.getBaseClassOffset(Base); 3222261991Sdim 3223276479Sdim // Update the full offset in the MDC. 3224276479Sdim P->FullOffsetInMDC = P->NonVirtualOffset; 3225276479Sdim if (const CXXRecordDecl *VB = P->getVBaseWithVPtr()) 3226276479Sdim P->FullOffsetInMDC += Layout.getVBaseClassOffset(VB); 3227276479Sdim 3228276479Sdim Paths.push_back(P); 3229261991Sdim } 3230276479Sdim 3231276479Sdim if (B.isVirtual()) 3232276479Sdim VBasesSeen.insert(Base); 3233276479Sdim 3234276479Sdim // After visiting any direct base, we've transitively visited all of its 3235276479Sdim // morally virtual bases. 3236276479Sdim for (const auto &VB : Base->vbases()) 3237276479Sdim VBasesSeen.insert(VB.getType()->getAsCXXRecordDecl()); 3238261991Sdim } 3239261991Sdim 3240276479Sdim // Sort the paths into buckets, and if any of them are ambiguous, extend all 3241276479Sdim // paths in ambiguous buckets. 3242276479Sdim bool Changed = true; 3243276479Sdim while (Changed) 3244276479Sdim Changed = rebucketPaths(Paths); 3245276479Sdim} 3246261991Sdim 3247276479Sdimstatic bool extendPath(VPtrInfo *P) { 3248276479Sdim if (P->NextBaseToMangle) { 3249276479Sdim P->MangledPath.push_back(P->NextBaseToMangle); 3250276479Sdim P->NextBaseToMangle = nullptr;// Prevent the path from being extended twice. 3251276479Sdim return true; 3252261991Sdim } 3253276479Sdim return false; 3254261991Sdim} 3255261991Sdim 3256276479Sdimstatic bool rebucketPaths(VPtrInfoVector &Paths) { 3257276479Sdim // What we're essentially doing here is bucketing together ambiguous paths. 3258276479Sdim // Any bucket with more than one path in it gets extended by NextBase, which 3259276479Sdim // is usually the direct base of the inherited the vbptr. This code uses a 3260276479Sdim // sorted vector to implement a multiset to form the buckets. Note that the 3261276479Sdim // ordering is based on pointers, but it doesn't change our output order. The 3262276479Sdim // current algorithm is designed to match MSVC 2012's names. 3263276479Sdim VPtrInfoVector PathsSorted(Paths); 3264276479Sdim std::sort(PathsSorted.begin(), PathsSorted.end(), 3265276479Sdim [](const VPtrInfo *LHS, const VPtrInfo *RHS) { 3266276479Sdim return LHS->MangledPath < RHS->MangledPath; 3267276479Sdim }); 3268276479Sdim bool Changed = false; 3269276479Sdim for (size_t I = 0, E = PathsSorted.size(); I != E;) { 3270276479Sdim // Scan forward to find the end of the bucket. 3271276479Sdim size_t BucketStart = I; 3272276479Sdim do { 3273276479Sdim ++I; 3274276479Sdim } while (I != E && PathsSorted[BucketStart]->MangledPath == 3275276479Sdim PathsSorted[I]->MangledPath); 3276276479Sdim 3277276479Sdim // If this bucket has multiple paths, extend them all. 3278276479Sdim if (I - BucketStart > 1) { 3279276479Sdim for (size_t II = BucketStart; II != I; ++II) 3280276479Sdim Changed |= extendPath(PathsSorted[II]); 3281276479Sdim assert(Changed && "no paths were extended to fix ambiguity"); 3282276479Sdim } 3283261991Sdim } 3284276479Sdim return Changed; 3285261991Sdim} 3286261991Sdim 3287276479SdimMicrosoftVTableContext::~MicrosoftVTableContext() { 3288276479Sdim for (auto &P : VFPtrLocations) 3289276479Sdim llvm::DeleteContainerPointers(*P.second); 3290276479Sdim llvm::DeleteContainerSeconds(VFPtrLocations); 3291276479Sdim llvm::DeleteContainerSeconds(VFTableLayouts); 3292276479Sdim llvm::DeleteContainerSeconds(VBaseInfo); 3293276479Sdim} 3294276479Sdim 3295261991Sdimvoid MicrosoftVTableContext::computeVTableRelatedInformation( 3296261991Sdim const CXXRecordDecl *RD) { 3297261991Sdim assert(RD->isDynamicClass()); 3298261991Sdim 3299261991Sdim // Check if we've computed this information before. 3300261991Sdim if (VFPtrLocations.count(RD)) 3301261991Sdim return; 3302261991Sdim 3303261991Sdim const VTableLayout::AddressPointsMapTy EmptyAddressPointsMap; 3304261991Sdim 3305276479Sdim VPtrInfoVector *VFPtrs = new VPtrInfoVector(); 3306276479Sdim computeVTablePaths(/*ForVBTables=*/false, RD, *VFPtrs); 3307276479Sdim VFPtrLocations[RD] = VFPtrs; 3308261991Sdim 3309261991Sdim MethodVFTableLocationsTy NewMethodLocations; 3310276479Sdim for (VPtrInfoVector::iterator I = VFPtrs->begin(), E = VFPtrs->end(); 3311261991Sdim I != E; ++I) { 3312261991Sdim VFTableBuilder Builder(*this, RD, *I); 3313261991Sdim 3314276479Sdim VFTableIdTy id(RD, (*I)->FullOffsetInMDC); 3315261991Sdim assert(VFTableLayouts.count(id) == 0); 3316261991Sdim SmallVector<VTableLayout::VTableThunkTy, 1> VTableThunks( 3317261991Sdim Builder.vtable_thunks_begin(), Builder.vtable_thunks_end()); 3318261991Sdim VFTableLayouts[id] = new VTableLayout( 3319261991Sdim Builder.getNumVTableComponents(), Builder.vtable_component_begin(), 3320261991Sdim VTableThunks.size(), VTableThunks.data(), EmptyAddressPointsMap, true); 3321261991Sdim Thunks.insert(Builder.thunks_begin(), Builder.thunks_end()); 3322276479Sdim 3323276479Sdim for (const auto &Loc : Builder.vtable_locations()) { 3324276479Sdim GlobalDecl GD = Loc.first; 3325276479Sdim MethodVFTableLocation NewLoc = Loc.second; 3326276479Sdim auto M = NewMethodLocations.find(GD); 3327276479Sdim if (M == NewMethodLocations.end() || NewLoc < M->second) 3328276479Sdim NewMethodLocations[GD] = NewLoc; 3329276479Sdim } 3330261991Sdim } 3331261991Sdim 3332261991Sdim MethodVFTableLocations.insert(NewMethodLocations.begin(), 3333261991Sdim NewMethodLocations.end()); 3334261991Sdim if (Context.getLangOpts().DumpVTableLayouts) 3335261991Sdim dumpMethodLocations(RD, NewMethodLocations, llvm::outs()); 3336261991Sdim} 3337261991Sdim 3338261991Sdimvoid MicrosoftVTableContext::dumpMethodLocations( 3339261991Sdim const CXXRecordDecl *RD, const MethodVFTableLocationsTy &NewMethods, 3340261991Sdim raw_ostream &Out) { 3341261991Sdim // Compute the vtable indices for all the member functions. 3342261991Sdim // Store them in a map keyed by the location so we'll get a sorted table. 3343261991Sdim std::map<MethodVFTableLocation, std::string> IndicesMap; 3344261991Sdim bool HasNonzeroOffset = false; 3345261991Sdim 3346261991Sdim for (MethodVFTableLocationsTy::const_iterator I = NewMethods.begin(), 3347261991Sdim E = NewMethods.end(); I != E; ++I) { 3348261991Sdim const CXXMethodDecl *MD = cast<const CXXMethodDecl>(I->first.getDecl()); 3349261991Sdim assert(MD->isVirtual()); 3350261991Sdim 3351261991Sdim std::string MethodName = PredefinedExpr::ComputeName( 3352261991Sdim PredefinedExpr::PrettyFunctionNoVirtual, MD); 3353261991Sdim 3354261991Sdim if (isa<CXXDestructorDecl>(MD)) { 3355261991Sdim IndicesMap[I->second] = MethodName + " [scalar deleting]"; 3356261991Sdim } else { 3357261991Sdim IndicesMap[I->second] = MethodName; 3358261991Sdim } 3359261991Sdim 3360261991Sdim if (!I->second.VFPtrOffset.isZero() || I->second.VBTableIndex != 0) 3361261991Sdim HasNonzeroOffset = true; 3362261991Sdim } 3363261991Sdim 3364261991Sdim // Print the vtable indices for all the member functions. 3365261991Sdim if (!IndicesMap.empty()) { 3366261991Sdim Out << "VFTable indices for "; 3367276479Sdim Out << "'"; 3368276479Sdim RD->printQualifiedName(Out); 3369276479Sdim Out << "' (" << IndicesMap.size() 3370276479Sdim << (IndicesMap.size() == 1 ? " entry" : " entries") << ").\n"; 3371261991Sdim 3372261991Sdim CharUnits LastVFPtrOffset = CharUnits::fromQuantity(-1); 3373261991Sdim uint64_t LastVBIndex = 0; 3374261991Sdim for (std::map<MethodVFTableLocation, std::string>::const_iterator 3375261991Sdim I = IndicesMap.begin(), 3376261991Sdim E = IndicesMap.end(); 3377261991Sdim I != E; ++I) { 3378261991Sdim CharUnits VFPtrOffset = I->first.VFPtrOffset; 3379261991Sdim uint64_t VBIndex = I->first.VBTableIndex; 3380261991Sdim if (HasNonzeroOffset && 3381261991Sdim (VFPtrOffset != LastVFPtrOffset || VBIndex != LastVBIndex)) { 3382261991Sdim assert(VBIndex > LastVBIndex || VFPtrOffset > LastVFPtrOffset); 3383261991Sdim Out << " -- accessible via "; 3384261991Sdim if (VBIndex) 3385261991Sdim Out << "vbtable index " << VBIndex << ", "; 3386261991Sdim Out << "vfptr at offset " << VFPtrOffset.getQuantity() << " --\n"; 3387261991Sdim LastVFPtrOffset = VFPtrOffset; 3388261991Sdim LastVBIndex = VBIndex; 3389261991Sdim } 3390261991Sdim 3391261991Sdim uint64_t VTableIndex = I->first.Index; 3392261991Sdim const std::string &MethodName = I->second; 3393261991Sdim Out << llvm::format("%4" PRIu64 " | ", VTableIndex) << MethodName << '\n'; 3394261991Sdim } 3395261991Sdim Out << '\n'; 3396261991Sdim } 3397276479Sdim 3398276479Sdim Out.flush(); 3399261991Sdim} 3400261991Sdim 3401276479Sdimconst VirtualBaseInfo *MicrosoftVTableContext::computeVBTableRelatedInformation( 3402261991Sdim const CXXRecordDecl *RD) { 3403276479Sdim VirtualBaseInfo *VBI; 3404261991Sdim 3405276479Sdim { 3406276479Sdim // Get or create a VBI for RD. Don't hold a reference to the DenseMap cell, 3407276479Sdim // as it may be modified and rehashed under us. 3408276479Sdim VirtualBaseInfo *&Entry = VBaseInfo[RD]; 3409276479Sdim if (Entry) 3410276479Sdim return Entry; 3411276479Sdim Entry = VBI = new VirtualBaseInfo(); 3412276479Sdim } 3413261991Sdim 3414276479Sdim computeVTablePaths(/*ForVBTables=*/true, RD, VBI->VBPtrPaths); 3415276479Sdim 3416261991Sdim // First, see if the Derived class shared the vbptr with a non-virtual base. 3417276479Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 3418261991Sdim if (const CXXRecordDecl *VBPtrBase = Layout.getBaseSharingVBPtr()) { 3419276479Sdim // If the Derived class shares the vbptr with a non-virtual base, the shared 3420276479Sdim // virtual bases come first so that the layout is the same. 3421276479Sdim const VirtualBaseInfo *BaseInfo = 3422276479Sdim computeVBTableRelatedInformation(VBPtrBase); 3423276479Sdim VBI->VBTableIndices.insert(BaseInfo->VBTableIndices.begin(), 3424276479Sdim BaseInfo->VBTableIndices.end()); 3425261991Sdim } 3426261991Sdim 3427261991Sdim // New vbases are added to the end of the vbtable. 3428261991Sdim // Skip the self entry and vbases visited in the non-virtual base, if any. 3429276479Sdim unsigned VBTableIndex = 1 + VBI->VBTableIndices.size(); 3430276479Sdim for (const auto &VB : RD->vbases()) { 3431276479Sdim const CXXRecordDecl *CurVBase = VB.getType()->getAsCXXRecordDecl(); 3432276479Sdim if (!VBI->VBTableIndices.count(CurVBase)) 3433276479Sdim VBI->VBTableIndices[CurVBase] = VBTableIndex++; 3434261991Sdim } 3435276479Sdim 3436276479Sdim return VBI; 3437261991Sdim} 3438261991Sdim 3439276479Sdimunsigned MicrosoftVTableContext::getVBTableIndex(const CXXRecordDecl *Derived, 3440276479Sdim const CXXRecordDecl *VBase) { 3441276479Sdim const VirtualBaseInfo *VBInfo = computeVBTableRelatedInformation(Derived); 3442276479Sdim assert(VBInfo->VBTableIndices.count(VBase)); 3443276479Sdim return VBInfo->VBTableIndices.find(VBase)->second; 3444276479Sdim} 3445276479Sdim 3446276479Sdimconst VPtrInfoVector & 3447276479SdimMicrosoftVTableContext::enumerateVBTables(const CXXRecordDecl *RD) { 3448276479Sdim return computeVBTableRelatedInformation(RD)->VBPtrPaths; 3449276479Sdim} 3450276479Sdim 3451276479Sdimconst VPtrInfoVector & 3452261991SdimMicrosoftVTableContext::getVFPtrOffsets(const CXXRecordDecl *RD) { 3453261991Sdim computeVTableRelatedInformation(RD); 3454261991Sdim 3455261991Sdim assert(VFPtrLocations.count(RD) && "Couldn't find vfptr locations"); 3456276479Sdim return *VFPtrLocations[RD]; 3457261991Sdim} 3458261991Sdim 3459261991Sdimconst VTableLayout & 3460261991SdimMicrosoftVTableContext::getVFTableLayout(const CXXRecordDecl *RD, 3461261991Sdim CharUnits VFPtrOffset) { 3462261991Sdim computeVTableRelatedInformation(RD); 3463261991Sdim 3464261991Sdim VFTableIdTy id(RD, VFPtrOffset); 3465261991Sdim assert(VFTableLayouts.count(id) && "Couldn't find a VFTable at this offset"); 3466261991Sdim return *VFTableLayouts[id]; 3467261991Sdim} 3468261991Sdim 3469261991Sdimconst MicrosoftVTableContext::MethodVFTableLocation & 3470261991SdimMicrosoftVTableContext::getMethodVFTableLocation(GlobalDecl GD) { 3471261991Sdim assert(cast<CXXMethodDecl>(GD.getDecl())->isVirtual() && 3472261991Sdim "Only use this method for virtual methods or dtors"); 3473261991Sdim if (isa<CXXDestructorDecl>(GD.getDecl())) 3474261991Sdim assert(GD.getDtorType() == Dtor_Deleting); 3475261991Sdim 3476261991Sdim MethodVFTableLocationsTy::iterator I = MethodVFTableLocations.find(GD); 3477261991Sdim if (I != MethodVFTableLocations.end()) 3478261991Sdim return I->second; 3479261991Sdim 3480261991Sdim const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent(); 3481261991Sdim 3482261991Sdim computeVTableRelatedInformation(RD); 3483261991Sdim 3484261991Sdim I = MethodVFTableLocations.find(GD); 3485261991Sdim assert(I != MethodVFTableLocations.end() && "Did not find index!"); 3486261991Sdim return I->second; 3487261991Sdim} 3488