//===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- 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 is the internal per-translation-unit state used for llvm translation.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H

#define LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H

#include "CGVTables.h"

#include "CodeGenTypeCache.h"

#include "CodeGenTypes.h"

#include "SanitizerMetadata.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/DeclOpenMP.h"

#include "clang/AST/GlobalDecl.h"

#include "clang/AST/Mangle.h"

#include "clang/Basic/ABI.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/Module.h"

#include "clang/Basic/NoSanitizeList.h"

#include "clang/Basic/ProfileList.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/XRayLists.h"

#include "clang/Lex/PreprocessorOptions.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/IR/Module.h"

#include "llvm/IR/ValueHandle.h"

#include "llvm/Transforms/Utils/SanitizerStats.h"

#include <optional>

namespace llvm {

class Module;

class Constant;

class ConstantInt;

class Function;

class GlobalValue;

class DataLayout;

class FunctionType;

class LLVMContext;

class IndexedInstrProfReader;

namespace vfs {

class FileSystem;

}

}

namespace clang {

class ASTContext;

class AtomicType;

class FunctionDecl;

class IdentifierInfo;

class ObjCImplementationDecl;

class ObjCEncodeExpr;

class BlockExpr;

class CharUnits;

class Decl;

class Expr;

class Stmt;

class StringLiteral;

class NamedDecl;

class ValueDecl;

class VarDecl;

class LangOptions;

class CodeGenOptions;

class HeaderSearchOptions;

class DiagnosticsEngine;

class AnnotateAttr;

class CXXDestructorDecl;

class Module;

class CoverageSourceInfo;

class InitSegAttr;

namespace CodeGen {

class CodeGenFunction;

class CodeGenTBAA;

class CGCXXABI;

class CGDebugInfo;

class CGObjCRuntime;

class CGOpenCLRuntime;

class CGOpenMPRuntime;

class CGCUDARuntime;

class CGHLSLRuntime;

class CoverageMappingModuleGen;

class TargetCodeGenInfo;

enum ForDefinition_t : bool {

  NotForDefinition = false,

  ForDefinition = true

};

struct OrderGlobalInitsOrStermFinalizers {

  unsigned int priority;

  unsigned int lex_order;

  OrderGlobalInitsOrStermFinalizers(unsigned int p, unsigned int l)

      : priority(p), lex_order(l) {}

  bool operator==(const OrderGlobalInitsOrStermFinalizers &RHS) const {

    return priority == RHS.priority && lex_order == RHS.lex_order;

  }

  bool operator<(const OrderGlobalInitsOrStermFinalizers &RHS) const {

    return std::tie(priority, lex_order) <

           std::tie(RHS.priority, RHS.lex_order);

  }

};

struct ObjCEntrypoints {

  ObjCEntrypoints() { memset(this, 0, sizeof(*this)); }

  /// void objc_alloc(id);

  llvm::FunctionCallee objc_alloc;

  /// void objc_allocWithZone(id);

  llvm::FunctionCallee objc_allocWithZone;

  /// void objc_alloc_init(id);

  llvm::FunctionCallee objc_alloc_init;

  /// void objc_autoreleasePoolPop(void*);

  llvm::FunctionCallee objc_autoreleasePoolPop;

  /// void objc_autoreleasePoolPop(void*);

  /// Note this method is used when we are using exception handling

  llvm::FunctionCallee objc_autoreleasePoolPopInvoke;

  /// void *objc_autoreleasePoolPush(void);

  llvm::Function *objc_autoreleasePoolPush;

  /// id objc_autorelease(id);

  llvm::Function *objc_autorelease;

  /// id objc_autorelease(id);

  /// Note this is the runtime method not the intrinsic.

  llvm::FunctionCallee objc_autoreleaseRuntimeFunction;

  /// id objc_autoreleaseReturnValue(id);

  llvm::Function *objc_autoreleaseReturnValue;

  /// void objc_copyWeak(id *dest, id *src);

  llvm::Function *objc_copyWeak;

  /// void objc_destroyWeak(id*);

  llvm::Function *objc_destroyWeak;

  /// id objc_initWeak(id*, id);

  llvm::Function *objc_initWeak;

  /// id objc_loadWeak(id*);

  llvm::Function *objc_loadWeak;

  /// id objc_loadWeakRetained(id*);

  llvm::Function *objc_loadWeakRetained;

  /// void objc_moveWeak(id *dest, id *src);

  llvm::Function *objc_moveWeak;

  /// id objc_retain(id);

  llvm::Function *objc_retain;

  /// id objc_retain(id);

  /// Note this is the runtime method not the intrinsic.

  llvm::FunctionCallee objc_retainRuntimeFunction;

  /// id objc_retainAutorelease(id);

  llvm::Function *objc_retainAutorelease;

  /// id objc_retainAutoreleaseReturnValue(id);

  llvm::Function *objc_retainAutoreleaseReturnValue;

  /// id objc_retainAutoreleasedReturnValue(id);

  llvm::Function *objc_retainAutoreleasedReturnValue;

  /// id objc_retainBlock(id);

  llvm::Function *objc_retainBlock;

  /// void objc_release(id);

  llvm::Function *objc_release;

  /// void objc_release(id);

  /// Note this is the runtime method not the intrinsic.

  llvm::FunctionCallee objc_releaseRuntimeFunction;

  /// void objc_storeStrong(id*, id);

  llvm::Function *objc_storeStrong;

  /// id objc_storeWeak(id*, id);

  llvm::Function *objc_storeWeak;

  /// id objc_unsafeClaimAutoreleasedReturnValue(id);

  llvm::Function *objc_unsafeClaimAutoreleasedReturnValue;

  /// A void(void) inline asm to use to mark that the return value of

  /// a call will be immediately retain.

  llvm::InlineAsm *retainAutoreleasedReturnValueMarker;

  /// void clang.arc.use(...);

  llvm::Function *clang_arc_use;

  /// void clang.arc.noop.use(...);

  llvm::Function *clang_arc_noop_use;

};

/// This class records statistics on instrumentation based profiling.

class InstrProfStats {

  uint32_t VisitedInMainFile = 0;

  uint32_t MissingInMainFile = 0;

  uint32_t Visited = 0;

  uint32_t Missing = 0;

  uint32_t Mismatched = 0;

public:

  InstrProfStats() = default;

  /// Record that we've visited a function and whether or not that function was

  /// in the main source file.

  void addVisited(bool MainFile) {

    if (MainFile)

      ++VisitedInMainFile;

    ++Visited;

  }

  /// Record that a function we've visited has no profile data.

  void addMissing(bool MainFile) {

    if (MainFile)

      ++MissingInMainFile;

    ++Missing;

  }

  /// Record that a function we've visited has mismatched profile data.

  void addMismatched(bool MainFile) { ++Mismatched; }

  /// Whether or not the stats we've gathered indicate any potential problems.

  bool hasDiagnostics() { return Missing || Mismatched; }

  /// Report potential problems we've found to \c Diags.

  void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile);

};

/// A pair of helper functions for a __block variable.

class BlockByrefHelpers : public llvm::FoldingSetNode {

  // MSVC requires this type to be complete in order to process this

  // header.

public:

  llvm::Constant *CopyHelper;

  llvm::Constant *DisposeHelper;

  /// The alignment of the field.  This is important because

  /// different offsets to the field within the byref struct need to

  /// have different helper functions.

  CharUnits Alignment;

  BlockByrefHelpers(CharUnits alignment)

      : CopyHelper(nullptr), DisposeHelper(nullptr), Alignment(alignment) {}

  BlockByrefHelpers(const BlockByrefHelpers &) = default;

  virtual ~BlockByrefHelpers();

  void Profile(llvm::FoldingSetNodeID &id) const {

    id.AddInteger(Alignment.getQuantity());

    profileImpl(id);

  }

  virtual void profileImpl(llvm::FoldingSetNodeID &id) const = 0;

  virtual bool needsCopy() const { return true; }

  virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src) = 0;

  virtual bool needsDispose() const { return true; }

  virtual void emitDispose(CodeGenFunction &CGF, Address field) = 0;

};

/// This class organizes the cross-function state that is used while generating

/// LLVM code.

class CodeGenModule : public CodeGenTypeCache {

  CodeGenModule(const CodeGenModule &) = delete;

  void operator=(const CodeGenModule &) = delete;

public:

  struct Structor {

    Structor()

        : Priority(0), LexOrder(~0u), Initializer(nullptr),

          AssociatedData(nullptr) {}

    Structor(int Priority, unsigned LexOrder, llvm::Constant *Initializer,

             llvm::Constant *AssociatedData)

        : Priority(Priority), LexOrder(LexOrder), Initializer(Initializer),

          AssociatedData(AssociatedData) {}

    int Priority;

    unsigned LexOrder;

    llvm::Constant *Initializer;

    llvm::Constant *AssociatedData;

  };

  typedef std::vector<Structor> CtorList;

private:

  ASTContext &Context;

  const LangOptions &LangOpts;

  IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; // Only used for debug info.

  const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.

  const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.

  const CodeGenOptions &CodeGenOpts;

  unsigned NumAutoVarInit = 0;

  llvm::Module &TheModule;

  DiagnosticsEngine &Diags;

  const TargetInfo &Target;

  std::unique_ptr<CGCXXABI> ABI;

  llvm::LLVMContext &VMContext;

  std::string ModuleNameHash;

  bool CXX20ModuleInits = false;

  std::unique_ptr<CodeGenTBAA> TBAA;

  mutable std::unique_ptr<TargetCodeGenInfo> TheTargetCodeGenInfo;

  // This should not be moved earlier, since its initialization depends on some

  // of the previous reference members being already initialized and also checks

  // if TheTargetCodeGenInfo is NULL

  CodeGenTypes Types;

  /// Holds information about C++ vtables.

  CodeGenVTables VTables;

  std::unique_ptr<CGObjCRuntime> ObjCRuntime;

  std::unique_ptr<CGOpenCLRuntime> OpenCLRuntime;

  std::unique_ptr<CGOpenMPRuntime> OpenMPRuntime;

  std::unique_ptr<CGCUDARuntime> CUDARuntime;

  std::unique_ptr<CGHLSLRuntime> HLSLRuntime;

  std::unique_ptr<CGDebugInfo> DebugInfo;

  std::unique_ptr<ObjCEntrypoints> ObjCData;

  llvm::MDNode *NoObjCARCExceptionsMetadata = nullptr;

  std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;

  InstrProfStats PGOStats;

  std::unique_ptr<llvm::SanitizerStatReport> SanStats;

  // A set of references that have only been seen via a weakref so far. This is

  // used to remove the weak of the reference if we ever see a direct reference

  // or a definition.

  llvm::SmallPtrSet<llvm::GlobalValue*, 10> WeakRefReferences;

  /// This contains all the decls which have definitions but/ which are deferred

  /// for emission and therefore should only be output if they are actually

  /// used. If a decl is in this, then it is known to have not been referenced

  /// yet.

  llvm::DenseMap<StringRef, GlobalDecl> DeferredDecls;

  /// This is a list of deferred decls which we have seen that *are* actually

  /// referenced. These get code generated when the module is done.

  std::vector<GlobalDecl> DeferredDeclsToEmit;

  void addDeferredDeclToEmit(GlobalDecl GD) {

    DeferredDeclsToEmit.emplace_back(GD);

    addEmittedDeferredDecl(GD);

  }

  /// Decls that were DeferredDecls and have now been emitted.

  llvm::DenseMap<llvm::StringRef, GlobalDecl> EmittedDeferredDecls;

  void addEmittedDeferredDecl(GlobalDecl GD) {

    // Reemission is only needed in incremental mode.

    if (!Context.getLangOpts().IncrementalExtensions)

      return;

    // Assume a linkage by default that does not need reemission.

    auto L = llvm::GlobalValue::ExternalLinkage;

    if (llvm::isa<FunctionDecl>(GD.getDecl()))

      L = getFunctionLinkage(GD);

    else if (auto *VD = llvm::dyn_cast<VarDecl>(GD.getDecl()))

      L = getLLVMLinkageVarDefinition(VD);

    if (llvm::GlobalValue::isInternalLinkage(L) ||

        llvm::GlobalValue::isLinkOnceLinkage(L) ||

        llvm::GlobalValue::isWeakLinkage(L)) {

      EmittedDeferredDecls[getMangledName(GD)] = GD;

    }

  }

  /// List of alias we have emitted. Used to make sure that what they point to

  /// is defined once we get to the end of the of the translation unit.

  std::vector<GlobalDecl> Aliases;

  /// List of multiversion functions to be emitted. This list is processed in

  /// conjunction with other deferred symbols and is used to ensure that

  /// multiversion function resolvers and ifuncs are defined and emitted.

  std::vector<GlobalDecl> MultiVersionFuncs;

  llvm::MapVector<StringRef, llvm::TrackingVH<llvm::Constant>> Replacements;

  /// List of global values to be replaced with something else. Used when we

  /// want to replace a GlobalValue but can't identify it by its mangled name

  /// anymore (because the name is already taken).

  llvm::SmallVector<std::pair<llvm::GlobalValue *, llvm::Constant *>, 8>

    GlobalValReplacements;

  /// Variables for which we've emitted globals containing their constant

  /// values along with the corresponding globals, for opportunistic reuse.

  llvm::DenseMap<const VarDecl*, llvm::GlobalVariable*> InitializerConstants;

  /// Set of global decls for which we already diagnosed mangled name conflict.

  /// Required to not issue a warning (on a mangling conflict) multiple times

  /// for the same decl.

  llvm::DenseSet<GlobalDecl> DiagnosedConflictingDefinitions;

  /// A queue of (optional) vtables to consider emitting.

  std::vector<const CXXRecordDecl*> DeferredVTables;

  /// A queue of (optional) vtables that may be emitted opportunistically.

  std::vector<const CXXRecordDecl *> OpportunisticVTables;

  /// List of global values which are required to be present in the object file;

  /// bitcast to i8*. This is used for forcing visibility of symbols which may

  /// otherwise be optimized out.

  std::vector<llvm::WeakTrackingVH> LLVMUsed;

  std::vector<llvm::WeakTrackingVH> LLVMCompilerUsed;

  /// Store the list of global constructors and their respective priorities to

  /// be emitted when the translation unit is complete.

  CtorList GlobalCtors;

  /// Store the list of global destructors and their respective priorities to be

  /// emitted when the translation unit is complete.

  CtorList GlobalDtors;

  /// An ordered map of canonical GlobalDecls to their mangled names.

  llvm::MapVector<GlobalDecl, StringRef> MangledDeclNames;

  llvm::StringMap<GlobalDecl, llvm::BumpPtrAllocator> Manglings;

  /// Global annotations.

  std::vector<llvm::Constant*> Annotations;

  // Store deferred function annotations so they can be emitted at the end with

  // most up to date ValueDecl that will have all the inherited annotations.

  llvm::DenseMap<StringRef, const ValueDecl *> DeferredAnnotations;

  /// Map used to get unique annotation strings.

  llvm::StringMap<llvm::Constant*> AnnotationStrings;

  /// Used for uniquing of annotation arguments.

  llvm::DenseMap<unsigned, llvm::Constant *> AnnotationArgs;

  llvm::StringMap<llvm::GlobalVariable *> CFConstantStringMap;

  llvm::DenseMap<llvm::Constant *, llvm::GlobalVariable *> ConstantStringMap;

  llvm::DenseMap<const UnnamedGlobalConstantDecl *, llvm::GlobalVariable *>

      UnnamedGlobalConstantDeclMap;

  llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap;

  llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap;

  llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap;

  llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap;

  llvm::DenseMap<QualType, llvm::Constant *> AtomicGetterHelperFnMap;

  /// Map used to get unique type descriptor constants for sanitizers.

  llvm::DenseMap<QualType, llvm::Constant *> TypeDescriptorMap;

  /// Map used to track internal linkage functions declared within

  /// extern "C" regions.

  typedef llvm::MapVector<IdentifierInfo *,

                          llvm::GlobalValue *> StaticExternCMap;

  StaticExternCMap StaticExternCValues;

  /// thread_local variables defined or used in this TU.

  std::vector<const VarDecl *> CXXThreadLocals;

  /// thread_local variables with initializers that need to run

  /// before any thread_local variable in this TU is odr-used.

  std::vector<llvm::Function *> CXXThreadLocalInits;

  std::vector<const VarDecl *> CXXThreadLocalInitVars;

  /// Global variables with initializers that need to run before main.

  std::vector<llvm::Function *> CXXGlobalInits;

  /// When a C++ decl with an initializer is deferred, null is

  /// appended to CXXGlobalInits, and the index of that null is placed

  /// here so that the initializer will be performed in the correct

  /// order. Once the decl is emitted, the index is replaced with ~0U to ensure

  /// that we don't re-emit the initializer.

  llvm::DenseMap<const Decl*, unsigned> DelayedCXXInitPosition;

  typedef std::pair<OrderGlobalInitsOrStermFinalizers, llvm::Function *>

      GlobalInitData;

  struct GlobalInitPriorityCmp {

    bool operator()(const GlobalInitData &LHS,

                    const GlobalInitData &RHS) const {

      return LHS.first.priority < RHS.first.priority;

    }

  };

  /// Global variables with initializers whose order of initialization is set by

  /// init_priority attribute.

  SmallVector<GlobalInitData, 8> PrioritizedCXXGlobalInits;

  /// Global destructor functions and arguments that need to run on termination.

  /// When UseSinitAndSterm is set, it instead contains sterm finalizer

  /// functions, which also run on unloading a shared library.

  typedef std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,

                     llvm::Constant *>

      CXXGlobalDtorsOrStermFinalizer_t;

  SmallVector<CXXGlobalDtorsOrStermFinalizer_t, 8>

      CXXGlobalDtorsOrStermFinalizers;

  typedef std::pair<OrderGlobalInitsOrStermFinalizers, llvm::Function *>

      StermFinalizerData;

  struct StermFinalizerPriorityCmp {

    bool operator()(const StermFinalizerData &LHS,

                    const StermFinalizerData &RHS) const {

      return LHS.first.priority < RHS.first.priority;

    }

  };

  /// Global variables with sterm finalizers whose order of initialization is

  /// set by init_priority attribute.

  SmallVector<StermFinalizerData, 8> PrioritizedCXXStermFinalizers;

  /// The complete set of modules that has been imported.

  llvm::SetVector<clang::Module *> ImportedModules;

  /// The set of modules for which the module initializers

  /// have been emitted.

  llvm::SmallPtrSet<clang::Module *, 16> EmittedModuleInitializers;

  /// A vector of metadata strings for linker options.

  SmallVector<llvm::MDNode *, 16> LinkerOptionsMetadata;

  /// A vector of metadata strings for dependent libraries for ELF.

  SmallVector<llvm::MDNode *, 16> ELFDependentLibraries;

  /// @name Cache for Objective-C runtime types

  /// @{

  /// Cached reference to the class for constant strings. This value has type

  /// int * but is actually an Obj-C class pointer.

  llvm::WeakTrackingVH CFConstantStringClassRef;

  /// The type used to describe the state of a fast enumeration in

  /// Objective-C's for..in loop.

  QualType ObjCFastEnumerationStateType;

  /// @}

  /// Lazily create the Objective-C runtime

  void createObjCRuntime();

  void createOpenCLRuntime();

  void createOpenMPRuntime();

  void createCUDARuntime();

  void createHLSLRuntime();

  bool isTriviallyRecursive(const FunctionDecl *F);

  bool shouldEmitFunction(GlobalDecl GD);

  bool shouldOpportunisticallyEmitVTables();

  /// Map used to be sure we don't emit the same CompoundLiteral twice.

  llvm::DenseMap<const CompoundLiteralExpr *, llvm::GlobalVariable *>

      EmittedCompoundLiterals;

  /// Map of the global blocks we've emitted, so that we don't have to re-emit

  /// them if the constexpr evaluator gets aggressive.

  llvm::DenseMap<const BlockExpr *, llvm::Constant *> EmittedGlobalBlocks;

  /// @name Cache for Blocks Runtime Globals

  /// @{

  llvm::Constant *NSConcreteGlobalBlock = nullptr;

  llvm::Constant *NSConcreteStackBlock = nullptr;

  llvm::FunctionCallee BlockObjectAssign = nullptr;

  llvm::FunctionCallee BlockObjectDispose = nullptr;

  llvm::Type *BlockDescriptorType = nullptr;

  llvm::Type *GenericBlockLiteralType = nullptr;

  struct {

    int GlobalUniqueCount;

  } Block;

  GlobalDecl initializedGlobalDecl;

  /// @}

  /// void @llvm.lifetime.start(i64 %size, i8* nocapture <ptr>)

  llvm::Function *LifetimeStartFn = nullptr;

  /// void @llvm.lifetime.end(i64 %size, i8* nocapture <ptr>)

  llvm::Function *LifetimeEndFn = nullptr;

  std::unique_ptr<SanitizerMetadata> SanitizerMD;

  llvm::MapVector<const Decl *, bool> DeferredEmptyCoverageMappingDecls;

  std::unique_ptr<CoverageMappingModuleGen> CoverageMapping;

  /// Mapping from canonical types to their metadata identifiers. We need to

  /// maintain this mapping because identifiers may be formed from distinct

  /// MDNodes.

  typedef llvm::DenseMap<QualType, llvm::Metadata *> MetadataTypeMap;

  MetadataTypeMap MetadataIdMap;

  MetadataTypeMap VirtualMetadataIdMap;

  MetadataTypeMap GeneralizedMetadataIdMap;

  // Helps squashing blocks of TopLevelStmtDecl into a single llvm::Function

  // when used with -fincremental-extensions.

  std::pair<std::unique_ptr<CodeGenFunction>, const TopLevelStmtDecl *>

      GlobalTopLevelStmtBlockInFlight;

public:

  CodeGenModule(ASTContext &C, IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,

                const HeaderSearchOptions &headersearchopts,

                const PreprocessorOptions &ppopts,

                const CodeGenOptions &CodeGenOpts, llvm::Module &M,

                DiagnosticsEngine &Diags,

                CoverageSourceInfo *CoverageInfo = nullptr);

  ~CodeGenModule();

  void clear();

  /// Finalize LLVM code generation.

  void Release();

  /// Return true if we should emit location information for expressions.

  bool getExpressionLocationsEnabled() const;

  /// Return a reference to the configured Objective-C runtime.

  CGObjCRuntime &getObjCRuntime() {

    if (!ObjCRuntime) createObjCRuntime();

    return *ObjCRuntime;

  }

  /// Return true iff an Objective-C runtime has been configured.

  bool hasObjCRuntime() { return !!ObjCRuntime; }

  const std::string &getModuleNameHash() const { return ModuleNameHash; }

  /// Return a reference to the configured OpenCL runtime.

  CGOpenCLRuntime &getOpenCLRuntime() {

    assert(OpenCLRuntime != nullptr);

    return *OpenCLRuntime;

  }

  /// Return a reference to the configured OpenMP runtime.

  CGOpenMPRuntime &getOpenMPRuntime() {

    assert(OpenMPRuntime != nullptr);

    return *OpenMPRuntime;

  }

  /// Return a reference to the configured CUDA runtime.

  CGCUDARuntime &getCUDARuntime() {

    assert(CUDARuntime != nullptr);

    return *CUDARuntime;

  }

  /// Return a reference to the configured HLSL runtime.

  CGHLSLRuntime &getHLSLRuntime() {

    assert(HLSLRuntime != nullptr);

    return *HLSLRuntime;

  }

  ObjCEntrypoints &getObjCEntrypoints() const {

    assert(ObjCData != nullptr);

    return *ObjCData;

  }

  // Version checking functions, used to implement ObjC's @available:

  // i32 @__isOSVersionAtLeast(i32, i32, i32)

  llvm::FunctionCallee IsOSVersionAtLeastFn = nullptr;

  // i32 @__isPlatformVersionAtLeast(i32, i32, i32, i32)

  llvm::FunctionCallee IsPlatformVersionAtLeastFn = nullptr;

  InstrProfStats &getPGOStats() { return PGOStats; }

  llvm::IndexedInstrProfReader *getPGOReader() const { return PGOReader.get(); }

  CoverageMappingModuleGen *getCoverageMapping() const {

    return CoverageMapping.get();

  }

  llvm::Constant *getStaticLocalDeclAddress(const VarDecl *D) {

    return StaticLocalDeclMap[D];

  }

  void setStaticLocalDeclAddress(const VarDecl *D,

                                 llvm::Constant *C) {

    StaticLocalDeclMap[D] = C;

  }

  llvm::Constant *

  getOrCreateStaticVarDecl(const VarDecl &D,

                           llvm::GlobalValue::LinkageTypes Linkage);

  llvm::GlobalVariable *getStaticLocalDeclGuardAddress(const VarDecl *D) {

    return StaticLocalDeclGuardMap[D];

  }

  void setStaticLocalDeclGuardAddress(const VarDecl *D,

                                      llvm::GlobalVariable *C) {

    StaticLocalDeclGuardMap[D] = C;

  }

  Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant,

                                  CharUnits Align);

  bool lookupRepresentativeDecl(StringRef MangledName,

                                GlobalDecl &Result) const;

  llvm::Constant *getAtomicSetterHelperFnMap(QualType Ty) {

    return AtomicSetterHelperFnMap[Ty];

  }

  void setAtomicSetterHelperFnMap(QualType Ty,

                            llvm::Constant *Fn) {

    AtomicSetterHelperFnMap[Ty] = Fn;

  }

  llvm::Constant *getAtomicGetterHelperFnMap(QualType Ty) {

    return AtomicGetterHelperFnMap[Ty];

  }

  void setAtomicGetterHelperFnMap(QualType Ty,

                            llvm::Constant *Fn) {

    AtomicGetterHelperFnMap[Ty] = Fn;

  }

  llvm::Constant *getTypeDescriptorFromMap(QualType Ty) {

    return TypeDescriptorMap[Ty];

  }

  void setTypeDescriptorInMap(QualType Ty, llvm::Constant *C) {

    TypeDescriptorMap[Ty] = C;

  }

  CGDebugInfo *getModuleDebugInfo() { return DebugInfo.get(); }

  llvm::MDNode *getNoObjCARCExceptionsMetadata() {

    if (!NoObjCARCExceptionsMetadata)

      NoObjCARCExceptionsMetadata =

          llvm::MDNode::get(getLLVMContext(), std::nullopt);

    return NoObjCARCExceptionsMetadata;

  }

  ASTContext &getContext() const { return Context; }

  const LangOptions &getLangOpts() const { return LangOpts; }

  const IntrusiveRefCntPtr<llvm::vfs::FileSystem> &getFileSystem() const {

    return FS;

  }

  const HeaderSearchOptions &getHeaderSearchOpts()

    const { return HeaderSearchOpts; }

  const PreprocessorOptions &getPreprocessorOpts()

    const { return PreprocessorOpts; }

  const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }

  llvm::Module &getModule() const { return TheModule; }

  DiagnosticsEngine &getDiags() const { return Diags; }

  const llvm::DataLayout &getDataLayout() const {

    return TheModule.getDataLayout();

  }

  const TargetInfo &getTarget() const { return Target; }

  const llvm::Triple &getTriple() const { return Target.getTriple(); }

  bool supportsCOMDAT() const;

  void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO);

  CGCXXABI &getCXXABI() const { return *ABI; }

  llvm::LLVMContext &getLLVMContext() { return VMContext; }

  bool shouldUseTBAA() const { return TBAA != nullptr; }

  const TargetCodeGenInfo &getTargetCodeGenInfo();

  CodeGenTypes &getTypes() { return Types; }

  CodeGenVTables &getVTables() { return VTables; }

  ItaniumVTableContext &getItaniumVTableContext() {

    return VTables.getItaniumVTableContext();

  }

  const ItaniumVTableContext &getItaniumVTableContext() const {

    return VTables.getItaniumVTableContext();

  }

  MicrosoftVTableContext &getMicrosoftVTableContext() {

    return VTables.getMicrosoftVTableContext();

  }

  CtorList &getGlobalCtors() { return GlobalCtors; }

  CtorList &getGlobalDtors() { return GlobalDtors; }

  /// getTBAATypeInfo - Get metadata used to describe accesses to objects of

  /// the given type.

  llvm::MDNode *getTBAATypeInfo(QualType QTy);

  /// getTBAAAccessInfo - Get TBAA information that describes an access to

  /// an object of the given type.

  TBAAAccessInfo getTBAAAccessInfo(QualType AccessType);

  /// getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an

  /// access to a virtual table pointer.

  TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType);

  llvm::MDNode *getTBAAStructInfo(QualType QTy);

  /// getTBAABaseTypeInfo - Get metadata that describes the given base access

  /// type. Return null if the type is not suitable for use in TBAA access tags.

  llvm::MDNode *getTBAABaseTypeInfo(QualType QTy);

  /// getTBAAAccessTagInfo - Get TBAA tag for a given memory access.

  llvm::MDNode *getTBAAAccessTagInfo(TBAAAccessInfo Info);

  /// mergeTBAAInfoForCast - Get merged TBAA information for the purposes of

  /// type casts.

  TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo,

                                      TBAAAccessInfo TargetInfo);

  /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the

  /// purposes of conditional operator.

  TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA,

                                                     TBAAAccessInfo InfoB);

  /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the

  /// purposes of memory transfer calls.

  TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo,

                                                TBAAAccessInfo SrcInfo);

  /// getTBAAInfoForSubobject - Get TBAA information for an access with a given

  /// base lvalue.

  TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType) {

    if (Base.getTBAAInfo().isMayAlias())

      return TBAAAccessInfo::getMayAliasInfo();

    return getTBAAAccessInfo(AccessType);

  }

  bool isPaddedAtomicType(QualType type);

  bool isPaddedAtomicType(const AtomicType *type);

  /// DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.

  void DecorateInstructionWithTBAA(llvm::Instruction *Inst,

                                   TBAAAccessInfo TBAAInfo);

  /// Adds !invariant.barrier !tag to instruction

  void DecorateInstructionWithInvariantGroup(llvm::Instruction *I,

                                             const CXXRecordDecl *RD);

  /// Emit the given number of characters as a value of type size_t.

  llvm::ConstantInt *getSize(CharUnits numChars);

  /// Set the visibility for the given LLVM GlobalValue.

  void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const;

  void setDSOLocal(llvm::GlobalValue *GV) const;

  bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const {

    return getLangOpts().hasDefaultVisibilityExportMapping() && D &&

           (D->getLinkageAndVisibility().getVisibility() ==

            DefaultVisibility) &&

           (getLangOpts().isAllDefaultVisibilityExportMapping() ||

            (getLangOpts().isExplicitDefaultVisibilityExportMapping() &&

             D->getLinkageAndVisibility().isVisibilityExplicit()));

  }

  void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const;

  void setDLLImportDLLExport(llvm::GlobalValue *GV, const NamedDecl *D) const;

  /// Set visibility, dllimport/dllexport and dso_local.

  /// This must be called after dllimport/dllexport is set.

  void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const;

  void setGVProperties(llvm::GlobalValue *GV, const NamedDecl *D) const;

  void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const;

  /// Set the TLS mode for the given LLVM GlobalValue for the thread-local

  /// variable declaration D.

  void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const;

  /// Get LLVM TLS mode from CodeGenOptions.

  llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const;

  static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V) {

    switch (V) {

    case DefaultVisibility:   return llvm::GlobalValue::DefaultVisibility;

    case HiddenVisibility:    return llvm::GlobalValue::HiddenVisibility;

    case ProtectedVisibility: return llvm::GlobalValue::ProtectedVisibility;

    }

    llvm_unreachable("unknown visibility!");

  }

  llvm::Constant *GetAddrOfGlobal(GlobalDecl GD,

                                  ForDefinition_t IsForDefinition

                                    = NotForDefinition);

  /// Will return a global variable of the given type. If a variable with a

  /// different type already exists then a new  variable with the right type

  /// will be created and all uses of the old variable will be replaced with a

  /// bitcast to the new variable.

  llvm::GlobalVariable *

  CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty,

                                    llvm::GlobalValue::LinkageTypes Linkage,

                                    llvm::Align Alignment);

  llvm::Function *CreateGlobalInitOrCleanUpFunction(

      llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI,

      SourceLocation Loc = SourceLocation(), bool TLS = false,

      llvm::GlobalVariable::LinkageTypes Linkage =

          llvm::GlobalVariable::InternalLinkage);

  /// Return the AST address space of the underlying global variable for D, as

  /// determined by its declaration. Normally this is the same as the address

  /// space of D's type, but in CUDA, address spaces are associated with

  /// declarations, not types. If D is nullptr, return the default address

  /// space for global variable.

  ///

  /// For languages without explicit address spaces, if D has default address

  /// space, target-specific global or constant address space may be returned.

  LangAS GetGlobalVarAddressSpace(const VarDecl *D);

  /// Return the AST address space of constant literal, which is used to emit

  /// the constant literal as global variable in LLVM IR.

  /// Note: This is not necessarily the address space of the constant literal

  /// in AST. For address space agnostic language, e.g. C++, constant literal

  /// in AST is always in default address space.

  LangAS GetGlobalConstantAddressSpace() const;

  /// Return the llvm::Constant for the address of the given global variable.

  /// If Ty is non-null and if the global doesn't exist, then it will be created

  /// with the specified type instead of whatever the normal requested type

  /// would be. If IsForDefinition is true, it is guaranteed that an actual

  /// global with type Ty will be returned, not conversion of a variable with

  /// the same mangled name but some other type.

  llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,

                                     llvm::Type *Ty = nullptr,

                                     ForDefinition_t IsForDefinition

                                       = NotForDefinition);

  /// Return the address of the given function. If Ty is non-null, then this

  /// function will use the specified type if it has to create it.

  llvm::Constant *GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty = nullptr,

                                    bool ForVTable = false,

                                    bool DontDefer = false,

                                    ForDefinition_t IsForDefinition

                                      = NotForDefinition);

  // Return the function body address of the given function.

  llvm::Constant *GetFunctionStart(const ValueDecl *Decl);

  // Return whether RTTI information should be emitted for this target.

  bool shouldEmitRTTI(bool ForEH = false) {

    return (ForEH || getLangOpts().RTTI) && !getLangOpts().CUDAIsDevice &&

           !(getLangOpts().OpenMP && getLangOpts().OpenMPIsTargetDevice &&

             getTriple().isNVPTX());

  }

  /// Get the address of the RTTI descriptor for the given type.

  llvm::Constant *GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH = false);

  /// Get the address of a GUID.

  ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD);

  /// Get the address of a UnnamedGlobalConstant

  ConstantAddress

  GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD);

  /// Get the address of a template parameter object.

  ConstantAddress

  GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO);

  /// Get the address of the thunk for the given global decl.

  llvm::Constant *GetAddrOfThunk(StringRef Name, llvm::Type *FnTy,

                                 GlobalDecl GD);

  /// Get a reference to the target of VD.

  ConstantAddress GetWeakRefReference(const ValueDecl *VD);

  /// Returns the assumed alignment of an opaque pointer to the given class.

  CharUnits getClassPointerAlignment(const CXXRecordDecl *CD);

  /// Returns the minimum object size for an object of the given class type

  /// (or a class derived from it).

  CharUnits getMinimumClassObjectSize(const CXXRecordDecl *CD);

  /// Returns the minimum object size for an object of the given type.

  CharUnits getMinimumObjectSize(QualType Ty) {

    if (CXXRecordDecl *RD = Ty->getAsCXXRecordDecl())

      return getMinimumClassObjectSize(RD);

    return getContext().getTypeSizeInChars(Ty);

  }

  /// Returns the assumed alignment of a virtual base of a class.

  CharUnits getVBaseAlignment(CharUnits DerivedAlign,

                              const CXXRecordDecl *Derived,

                              const CXXRecordDecl *VBase);

  /// Given a class pointer with an actual known alignment, and the

  /// expected alignment of an object at a dynamic offset w.r.t that

  /// pointer, return the alignment to assume at the offset.

  CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign,

                                      const CXXRecordDecl *Class,

                                      CharUnits ExpectedTargetAlign);

  CharUnits

  computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass,

                                   CastExpr::path_const_iterator Start,

                                   CastExpr::path_const_iterator End);

  /// Returns the offset from a derived class to  a class. Returns null if the

  /// offset is 0.

  llvm::Constant *

  GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,

                               CastExpr::path_const_iterator PathBegin,

                               CastExpr::path_const_iterator PathEnd);

  llvm::FoldingSet<BlockByrefHelpers> ByrefHelpersCache;

  /// Fetches the global unique block count.

  int getUniqueBlockCount() { return ++Block.GlobalUniqueCount; }

  /// Fetches the type of a generic block descriptor.

  llvm::Type *getBlockDescriptorType();

  /// The type of a generic block literal.

  llvm::Type *getGenericBlockLiteralType();

  /// Gets the address of a block which requires no captures.

  llvm::Constant *GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name);

  /// Returns the address of a block which requires no caputres, or null if

  /// we've yet to emit the block for BE.

  llvm::Constant *getAddrOfGlobalBlockIfEmitted(const BlockExpr *BE) {

    return EmittedGlobalBlocks.lookup(BE);

  }

  /// Notes that BE's global block is available via Addr. Asserts that BE

  /// isn't already emitted.

  void setAddrOfGlobalBlock(const BlockExpr *BE, llvm::Constant *Addr);

  /// Return a pointer to a constant CFString object for the given string.

  ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal);

  /// Return a constant array for the given string.

  llvm::Constant *GetConstantArrayFromStringLiteral(const StringLiteral *E);

  /// Return a pointer to a constant array for the given string literal.

  ConstantAddress

  GetAddrOfConstantStringFromLiteral(const StringLiteral *S,

                                     StringRef Name = ".str");

  /// Return a pointer to a constant array for the given ObjCEncodeExpr node.

  ConstantAddress

  GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *);

  /// Returns a pointer to a character array containing the literal and a

  /// terminating '\0' character. The result has pointer to array type.

  ///

  /// \param GlobalName If provided, the name to use for the global (if one is

  /// created).

  ConstantAddress

  GetAddrOfConstantCString(const std::string &Str,

                           const char *GlobalName = nullptr);

  /// Returns a pointer to a constant global variable for the given file-scope

  /// compound literal expression.

  ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr*E);

  /// If it's been emitted already, returns the GlobalVariable corresponding to

  /// a compound literal. Otherwise, returns null.

  llvm::GlobalVariable *

  getAddrOfConstantCompoundLiteralIfEmitted(const CompoundLiteralExpr *E);

  /// Notes that CLE's GlobalVariable is GV. Asserts that CLE isn't already

  /// emitted.

  void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE,

                                        llvm::GlobalVariable *GV);

  /// Returns a pointer to a global variable representing a temporary

  /// with static or thread storage duration.

  ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E,

                                           const Expr *Inner);

  /// Retrieve the record type that describes the state of an

  /// Objective-C fast enumeration loop (for..in).

  QualType getObjCFastEnumerationStateType();

  // Produce code for this constructor/destructor. This method doesn't try