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