Home | History | Annotate | Download | only in AST
      1 //===--- VTTBuilder.cpp - C++ VTT layout builder --------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This contains code dealing with generation of the layout of virtual table
     11 // tables (VTT).
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "clang/AST/VTTBuilder.h"
     16 #include "clang/AST/ASTContext.h"
     17 #include "clang/AST/CXXInheritance.h"
     18 #include "clang/AST/RecordLayout.h"
     19 #include "clang/Basic/TargetInfo.h"
     20 #include "llvm/Support/Format.h"
     21 #include <algorithm>
     22 #include <cstdio>
     23 
     24 using namespace clang;
     25 
     26 #define DUMP_OVERRIDERS 0
     27 
     28 VTTBuilder::VTTBuilder(ASTContext &Ctx,
     29                        const CXXRecordDecl *MostDerivedClass,
     30                        bool GenerateDefinition)
     31   : Ctx(Ctx), MostDerivedClass(MostDerivedClass),
     32   MostDerivedClassLayout(Ctx.getASTRecordLayout(MostDerivedClass)),
     33     GenerateDefinition(GenerateDefinition) {
     34   // Lay out this VTT.
     35   LayoutVTT(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
     36             /*BaseIsVirtual=*/false);
     37 }
     38 
     39 void VTTBuilder::AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
     40                                   const CXXRecordDecl *VTableClass) {
     41   // Store the vtable pointer index if we're generating the primary VTT.
     42   if (VTableClass == MostDerivedClass) {
     43     assert(!SecondaryVirtualPointerIndices.count(Base) &&
     44            "A virtual pointer index already exists for this base subobject!");
     45     SecondaryVirtualPointerIndices[Base] = VTTComponents.size();
     46   }
     47 
     48   if (!GenerateDefinition) {
     49     VTTComponents.push_back(VTTComponent());
     50     return;
     51   }
     52 
     53   VTTComponents.push_back(VTTComponent(VTableIndex, Base));
     54 }
     55 
     56 void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) {
     57   const CXXRecordDecl *RD = Base.getBase();
     58 
     59   for (const auto &I : RD->bases()) {
     60     // Don't layout virtual bases.
     61     if (I.isVirtual())
     62         continue;
     63 
     64     const CXXRecordDecl *BaseDecl =
     65       cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
     66 
     67     const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
     68     CharUnits BaseOffset = Base.getBaseOffset() +
     69       Layout.getBaseClassOffset(BaseDecl);
     70 
     71     // Layout the VTT for this base.
     72     LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/false);
     73   }
     74 }
     75 
     76 void
     77 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
     78                                            bool BaseIsMorallyVirtual,
     79                                            uint64_t VTableIndex,
     80                                            const CXXRecordDecl *VTableClass,
     81                                            VisitedVirtualBasesSetTy &VBases) {
     82   const CXXRecordDecl *RD = Base.getBase();
     83 
     84   // We're not interested in bases that don't have virtual bases, and not
     85   // morally virtual bases.
     86   if (!RD->getNumVBases() && !BaseIsMorallyVirtual)
     87     return;
     88 
     89   for (const auto &I : RD->bases()) {
     90     const CXXRecordDecl *BaseDecl =
     91       cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
     92 
     93     // Itanium C++ ABI 2.6.2:
     94     //   Secondary virtual pointers are present for all bases with either
     95     //   virtual bases or virtual function declarations overridden along a
     96     //   virtual path.
     97     //
     98     // If the base class is not dynamic, we don't want to add it, nor any
     99     // of its base classes.
    100     if (!BaseDecl->isDynamicClass())
    101       continue;
    102 
    103     bool BaseDeclIsMorallyVirtual = BaseIsMorallyVirtual;
    104     bool BaseDeclIsNonVirtualPrimaryBase = false;
    105     CharUnits BaseOffset;
    106     if (I.isVirtual()) {
    107       // Ignore virtual bases that we've already visited.
    108       if (!VBases.insert(BaseDecl))
    109         continue;
    110 
    111       BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
    112       BaseDeclIsMorallyVirtual = true;
    113     } else {
    114       const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
    115 
    116       BaseOffset = Base.getBaseOffset() +
    117         Layout.getBaseClassOffset(BaseDecl);
    118 
    119       if (!Layout.isPrimaryBaseVirtual() &&
    120           Layout.getPrimaryBase() == BaseDecl)
    121         BaseDeclIsNonVirtualPrimaryBase = true;
    122     }
    123 
    124     // Itanium C++ ABI 2.6.2:
    125     //   Secondary virtual pointers: for each base class X which (a) has virtual
    126     //   bases or is reachable along a virtual path from D, and (b) is not a
    127     //   non-virtual primary base, the address of the virtual table for X-in-D
    128     //   or an appropriate construction virtual table.
    129     if (!BaseDeclIsNonVirtualPrimaryBase &&
    130         (BaseDecl->getNumVBases() || BaseDeclIsMorallyVirtual)) {
    131       // Add the vtable pointer.
    132       AddVTablePointer(BaseSubobject(BaseDecl, BaseOffset), VTableIndex,
    133                        VTableClass);
    134     }
    135 
    136     // And lay out the secondary virtual pointers for the base class.
    137     LayoutSecondaryVirtualPointers(BaseSubobject(BaseDecl, BaseOffset),
    138                                    BaseDeclIsMorallyVirtual, VTableIndex,
    139                                    VTableClass, VBases);
    140   }
    141 }
    142 
    143 void
    144 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
    145                                            uint64_t VTableIndex) {
    146   VisitedVirtualBasesSetTy VBases;
    147   LayoutSecondaryVirtualPointers(Base, /*BaseIsMorallyVirtual=*/false,
    148                                  VTableIndex, Base.getBase(), VBases);
    149 }
    150 
    151 void VTTBuilder::LayoutVirtualVTTs(const CXXRecordDecl *RD,
    152                                    VisitedVirtualBasesSetTy &VBases) {
    153   for (const auto &I : RD->bases()) {
    154     const CXXRecordDecl *BaseDecl =
    155       cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
    156 
    157     // Check if this is a virtual base.
    158     if (I.isVirtual()) {
    159       // Check if we've seen this base before.
    160       if (!VBases.insert(BaseDecl))
    161         continue;
    162 
    163       CharUnits BaseOffset =
    164         MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
    165 
    166       LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/true);
    167     }
    168 
    169     // We only need to layout virtual VTTs for this base if it actually has
    170     // virtual bases.
    171     if (BaseDecl->getNumVBases())
    172       LayoutVirtualVTTs(BaseDecl, VBases);
    173   }
    174 }
    175 
    176 void VTTBuilder::LayoutVTT(BaseSubobject Base, bool BaseIsVirtual) {
    177   const CXXRecordDecl *RD = Base.getBase();
    178 
    179   // Itanium C++ ABI 2.6.2:
    180   //   An array of virtual table addresses, called the VTT, is declared for
    181   //   each class type that has indirect or direct virtual base classes.
    182   if (RD->getNumVBases() == 0)
    183     return;
    184 
    185   bool IsPrimaryVTT = Base.getBase() == MostDerivedClass;
    186 
    187   if (!IsPrimaryVTT) {
    188     // Remember the sub-VTT index.
    189     SubVTTIndicies[Base] = VTTComponents.size();
    190   }
    191 
    192   uint64_t VTableIndex = VTTVTables.size();
    193   VTTVTables.push_back(VTTVTable(Base, BaseIsVirtual));
    194 
    195   // Add the primary vtable pointer.
    196   AddVTablePointer(Base, VTableIndex, RD);
    197 
    198   // Add the secondary VTTs.
    199   LayoutSecondaryVTTs(Base);
    200 
    201   // Add the secondary virtual pointers.
    202   LayoutSecondaryVirtualPointers(Base, VTableIndex);
    203 
    204   // If this is the primary VTT, we want to lay out virtual VTTs as well.
    205   if (IsPrimaryVTT) {
    206     VisitedVirtualBasesSetTy VBases;
    207     LayoutVirtualVTTs(Base.getBase(), VBases);
    208   }
    209 }
    210