File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/lib/CodeGen

usr / src / contrib / llvm-project / clang / lib / CodeGen /

📁 ..
📄 ABIInfo.h(5.01 KB)
📄 Address.h(3.28 KB)
📄 BackendUtil.cpp(67.92 KB)
📄 CGAtomic.cpp(85.95 KB)
📄 CGBlocks.cpp(111.14 KB)
📄 CGBlocks.h(8.94 KB)
📄 CGBuilder.h(13.78 KB)
📄 CGBuiltin.cpp(695.8 KB)
📄 CGCUDANV.cpp(35.16 KB)
📄 CGCUDARuntime.cpp(1.53 KB)
📄 CGCUDARuntime.h(3.4 KB)
📄 CGCXX.cpp(11.8 KB)
📄 CGCXXABI.cpp(12.47 KB)
📄 CGCXXABI.h(27.9 KB)
📄 CGCall.cpp(197.3 KB)
📄 CGCall.h(11.62 KB)
📄 CGClass.cpp(113.54 KB)
📄 CGCleanup.cpp(46.97 KB)
📄 CGCleanup.h(19.28 KB)
📄 CGCoroutine.cpp(27.82 KB)
📄 CGDebugInfo.cpp(191.42 KB)
📄 CGDebugInfo.h(34.73 KB)
📄 CGDecl.cpp(97.98 KB)
📄 CGDeclCXX.cpp(34.73 KB)
📄 CGException.cpp(80.38 KB)
📄 CGExpr.cpp(209.78 KB)
📄 CGExprAgg.cpp(77.04 KB)
📄 CGExprCXX.cpp(90.39 KB)
📄 CGExprComplex.cpp(44.9 KB)
📄 CGExprConstant.cpp(86.17 KB)
📄 CGExprScalar.cpp(196.29 KB)
📄 CGGPUBuiltin.cpp(6.17 KB)
📄 CGLoopInfo.cpp(29.17 KB)
📄 CGLoopInfo.h(10.5 KB)
📄 CGNonTrivialStruct.cpp(41.4 KB)
📄 CGObjC.cpp(142.79 KB)
📄 CGObjCGNU.cpp(168.38 KB)
📄 CGObjCMac.cpp(304.84 KB)
📄 CGObjCRuntime.cpp(14.68 KB)
📄 CGObjCRuntime.h(14.81 KB)
📄 CGOpenCLRuntime.cpp(7.08 KB)
📄 CGOpenCLRuntime.h(3.44 KB)
📄 CGOpenMPRuntime.cpp(501.86 KB)
📄 CGOpenMPRuntime.h(111.87 KB)
📄 CGOpenMPRuntimeNVPTX.cpp(215.42 KB)
📄 CGOpenMPRuntimeNVPTX.h(22.59 KB)
📄 CGRecordLayout.h(7.84 KB)
📄 CGRecordLayoutBuilder.cpp(38.24 KB)
📄 CGStmt.cpp(92.92 KB)
📄 CGStmtOpenMP.cpp(278.04 KB)
📄 CGVTT.cpp(6.81 KB)
📄 CGVTables.cpp(55.02 KB)
📄 CGVTables.h(6.38 KB)
📄 CGValue.h(21.24 KB)
📄 CodeGenABITypes.cpp(5 KB)
📄 CodeGenAction.cpp(46.2 KB)
📄 CodeGenFunction.cpp(95.34 KB)
📄 CodeGenFunction.h(200.94 KB)
📄 CodeGenModule.cpp(228.13 KB)
📄 CodeGenModule.h(60.91 KB)
📄 CodeGenPGO.cpp(36.17 KB)
📄 CodeGenPGO.h(4.36 KB)
📄 CodeGenTBAA.cpp(16.92 KB)
📄 CodeGenTBAA.h(9.19 KB)
📄 CodeGenTypeCache.h(3.28 KB)
📄 CodeGenTypes.cpp(32.35 KB)
📄 CodeGenTypes.h(13.42 KB)
📄 ConstantEmitter.h(6.65 KB)
📄 ConstantInitBuilder.cpp(10.29 KB)
📄 CoverageMappingGen.cpp(54.64 KB)
📄 CoverageMappingGen.h(4.04 KB)
📄 EHScopeStack.h(14.38 KB)
📄 ItaniumCXXABI.cpp(176.66 KB)
📄 MacroPPCallbacks.cpp(6.41 KB)
📄 MacroPPCallbacks.h(4.54 KB)
📄 MicrosoftCXXABI.cpp(175.41 KB)
📄 ModuleBuilder.cpp(11.79 KB)
📄 ObjectFilePCHContainerOperations.cpp(12.93 KB)
📄 PatternInit.cpp(4.1 KB)
📄 PatternInit.h(722 B)
📄 SanitizerMetadata.cpp(4.21 KB)
📄 SanitizerMetadata.h(1.63 KB)
📄 SwiftCallingConv.cpp(29.76 KB)
📄 TargetInfo.cpp(403.11 KB)
📄 TargetInfo.h(15.43 KB)
📄 VarBypassDetector.cpp(5.1 KB)
📄 VarBypassDetector.h(2.29 KB)

Editing: CGVTables.h

//===--- CGVTables.h - Emit LLVM Code for C++ vtables -----------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This contains code dealing with C++ code generation of virtual tables.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LIB_CODEGEN_CGVTABLES_H
#define LLVM_CLANG_LIB_CODEGEN_CGVTABLES_H

#include "clang/AST/BaseSubobject.h"
#include "clang/AST/CharUnits.h"
#include "clang/AST/GlobalDecl.h"
#include "clang/AST/VTableBuilder.h"
#include "clang/Basic/ABI.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/IR/GlobalVariable.h"

namespace clang {
  class CXXRecordDecl;

namespace CodeGen {
  class CodeGenModule;
  class ConstantArrayBuilder;
  class ConstantStructBuilder;

class CodeGenVTables {
  CodeGenModule &CGM;

VTableContextBase *VTContext;

/// VTableAddressPointsMapTy - Address points for a single vtable.
  typedef VTableLayout::AddressPointsMapTy VTableAddressPointsMapTy;

typedef std::pair<const CXXRecordDecl *, BaseSubobject> BaseSubobjectPairTy;
  typedef llvm::DenseMap<BaseSubobjectPairTy, uint64_t> SubVTTIndiciesMapTy;

/// SubVTTIndicies - Contains indices into the various sub-VTTs.
  SubVTTIndiciesMapTy SubVTTIndicies;

typedef llvm::DenseMap<BaseSubobjectPairTy, uint64_t>
    SecondaryVirtualPointerIndicesMapTy;

/// SecondaryVirtualPointerIndices - Contains the secondary virtual pointer
  /// indices.
  SecondaryVirtualPointerIndicesMapTy SecondaryVirtualPointerIndices;

/// Cache for the pure virtual member call function.
  llvm::Constant *PureVirtualFn = nullptr;

/// Cache for the deleted virtual member call function.
  llvm::Constant *DeletedVirtualFn = nullptr;

/// Get the address of a thunk and emit it if necessary.
  llvm::Constant *maybeEmitThunk(GlobalDecl GD,
                                 const ThunkInfo &ThunkAdjustments,
                                 bool ForVTable);

void addVTableComponent(ConstantArrayBuilder &builder,
                          const VTableLayout &layout, unsigned componentIndex,
                          llvm::Constant *rtti, unsigned &nextVTableThunkIndex,
                          unsigned vtableAddressPoint,
                          bool vtableHasLocalLinkage);

/// Add a 32-bit offset to a component relative to the vtable when using the
  /// relative vtables ABI. The array builder points to the start of the vtable.
  void addRelativeComponent(ConstantArrayBuilder &builder,
                            llvm::Constant *component,
                            unsigned vtableAddressPoint,
                            bool vtableHasLocalLinkage,
                            bool isCompleteDtor) const;

/// Create a dso_local stub that will be used for a relative reference in the
  /// relative vtable layout. This stub will just be a tail call to the original
  /// function and propagate any function attributes from the original. If the
  /// original function is already dso_local, the original is returned instead
  /// and a stub is not created.
  llvm::Function *
  getOrCreateRelativeStub(llvm::Function *func,
                          llvm::GlobalValue::LinkageTypes stubLinkage,
                          bool isCompleteDtor) const;

bool useRelativeLayout() const;

llvm::Type *getVTableComponentType() const;

public:
  /// Add vtable components for the given vtable layout to the given
  /// global initializer.
  void createVTableInitializer(ConstantStructBuilder &builder,
                               const VTableLayout &layout, llvm::Constant *rtti,
                               bool vtableHasLocalLinkage);

CodeGenVTables(CodeGenModule &CGM);

ItaniumVTableContext &getItaniumVTableContext() {
    return *cast<ItaniumVTableContext>(VTContext);
  }

MicrosoftVTableContext &getMicrosoftVTableContext() {
    return *cast<MicrosoftVTableContext>(VTContext);
  }

/// getSubVTTIndex - Return the index of the sub-VTT for the base class of the
  /// given record decl.
  uint64_t getSubVTTIndex(const CXXRecordDecl *RD, BaseSubobject Base);

/// getSecondaryVirtualPointerIndex - Return the index in the VTT where the
  /// virtual pointer for the given subobject is located.
  uint64_t getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD,
                                           BaseSubobject Base);

/// GenerateConstructionVTable - Generate a construction vtable for the given
  /// base subobject.
  llvm::GlobalVariable *
  GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base,
                             bool BaseIsVirtual,
                             llvm::GlobalVariable::LinkageTypes Linkage,
                             VTableAddressPointsMapTy& AddressPoints);

/// GetAddrOfVTT - Get the address of the VTT for the given record decl.
  llvm::GlobalVariable *GetAddrOfVTT(const CXXRecordDecl *RD);

/// EmitVTTDefinition - Emit the definition of the given vtable.
  void EmitVTTDefinition(llvm::GlobalVariable *VTT,
                         llvm::GlobalVariable::LinkageTypes Linkage,
                         const CXXRecordDecl *RD);

/// EmitThunks - Emit the associated thunks for the given global decl.
  void EmitThunks(GlobalDecl GD);

/// GenerateClassData - Generate all the class data required to be
  /// generated upon definition of a KeyFunction.  This includes the
  /// vtable, the RTTI data structure (if RTTI is enabled) and the VTT
  /// (if the class has virtual bases).
  void GenerateClassData(const CXXRecordDecl *RD);

bool isVTableExternal(const CXXRecordDecl *RD);

/// Returns the type of a vtable with the given layout. Normally a struct of
  /// arrays of pointers, with one struct element for each vtable in the vtable
  /// group.
  llvm::Type *getVTableType(const VTableLayout &layout);

/// Generate a public facing alias for the vtable and make the vtable either
  /// hidden or private. The alias will have the original linkage and visibility
  /// of the vtable. This is used for cases under the relative vtables ABI
  /// when a vtable may not be dso_local.
  void GenerateRelativeVTableAlias(llvm::GlobalVariable *VTable,
                                   llvm::StringRef AliasNameRef);
};

} // end namespace CodeGen
} // end namespace clang
#endif

003 File Manager

Editing: CGVTables.h

Upload File

Create Folder