contrib/llvm/tools/clang/include/clang/AST/VTTBuilder.h

   1 //===--- VTTBuilder.h - C++ VTT layout builder --------------------*- C++ -*-=//
   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 #ifndef LLVM_CLANG_AST_VTTBUILDER_H
  16 #define LLVM_CLANG_AST_VTTBUILDER_H
  17
  18 #include "clang/AST/BaseSubobject.h"
  19 #include "clang/AST/CXXInheritance.h"
  20 #include "clang/AST/GlobalDecl.h"
  21 #include "clang/AST/RecordLayout.h"
  22 #include "clang/Basic/ABI.h"
  23 #include "llvm/ADT/SetVector.h"
  24 #include <utility>
  25
  26 namespace clang {
  27
  28 class VTTVTable {
  29   llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> BaseAndIsVirtual;
  30   CharUnits BaseOffset;
  31
  32 public:
  33   VTTVTable() {}
  34   VTTVTable(const CXXRecordDecl *Base, CharUnits BaseOffset, bool BaseIsVirtual)
  35     : BaseAndIsVirtual(Base, BaseIsVirtual), BaseOffset(BaseOffset) {}
  36   VTTVTable(BaseSubobject Base, bool BaseIsVirtual)
  37     : BaseAndIsVirtual(Base.getBase(), BaseIsVirtual),
  38       BaseOffset(Base.getBaseOffset()) {}
  39
  40   const CXXRecordDecl *getBase() const {
  41     return BaseAndIsVirtual.getPointer();
  42   }
  43
  44   CharUnits getBaseOffset() const {
  45     return BaseOffset;
  46   }
  47
  48   bool isVirtual() const {
  49     return BaseAndIsVirtual.getInt();
  50   }
  51
  52   BaseSubobject getBaseSubobject() const {
  53     return BaseSubobject(getBase(), getBaseOffset());
  54   }
  55 };
  56
  57 struct VTTComponent {
  58   uint64_t VTableIndex;
  59   BaseSubobject VTableBase;
  60
  61   VTTComponent() {}
  62   VTTComponent(uint64_t VTableIndex, BaseSubobject VTableBase)
  63     : VTableIndex(VTableIndex), VTableBase(VTableBase) {}
  64 };
  65
  66 /// \brief Class for building VTT layout information.
  67 class VTTBuilder {
  68
  69   ASTContext &Ctx;
  70
  71   /// \brief The most derived class for which we're building this vtable.
  72   const CXXRecordDecl *MostDerivedClass;
  73
  74   typedef SmallVector<VTTVTable, 64> VTTVTablesVectorTy;
  75
  76   /// \brief The VTT vtables.
  77   VTTVTablesVectorTy VTTVTables;
  78
  79   typedef SmallVector<VTTComponent, 64> VTTComponentsVectorTy;
  80
  81   /// \brief The VTT components.
  82   VTTComponentsVectorTy VTTComponents;
  83
  84   /// \brief The AST record layout of the most derived class.
  85   const ASTRecordLayout &MostDerivedClassLayout;
  86
  87   typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
  88
  89   typedef llvm::DenseMap<BaseSubobject, uint64_t> AddressPointsMapTy;
  90
  91   /// \brief The sub-VTT indices for the bases of the most derived class.
  92   llvm::DenseMap<BaseSubobject, uint64_t> SubVTTIndicies;
  93
  94   /// \brief The secondary virtual pointer indices of all subobjects of
  95   /// the most derived class.
  96   llvm::DenseMap<BaseSubobject, uint64_t> SecondaryVirtualPointerIndices;
  97
  98   /// \brief Whether the VTT builder should generate LLVM IR for the VTT.
  99   bool GenerateDefinition;
 100
 101   /// \brief Add a vtable pointer to the VTT currently being built.
 102   void AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
 103                         const CXXRecordDecl *VTableClass);
 104
 105   /// \brief Lay out the secondary VTTs of the given base subobject.
 106   void LayoutSecondaryVTTs(BaseSubobject Base);
 107
 108   /// \brief Lay out the secondary virtual pointers for the given base
 109   /// subobject.
 110   ///
 111   /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
 112   /// or a direct or indirect base of a virtual base.
 113   void LayoutSecondaryVirtualPointers(BaseSubobject Base,
 114                                       bool BaseIsMorallyVirtual,
 115                                       uint64_t VTableIndex,
 116                                       const CXXRecordDecl *VTableClass,
 117                                       VisitedVirtualBasesSetTy &VBases);
 118
 119   /// \brief Lay out the secondary virtual pointers for the given base
 120   /// subobject.
 121   void LayoutSecondaryVirtualPointers(BaseSubobject Base,
 122                                       uint64_t VTableIndex);
 123
 124   /// \brief Lay out the VTTs for the virtual base classes of the given
 125   /// record declaration.
 126   void LayoutVirtualVTTs(const CXXRecordDecl *RD,
 127                          VisitedVirtualBasesSetTy &VBases);
 128
 129   /// \brief Lay out the VTT for the given subobject, including any
 130   /// secondary VTTs, secondary virtual pointers and virtual VTTs.
 131   void LayoutVTT(BaseSubobject Base, bool BaseIsVirtual);
 132
 133 public:
 134   VTTBuilder(ASTContext &Ctx, const CXXRecordDecl *MostDerivedClass,
 135              bool GenerateDefinition);
 136
 137   // \brief Returns a reference to the VTT components.
 138   const VTTComponentsVectorTy &getVTTComponents() const {
 139     return VTTComponents;
 140   }
 141
 142   // \brief Returns a reference to the VTT vtables.
 143   const VTTVTablesVectorTy &getVTTVTables() const {
 144     return VTTVTables;
 145   }
 146
 147   /// \brief Returns a reference to the sub-VTT indices.
 148   const llvm::DenseMap<BaseSubobject, uint64_t> &getSubVTTIndicies() const {
 149     return SubVTTIndicies;
 150   }
 151
 152   /// \brief Returns a reference to the secondary virtual pointer indices.
 153   const llvm::DenseMap<BaseSubobject, uint64_t> &
 154   getSecondaryVirtualPointerIndices() const {
 155     return SecondaryVirtualPointerIndices;
 156   }
 157
 158 };
 159
 160 }
 161
 162 #endif