contrib/llvm/tools/clang/lib/AST/VTTBuilder.cpp

   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 }