contrib/llvm-project/clang/lib/CodeGen/CGVTables.h

   1 //===--- CGVTables.h - Emit LLVM Code for C++ vtables -----------*- 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 C++ code generation of virtual tables.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGVTABLES_H
  14 #define LLVM_CLANG_LIB_CODEGEN_CGVTABLES_H
  15
  16 #include "clang/AST/BaseSubobject.h"
  17 #include "clang/AST/CharUnits.h"
  18 #include "clang/AST/GlobalDecl.h"
  19 #include "clang/AST/VTableBuilder.h"
  20 #include "clang/Basic/ABI.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/IR/GlobalVariable.h"
  23
  24 namespace clang {
  25   class CXXRecordDecl;
  26
  27 namespace CodeGen {
  28   class CodeGenModule;
  29   class ConstantArrayBuilder;
  30   class ConstantStructBuilder;
  31
  32 class CodeGenVTables {
  33   CodeGenModule &CGM;
  34
  35   VTableContextBase *VTContext;
  36
  37   /// VTableAddressPointsMapTy - Address points for a single vtable.
  38   typedef VTableLayout::AddressPointsMapTy VTableAddressPointsMapTy;
  39
  40   typedef std::pair<const CXXRecordDecl *, BaseSubobject> BaseSubobjectPairTy;
  41   typedef llvm::DenseMap<BaseSubobjectPairTy, uint64_t> SubVTTIndiciesMapTy;
  42
  43   /// SubVTTIndicies - Contains indices into the various sub-VTTs.
  44   SubVTTIndiciesMapTy SubVTTIndicies;
  45
  46   typedef llvm::DenseMap<BaseSubobjectPairTy, uint64_t>
  47     SecondaryVirtualPointerIndicesMapTy;
  48
  49   /// SecondaryVirtualPointerIndices - Contains the secondary virtual pointer
  50   /// indices.
  51   SecondaryVirtualPointerIndicesMapTy SecondaryVirtualPointerIndices;
  52
  53   /// Cache for the pure virtual member call function.
  54   llvm::Constant *PureVirtualFn = nullptr;
  55
  56   /// Cache for the deleted virtual member call function.
  57   llvm::Constant *DeletedVirtualFn = nullptr;
  58
  59   /// Get the address of a thunk and emit it if necessary.
  60   llvm::Constant *maybeEmitThunk(GlobalDecl GD,
  61                                  const ThunkInfo &ThunkAdjustments,
  62                                  bool ForVTable);
  63
  64   void addVTableComponent(ConstantArrayBuilder &builder,
  65                           const VTableLayout &layout, unsigned componentIndex,
  66                           llvm::Constant *rtti, unsigned &nextVTableThunkIndex,
  67                           unsigned vtableAddressPoint,
  68                           bool vtableHasLocalLinkage);
  69
  70   /// Add a 32-bit offset to a component relative to the vtable when using the
  71   /// relative vtables ABI. The array builder points to the start of the vtable.
  72   void addRelativeComponent(ConstantArrayBuilder &builder,
  73                             llvm::Constant *component,
  74                             unsigned vtableAddressPoint,
  75                             bool vtableHasLocalLinkage,
  76                             bool isCompleteDtor) const;
  77
  78   bool useRelativeLayout() const;
  79
  80   llvm::Type *getVTableComponentType() const;
  81
  82 public:
  83   /// Add vtable components for the given vtable layout to the given
  84   /// global initializer.
  85   void createVTableInitializer(ConstantStructBuilder &builder,
  86                                const VTableLayout &layout, llvm::Constant *rtti,
  87                                bool vtableHasLocalLinkage);
  88
  89   CodeGenVTables(CodeGenModule &CGM);
  90
  91   ItaniumVTableContext &getItaniumVTableContext() {
  92     return *cast<ItaniumVTableContext>(VTContext);
  93   }
  94
  95   const ItaniumVTableContext &getItaniumVTableContext() const {
  96     return *cast<ItaniumVTableContext>(VTContext);
  97   }
  98
  99   MicrosoftVTableContext &getMicrosoftVTableContext() {
 100     return *cast<MicrosoftVTableContext>(VTContext);
 101   }
 102
 103   /// getSubVTTIndex - Return the index of the sub-VTT for the base class of the
 104   /// given record decl.
 105   uint64_t getSubVTTIndex(const CXXRecordDecl *RD, BaseSubobject Base);
 106
 107   /// getSecondaryVirtualPointerIndex - Return the index in the VTT where the
 108   /// virtual pointer for the given subobject is located.
 109   uint64_t getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD,
 110                                            BaseSubobject Base);
 111
 112   /// GenerateConstructionVTable - Generate a construction vtable for the given
 113   /// base subobject.
 114   llvm::GlobalVariable *
 115   GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base,
 116                              bool BaseIsVirtual,
 117                              llvm::GlobalVariable::LinkageTypes Linkage,
 118                              VTableAddressPointsMapTy& AddressPoints);
 119
 120
 121   /// GetAddrOfVTT - Get the address of the VTT for the given record decl.
 122   llvm::GlobalVariable *GetAddrOfVTT(const CXXRecordDecl *RD);
 123
 124   /// EmitVTTDefinition - Emit the definition of the given vtable.
 125   void EmitVTTDefinition(llvm::GlobalVariable *VTT,
 126                          llvm::GlobalVariable::LinkageTypes Linkage,
 127                          const CXXRecordDecl *RD);
 128
 129   /// EmitThunks - Emit the associated thunks for the given global decl.
 130   void EmitThunks(GlobalDecl GD);
 131
 132   /// GenerateClassData - Generate all the class data required to be
 133   /// generated upon definition of a KeyFunction.  This includes the
 134   /// vtable, the RTTI data structure (if RTTI is enabled) and the VTT
 135   /// (if the class has virtual bases).
 136   void GenerateClassData(const CXXRecordDecl *RD);
 137
 138   bool isVTableExternal(const CXXRecordDecl *RD);
 139
 140   /// Returns the type of a vtable with the given layout. Normally a struct of
 141   /// arrays of pointers, with one struct element for each vtable in the vtable
 142   /// group.
 143   llvm::Type *getVTableType(const VTableLayout &layout);
 144
 145   /// Generate a public facing alias for the vtable and make the vtable either
 146   /// hidden or private. The alias will have the original linkage and visibility
 147   /// of the vtable. This is used for cases under the relative vtables ABI
 148   /// when a vtable may not be dso_local.
 149   void GenerateRelativeVTableAlias(llvm::GlobalVariable *VTable,
 150                                    llvm::StringRef AliasNameRef);
 151
 152   /// Specify a global should not be instrumented with hwasan.
 153   void RemoveHwasanMetadata(llvm::GlobalValue *GV) const;
 154 };
 155
 156 } // end namespace CodeGen
 157 } // end namespace clang
 158 #endif