Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

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