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 /// VTT builder - Class for building VTT layout information.
  67 class VTTBuilder {
  68
  69   ASTContext &Ctx;
  70
  71   /// MostDerivedClass - The most derived class for which we're building this
  72   /// vtable.
  73   const CXXRecordDecl *MostDerivedClass;
  74
  75   typedef SmallVector<VTTVTable, 64> VTTVTablesVectorTy;
  76
  77   /// VTTVTables - The VTT vtables.
  78   VTTVTablesVectorTy VTTVTables;
  79
  80   typedef SmallVector<VTTComponent, 64> VTTComponentsVectorTy;
  81
  82   /// VTTComponents - The VTT components.
  83   VTTComponentsVectorTy VTTComponents;
  84
  85   /// MostDerivedClassLayout - the AST record layout of the most derived class.
  86   const ASTRecordLayout &MostDerivedClassLayout;
  87
  88   typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
  89
  90   typedef llvm::DenseMap<BaseSubobject, uint64_t> AddressPointsMapTy;
  91
  92   /// SubVTTIndicies - The sub-VTT indices for the bases of the most derived
  93   /// class.
  94   llvm::DenseMap<BaseSubobject, uint64_t> SubVTTIndicies;
  95
  96   /// SecondaryVirtualPointerIndices - The secondary virtual pointer indices of
  97   /// all subobjects of the most derived class.
  98   llvm::DenseMap<BaseSubobject, uint64_t> SecondaryVirtualPointerIndices;
  99
 100   /// GenerateDefinition - Whether the VTT builder should generate LLVM IR for
 101   /// the VTT.
 102   bool GenerateDefinition;
 103
 104   /// AddVTablePointer - Add a vtable pointer to the VTT currently being built.
 105   void AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
 106                         const CXXRecordDecl *VTableClass);
 107
 108   /// LayoutSecondaryVTTs - Lay out the secondary VTTs of the given base
 109   /// subobject.
 110   void LayoutSecondaryVTTs(BaseSubobject Base);
 111
 112   /// LayoutSecondaryVirtualPointers - Lay out the secondary virtual pointers
 113   /// for the given base subobject.
 114   ///
 115   /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
 116   /// or a direct or indirect base of a virtual base.
 117   void LayoutSecondaryVirtualPointers(BaseSubobject Base,
 118                                       bool BaseIsMorallyVirtual,
 119                                       uint64_t VTableIndex,
 120                                       const CXXRecordDecl *VTableClass,
 121                                       VisitedVirtualBasesSetTy &VBases);
 122
 123   /// LayoutSecondaryVirtualPointers - Lay out the secondary virtual pointers
 124   /// for the given base subobject.
 125   void LayoutSecondaryVirtualPointers(BaseSubobject Base,
 126                                       uint64_t VTableIndex);
 127
 128   /// LayoutVirtualVTTs - Lay out the VTTs for the virtual base classes of the
 129   /// given record decl.
 130   void LayoutVirtualVTTs(const CXXRecordDecl *RD,
 131                          VisitedVirtualBasesSetTy &VBases);
 132
 133   /// LayoutVTT - Will lay out the VTT for the given subobject, including any
 134   /// secondary VTTs, secondary virtual pointers and virtual VTTs.
 135   void LayoutVTT(BaseSubobject Base, bool BaseIsVirtual);
 136
 137 public:
 138   VTTBuilder(ASTContext &Ctx, const CXXRecordDecl *MostDerivedClass,
 139              bool GenerateDefinition);
 140
 141   // getVTTComponents - Returns a reference to the VTT components.
 142   const VTTComponentsVectorTy &getVTTComponents() const {
 143     return VTTComponents;
 144   }
 145
 146   // getVTTVTables - Returns a reference to the VTT vtables.
 147   const VTTVTablesVectorTy &getVTTVTables() const {
 148     return VTTVTables;
 149   }
 150
 151   /// getSubVTTIndicies - Returns a reference to the sub-VTT indices.
 152   const llvm::DenseMap<BaseSubobject, uint64_t> &getSubVTTIndicies() const {
 153     return SubVTTIndicies;
 154   }
 155
 156   /// getSecondaryVirtualPointerIndices - Returns a reference to the secondary
 157   /// virtual pointer indices.
 158   const llvm::DenseMap<BaseSubobject, uint64_t> &
 159   getSecondaryVirtualPointerIndices() const {
 160     return SecondaryVirtualPointerIndices;
 161   }
 162
 163 };
 164
 165 }
 166
 167 #endif