1 //===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- C++ -*-===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This is the internal per-translation-unit state used for llvm translation.
11 //===----------------------------------------------------------------------===//
43 class Module;
44 class Constant;
45 class ConstantInt;
46 class Function;
47 class GlobalValue;
48 class DataLayout;
49 class FunctionType;
50 class LLVMContext;
51 class IndexedInstrProfReader;
54 class FileSystem;
59 class ASTContext;
60 class AtomicType;
61 class FunctionDecl;
62 class IdentifierInfo;
63 class ObjCImplementationDecl;
64 class ObjCEncodeExpr;
65 class BlockExpr;
66 class CharUnits;
67 class Decl;
68 class Expr;
69 class Stmt;
70 class StringLiteral;
71 class NamedDecl;
72 class PointerAuthSchema;
73 class ValueDecl;
74 class VarDecl;
75 class LangOptions;
76 class CodeGenOptions;
77 class HeaderSearchOptions;
78 class DiagnosticsEngine;
79 class AnnotateAttr;
80 class CXXDestructorDecl;
81 class Module;
82 class CoverageSourceInfo;
83 class InitSegAttr;
87 class CodeGenFunction;
88 class CodeGenTBAA;
89 class CGCXXABI;
90 class CGDebugInfo;
91 class CGObjCRuntime;
92 class CGOpenCLRuntime;
93 class CGOpenMPRuntime;
94 class CGCUDARuntime;
95 class CGHLSLRuntime;
96 class CoverageMappingModuleGen;
97 class TargetCodeGenInfo;
216 /// This class records statistics on instrumentation based profiling.
217 class InstrProfStats {
248 class BlockByrefHelpers : public llvm::FoldingSetNode {
278 /// This class organizes the cross-function state that is used while generating
280 class CodeGenModule : public CodeGenTypeCache {
471   /// before any thread_local variable in this TU is odr-used.
482   /// that we don't re-emit the initializer.
543   /// @name Cache for Objective-C runtime types
546   /// Cached reference to the class for constant strings. This value has type
547   /// int * but is actually an Obj-C class pointer.
551   /// Objective-C's for..in loop.
556   /// Lazily create the Objective-C runtime
574   /// Map of the global blocks we've emitted, so that we don't have to re-emit
619   // when used with -fincremental-extensions.
648   /// Return a reference to the configured Objective-C runtime.
654   /// Return true iff an Objective-C runtime has been configured.
701   llvm::Constant *getStaticLocalDeclAddress(const VarDecl *D) {  in getStaticLocalDeclAddress()  argument
702     return StaticLocalDeclMap[D];  in getStaticLocalDeclAddress()
704   void setStaticLocalDeclAddress(const VarDecl *D,  in setStaticLocalDeclAddress()  argument
706     StaticLocalDeclMap[D] = C;  in setStaticLocalDeclAddress()
710   getOrCreateStaticVarDecl(const VarDecl &D,
713   llvm::GlobalVariable *getStaticLocalDeclGuardAddress(const VarDecl *D) {  in getStaticLocalDeclGuardAddress()  argument
714     return StaticLocalDeclGuardMap[D];  in getStaticLocalDeclGuardAddress()
716   void setStaticLocalDeclGuardAddress(const VarDecl *D,  in setStaticLocalDeclGuardAddress()  argument
718     StaticLocalDeclGuardMap[D] = C;  in setStaticLocalDeclGuardAddress()
721   Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant,
777   void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO);
806   /// getTBAATypeInfo - Get metadata used to describe accesses to objects of
810   /// getTBAAAccessInfo - Get TBAA information that describes an access to
814   /// getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an
820   /// getTBAABaseTypeInfo - Get metadata that describes the given base access
824   /// getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
827   /// mergeTBAAInfoForCast - Get merged TBAA information for the purposes of
832   /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the
837   /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the
842   /// getTBAAInfoForSubobject - Get TBAA information for an access with a given
853   /// DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.
865   void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const;
869   bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const {  in shouldMapVisibilityToDLLExport()  argument
870     return getLangOpts().hasDefaultVisibilityExportMapping() && D &&  in shouldMapVisibilityToDLLExport()
871            (D->getLinkageAndVisibility().getVisibility() ==  in shouldMapVisibilityToDLLExport()
875              D->getLinkageAndVisibility().isVisibilityExplicit()));  in shouldMapVisibilityToDLLExport()
877   void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const;
878   void setDLLImportDLLExport(llvm::GlobalValue *GV, const NamedDecl *D) const;
882   void setGVProperties(llvm::GlobalValue *GV, const NamedDecl *D) const;
884   void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const;
886   /// Set the TLS mode for the given LLVM GlobalValue for the thread-local
887   /// variable declaration D.
888   void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const;
921   /// Return the AST address space of the underlying global variable for D, as
923   /// space of D's type, but in CUDA, address spaces are associated with
924   /// declarations, not types. If D is nullptr, return the default address
927   /// For languages without explicit address spaces, if D has default address
928   /// space, target-specific global or constant address space may be returned.
929   LangAS GetGlobalVarAddressSpace(const VarDecl *D);
939   /// If Ty is non-null and if the global doesn't exist, then it will be created
944   llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,
949   /// Return the address of the given function. If Ty is non-null, then this
966   /// Return the ABI-correct function pointer value for a reference
971   /// Return the ABI-correct function pointer value for a reference
1046   /// Returns the assumed alignment of an opaque pointer to the given class.
1049   /// Returns the minimum object size for an object of the given class type
1050   /// (or a class derived from it).
1055     if (CXXRecordDecl *RD = Ty->getAsCXXRecordDecl())  in getMinimumObjectSize()
1060   /// Returns the assumed alignment of a virtual base of a class.
1065   /// Given a class pointer with an actual known alignment, and the
1069                                       const CXXRecordDecl *Class,
1077   /// Returns the offset from a derived class to  a class. Returns null if the
1132   /// Returns a pointer to a constant global variable for the given file-scope
1152   /// Objective-C fast enumeration loop (for..in).
1186   void EmitTopLevelDecl(Decl *D);
1190   void AddDeferredUnusedCoverageMapping(Decl *D);
1194   void ClearUnusedCoverageMapping(const Decl *D);
1210   void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV);
1282   /// Return the result of value-initializing the given type, i.e. a null
1287   /// Return a null constant appropriate for zero-initializing a base class with
1298   void ErrorUnsupported(const Decl *D, const char *Type);
1312   void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F);
1316   void setLLVMFunctionFEnvAttributes(const FunctionDecl *D, llvm::Function *F);
1337   /// \param Name - The function name.
1338   /// \param Info - The function type information.
1339   /// \param CalleeInfo - The callee information these attributes are being
1342   /// \param Attrs [out] - On return, the attribute list to use.
1343   /// \param CallingConv [out] - On return, the LLVM calling convention to use.
1356   /// for frontends that want to build on Clang's target-configuration logic.
1363   void EmitTentativeDefinition(const VarDecl *D);
1365   void EmitExternalDeclaration(const DeclaratorDecl *D);
1367   void EmitVTable(CXXRecordDecl *Class);
1369   void RefreshTypeCacheForClass(const CXXRecordDecl *Class);
1384     F->setLinkage(getFunctionLinkage(GD));  in setFunctionLinkage()
1388   /// of the given class.
1396   getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage);
1428   /// Add global annotations that are set on D, for the global GV. Those
1430   void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV);
1446   /// instrumentation by the SCL passed by \p -fprofile-list.
1466   void EmitGlobal(GlobalDecl D);
1468   bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);
1473   /// Objective-C method, function, global variable).
1483   /// \param D Threadprivate declaration.
1484   void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);
1487   void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D,
1491   void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D,
1495   /// \param D Requires declaration
1496   void EmitOMPRequiresDecl(const OMPRequiresDecl *D);
1499   /// \param D The allocate declaration
1500   void EmitOMPAllocateDecl(const OMPAllocateDecl *D);
1506   /// may participate in (single-module) CFI and whole-program vtable
1511   /// -lto-whole-program-visibility) and therefore may not participate in
1512   /// (single-module) CFI and whole-program vtable optimization.
1517   /// member function of this class. This scope can be wider than the visibility
1518   /// of the class itself when the class has a more-visible dynamic base class.
1532   /// Generate a cross-DSO type identifier for MD.
1567   /// Returns whether this module needs the "all-vtables" type identifier.
1574   /// Return a vector of most-base classes for RD. This is used to implement
1577   /// A most-base class of a class C is defined as a recursive base class of C,
1596   /// otherwise all parameters must have valid non-null values.
1622   /// does not define separate macros via the -cc1 options.
1624                                        const Decl *D) const;
1626   /// Move some lazily-emitted states to the NewBuilder. This is especially
1640   /// Emit the IR encoding to attach the AMD GPU flat-work-group-size attribute
1650   /// Emit the IR encoding to attach the AMD GPU waves-per-eu attribute to \p F.
1656                         const VarDecl *D,
1680   bool shouldDropDLLAttribute(const Decl *D, const llvm::GlobalValue *GV) const;
1683       StringRef MangledName, llvm::Type *Ty, GlobalDecl D, bool ForVTable,
1715   void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue *GV = nullptr);
1720   void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false);
1721   void EmitExternalVarDeclaration(const VarDecl *D);
1722   void EmitExternalFunctionDeclaration(const FunctionDecl *D);
1726   void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
1727   void EmitObjCIvarInitializations(ObjCImplementationDecl *D);
1732   void EmitLinkageSpec(const LinkageSpecDecl *D);
1733   void EmitTopLevelStmt(const TopLevelStmtDecl *D);
1749   void EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
1756   /// EmitCtorList - Generates a global array of functions and priorities using
1818   /// Emit aliases for internal-linkage declarations inside "C" language
1843   bool MustBeEmitted(const ValueDecl *D);
1849   bool MayBeEmittedEagerly(const ValueDecl *D);