Home | History | Annotate | Download | only in AST 
      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
    168