2051 lines · c
1//===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- 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-exception6//7//===----------------------------------------------------------------------===//8//9// This is the internal per-translation-unit state used for llvm translation.10//11//===----------------------------------------------------------------------===//12 13#ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H14#define LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H15 16#include "CGVTables.h"17#include "CodeGenTypeCache.h"18#include "CodeGenTypes.h"19#include "SanitizerMetadata.h"20#include "TrapReasonBuilder.h"21#include "clang/AST/DeclCXX.h"22#include "clang/AST/DeclObjC.h"23#include "clang/AST/DeclOpenMP.h"24#include "clang/AST/GlobalDecl.h"25#include "clang/AST/Mangle.h"26#include "clang/Basic/ABI.h"27#include "clang/Basic/LangOptions.h"28#include "clang/Basic/NoSanitizeList.h"29#include "clang/Basic/ProfileList.h"30#include "clang/Basic/StackExhaustionHandler.h"31#include "clang/Basic/TargetInfo.h"32#include "clang/Basic/XRayLists.h"33#include "clang/Lex/PreprocessorOptions.h"34#include "llvm/ADT/DenseMap.h"35#include "llvm/ADT/MapVector.h"36#include "llvm/ADT/SetVector.h"37#include "llvm/ADT/SmallPtrSet.h"38#include "llvm/ADT/StringMap.h"39#include "llvm/IR/Module.h"40#include "llvm/IR/ValueHandle.h"41#include "llvm/Transforms/Utils/SanitizerStats.h"42#include <optional>43 44namespace llvm {45class Module;46class Constant;47class ConstantInt;48class Function;49class GlobalValue;50class DataLayout;51class FunctionType;52class LLVMContext;53class IndexedInstrProfReader;54 55namespace vfs {56class FileSystem;57}58}59 60namespace clang {61class ASTContext;62class AtomicType;63class FunctionDecl;64class IdentifierInfo;65class ObjCImplementationDecl;66class ObjCEncodeExpr;67class BlockExpr;68class CharUnits;69class Decl;70class Expr;71class Stmt;72class StringLiteral;73class NamedDecl;74class PointerAuthSchema;75class ValueDecl;76class VarDecl;77class LangOptions;78class CodeGenOptions;79class HeaderSearchOptions;80class DiagnosticsEngine;81class AnnotateAttr;82class CXXDestructorDecl;83class Module;84class CoverageSourceInfo;85class InitSegAttr;86 87namespace CodeGen {88 89class CodeGenFunction;90class CodeGenTBAA;91class CGCXXABI;92class CGDebugInfo;93class CGObjCRuntime;94class CGOpenCLRuntime;95class CGOpenMPRuntime;96class CGCUDARuntime;97class CGHLSLRuntime;98class CoverageMappingModuleGen;99class TargetCodeGenInfo;100 101enum ForDefinition_t : bool {102 NotForDefinition = false,103 ForDefinition = true104};105 106/// The Counter with an optional additional Counter for107/// branches. `Skipped` counter can be calculated with `Executed` and108/// a common Counter (like `Parent`) as `(Parent-Executed)`.109///110/// In SingleByte mode, Counters are binary. Subtraction is not111/// applicable (but addition is capable). In this case, both112/// `Executed` and `Skipped` counters are required. `Skipped` is113/// `None` by default. It is allocated in the coverage mapping.114///115/// There might be cases that `Parent` could be induced with116/// `(Executed+Skipped)`. This is not always applicable.117class CounterPair {118public:119 /// Optional value.120 class ValueOpt {121 private:122 static constexpr uint32_t None = (1u << 31); /// None is allocated.123 static constexpr uint32_t Mask = None - 1;124 125 uint32_t Val;126 127 public:128 ValueOpt() : Val(None) {}129 130 ValueOpt(unsigned InitVal) {131 assert(!(InitVal & ~Mask));132 Val = InitVal;133 }134 135 bool hasValue() const { return !(Val & None); }136 137 operator uint32_t() const { return Val; }138 };139 140 ValueOpt Executed;141 ValueOpt Skipped; /// May be None.142 143 /// Initialized with Skipped=None.144 CounterPair(unsigned Val) : Executed(Val) {}145 146 // FIXME: Should work with {None, None}147 CounterPair() : Executed(0) {}148};149 150struct OrderGlobalInitsOrStermFinalizers {151 unsigned int priority;152 unsigned int lex_order;153 OrderGlobalInitsOrStermFinalizers(unsigned int p, unsigned int l)154 : priority(p), lex_order(l) {}155 156 bool operator==(const OrderGlobalInitsOrStermFinalizers &RHS) const {157 return priority == RHS.priority && lex_order == RHS.lex_order;158 }159 160 bool operator<(const OrderGlobalInitsOrStermFinalizers &RHS) const {161 return std::tie(priority, lex_order) <162 std::tie(RHS.priority, RHS.lex_order);163 }164};165 166struct ObjCEntrypoints {167 ObjCEntrypoints() { memset(this, 0, sizeof(*this)); }168 169 /// void objc_alloc(id);170 llvm::FunctionCallee objc_alloc;171 172 /// void objc_allocWithZone(id);173 llvm::FunctionCallee objc_allocWithZone;174 175 /// void objc_alloc_init(id);176 llvm::FunctionCallee objc_alloc_init;177 178 /// void objc_autoreleasePoolPop(void*);179 llvm::FunctionCallee objc_autoreleasePoolPop;180 181 /// void objc_autoreleasePoolPop(void*);182 /// Note this method is used when we are using exception handling183 llvm::FunctionCallee objc_autoreleasePoolPopInvoke;184 185 /// void *objc_autoreleasePoolPush(void);186 llvm::Function *objc_autoreleasePoolPush;187 188 /// id objc_autorelease(id);189 llvm::Function *objc_autorelease;190 191 /// id objc_autorelease(id);192 /// Note this is the runtime method not the intrinsic.193 llvm::FunctionCallee objc_autoreleaseRuntimeFunction;194 195 /// id objc_autoreleaseReturnValue(id);196 llvm::Function *objc_autoreleaseReturnValue;197 198 /// void objc_copyWeak(id *dest, id *src);199 llvm::Function *objc_copyWeak;200 201 /// void objc_destroyWeak(id*);202 llvm::Function *objc_destroyWeak;203 204 /// id objc_initWeak(id*, id);205 llvm::Function *objc_initWeak;206 207 /// id objc_loadWeak(id*);208 llvm::Function *objc_loadWeak;209 210 /// id objc_loadWeakRetained(id*);211 llvm::Function *objc_loadWeakRetained;212 213 /// void objc_moveWeak(id *dest, id *src);214 llvm::Function *objc_moveWeak;215 216 /// id objc_retain(id);217 llvm::Function *objc_retain;218 219 /// id objc_retain(id);220 /// Note this is the runtime method not the intrinsic.221 llvm::FunctionCallee objc_retainRuntimeFunction;222 223 /// id objc_retainAutorelease(id);224 llvm::Function *objc_retainAutorelease;225 226 /// id objc_retainAutoreleaseReturnValue(id);227 llvm::Function *objc_retainAutoreleaseReturnValue;228 229 /// id objc_retainAutoreleasedReturnValue(id);230 llvm::Function *objc_retainAutoreleasedReturnValue;231 232 /// id objc_retainBlock(id);233 llvm::Function *objc_retainBlock;234 235 /// void objc_release(id);236 llvm::Function *objc_release;237 238 /// void objc_release(id);239 /// Note this is the runtime method not the intrinsic.240 llvm::FunctionCallee objc_releaseRuntimeFunction;241 242 /// void objc_storeStrong(id*, id);243 llvm::Function *objc_storeStrong;244 245 /// id objc_storeWeak(id*, id);246 llvm::Function *objc_storeWeak;247 248 /// id objc_unsafeClaimAutoreleasedReturnValue(id);249 llvm::Function *objc_unsafeClaimAutoreleasedReturnValue;250 251 /// A void(void) inline asm to use to mark that the return value of252 /// a call will be immediately retain.253 llvm::InlineAsm *retainAutoreleasedReturnValueMarker;254 255 /// void clang.arc.use(...);256 llvm::Function *clang_arc_use;257 258 /// void clang.arc.noop.use(...);259 llvm::Function *clang_arc_noop_use;260};261 262/// This class records statistics on instrumentation based profiling.263class InstrProfStats {264 uint32_t VisitedInMainFile = 0;265 uint32_t MissingInMainFile = 0;266 uint32_t Visited = 0;267 uint32_t Missing = 0;268 uint32_t Mismatched = 0;269 270public:271 InstrProfStats() = default;272 /// Record that we've visited a function and whether or not that function was273 /// in the main source file.274 void addVisited(bool MainFile) {275 if (MainFile)276 ++VisitedInMainFile;277 ++Visited;278 }279 /// Record that a function we've visited has no profile data.280 void addMissing(bool MainFile) {281 if (MainFile)282 ++MissingInMainFile;283 ++Missing;284 }285 /// Record that a function we've visited has mismatched profile data.286 void addMismatched(bool MainFile) { ++Mismatched; }287 /// Whether or not the stats we've gathered indicate any potential problems.288 bool hasDiagnostics() { return Missing || Mismatched; }289 /// Report potential problems we've found to \c Diags.290 void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile);291};292 293/// A pair of helper functions for a __block variable.294class BlockByrefHelpers : public llvm::FoldingSetNode {295 // MSVC requires this type to be complete in order to process this296 // header.297public:298 llvm::Constant *CopyHelper;299 llvm::Constant *DisposeHelper;300 301 /// The alignment of the field. This is important because302 /// different offsets to the field within the byref struct need to303 /// have different helper functions.304 CharUnits Alignment;305 306 BlockByrefHelpers(CharUnits alignment)307 : CopyHelper(nullptr), DisposeHelper(nullptr), Alignment(alignment) {}308 BlockByrefHelpers(const BlockByrefHelpers &) = default;309 virtual ~BlockByrefHelpers();310 311 void Profile(llvm::FoldingSetNodeID &id) const {312 id.AddInteger(Alignment.getQuantity());313 profileImpl(id);314 }315 virtual void profileImpl(llvm::FoldingSetNodeID &id) const = 0;316 317 virtual bool needsCopy() const { return true; }318 virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src) = 0;319 320 virtual bool needsDispose() const { return true; }321 virtual void emitDispose(CodeGenFunction &CGF, Address field) = 0;322};323 324/// This class organizes the cross-function state that is used while generating325/// LLVM code.326class CodeGenModule : public CodeGenTypeCache {327 CodeGenModule(const CodeGenModule &) = delete;328 void operator=(const CodeGenModule &) = delete;329 330public:331 struct Structor {332 Structor()333 : Priority(0), LexOrder(~0u), Initializer(nullptr),334 AssociatedData(nullptr) {}335 Structor(int Priority, unsigned LexOrder, llvm::Constant *Initializer,336 llvm::Constant *AssociatedData)337 : Priority(Priority), LexOrder(LexOrder), Initializer(Initializer),338 AssociatedData(AssociatedData) {}339 int Priority;340 unsigned LexOrder;341 llvm::Constant *Initializer;342 llvm::Constant *AssociatedData;343 };344 345 typedef std::vector<Structor> CtorList;346 347private:348 ASTContext &Context;349 const LangOptions &LangOpts;350 IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; // Only used for debug info.351 const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.352 const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.353 const CodeGenOptions &CodeGenOpts;354 unsigned NumAutoVarInit = 0;355 llvm::Module &TheModule;356 DiagnosticsEngine &Diags;357 const TargetInfo &Target;358 std::unique_ptr<CGCXXABI> ABI;359 llvm::LLVMContext &VMContext;360 std::string ModuleNameHash;361 bool CXX20ModuleInits = false;362 std::unique_ptr<CodeGenTBAA> TBAA;363 364 mutable std::unique_ptr<TargetCodeGenInfo> TheTargetCodeGenInfo;365 366 // This should not be moved earlier, since its initialization depends on some367 // of the previous reference members being already initialized and also checks368 // if TheTargetCodeGenInfo is NULL369 std::unique_ptr<CodeGenTypes> Types;370 371 /// Holds information about C++ vtables.372 CodeGenVTables VTables;373 374 std::unique_ptr<CGObjCRuntime> ObjCRuntime;375 std::unique_ptr<CGOpenCLRuntime> OpenCLRuntime;376 std::unique_ptr<CGOpenMPRuntime> OpenMPRuntime;377 std::unique_ptr<CGCUDARuntime> CUDARuntime;378 std::unique_ptr<CGHLSLRuntime> HLSLRuntime;379 std::unique_ptr<CGDebugInfo> DebugInfo;380 std::unique_ptr<ObjCEntrypoints> ObjCData;381 llvm::MDNode *NoObjCARCExceptionsMetadata = nullptr;382 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;383 InstrProfStats PGOStats;384 std::unique_ptr<llvm::SanitizerStatReport> SanStats;385 StackExhaustionHandler StackHandler;386 387 // A set of references that have only been seen via a weakref so far. This is388 // used to remove the weak of the reference if we ever see a direct reference389 // or a definition.390 llvm::SmallPtrSet<llvm::GlobalValue*, 10> WeakRefReferences;391 392 /// This contains all the decls which have definitions but/ which are deferred393 /// for emission and therefore should only be output if they are actually394 /// used. If a decl is in this, then it is known to have not been referenced395 /// yet.396 llvm::DenseMap<StringRef, GlobalDecl> DeferredDecls;397 398 llvm::StringSet<llvm::BumpPtrAllocator> DeferredResolversToEmit;399 400 /// This is a list of deferred decls which we have seen that *are* actually401 /// referenced. These get code generated when the module is done.402 std::vector<GlobalDecl> DeferredDeclsToEmit;403 void addDeferredDeclToEmit(GlobalDecl GD) {404 DeferredDeclsToEmit.emplace_back(GD);405 addEmittedDeferredDecl(GD);406 }407 408 /// Decls that were DeferredDecls and have now been emitted.409 llvm::DenseMap<llvm::StringRef, GlobalDecl> EmittedDeferredDecls;410 411 void addEmittedDeferredDecl(GlobalDecl GD) {412 // Reemission is only needed in incremental mode.413 if (!Context.getLangOpts().IncrementalExtensions)414 return;415 416 // Assume a linkage by default that does not need reemission.417 auto L = llvm::GlobalValue::ExternalLinkage;418 if (llvm::isa<FunctionDecl>(GD.getDecl()))419 L = getFunctionLinkage(GD);420 else if (auto *VD = llvm::dyn_cast<VarDecl>(GD.getDecl()))421 L = getLLVMLinkageVarDefinition(VD);422 423 if (llvm::GlobalValue::isInternalLinkage(L) ||424 llvm::GlobalValue::isLinkOnceLinkage(L) ||425 llvm::GlobalValue::isWeakLinkage(L)) {426 EmittedDeferredDecls[getMangledName(GD)] = GD;427 }428 }429 430 /// List of alias we have emitted. Used to make sure that what they point to431 /// is defined once we get to the end of the of the translation unit.432 std::vector<GlobalDecl> Aliases;433 434 /// List of multiversion functions to be emitted. This list is processed in435 /// conjunction with other deferred symbols and is used to ensure that436 /// multiversion function resolvers and ifuncs are defined and emitted.437 std::vector<GlobalDecl> MultiVersionFuncs;438 439 llvm::MapVector<StringRef, llvm::TrackingVH<llvm::Constant>> Replacements;440 441 /// List of global values to be replaced with something else. Used when we442 /// want to replace a GlobalValue but can't identify it by its mangled name443 /// anymore (because the name is already taken).444 llvm::SmallVector<std::pair<llvm::GlobalValue *, llvm::Constant *>, 8>445 GlobalValReplacements;446 447 /// Variables for which we've emitted globals containing their constant448 /// values along with the corresponding globals, for opportunistic reuse.449 llvm::DenseMap<const VarDecl*, llvm::GlobalVariable*> InitializerConstants;450 451 /// Set of global decls for which we already diagnosed mangled name conflict.452 /// Required to not issue a warning (on a mangling conflict) multiple times453 /// for the same decl.454 llvm::DenseSet<GlobalDecl> DiagnosedConflictingDefinitions;455 456 /// A queue of (optional) vtables to consider emitting.457 std::vector<const CXXRecordDecl*> DeferredVTables;458 459 /// A queue of (optional) vtables that may be emitted opportunistically.460 std::vector<const CXXRecordDecl *> OpportunisticVTables;461 462 /// List of global values which are required to be present in the object file;463 /// bitcast to i8*. This is used for forcing visibility of symbols which may464 /// otherwise be optimized out.465 std::vector<llvm::WeakTrackingVH> LLVMUsed;466 std::vector<llvm::WeakTrackingVH> LLVMCompilerUsed;467 468 /// Store the list of global constructors and their respective priorities to469 /// be emitted when the translation unit is complete.470 CtorList GlobalCtors;471 472 /// Store the list of global destructors and their respective priorities to be473 /// emitted when the translation unit is complete.474 CtorList GlobalDtors;475 476 /// An ordered map of canonical GlobalDecls to their mangled names.477 llvm::MapVector<GlobalDecl, StringRef> MangledDeclNames;478 llvm::StringMap<GlobalDecl, llvm::BumpPtrAllocator> Manglings;479 480 /// Global annotations.481 std::vector<llvm::Constant*> Annotations;482 483 // Store deferred function annotations so they can be emitted at the end with484 // most up to date ValueDecl that will have all the inherited annotations.485 llvm::MapVector<StringRef, const ValueDecl *> DeferredAnnotations;486 487 /// Map used to get unique annotation strings.488 llvm::StringMap<llvm::Constant*> AnnotationStrings;489 490 /// Used for uniquing of annotation arguments.491 llvm::DenseMap<unsigned, llvm::Constant *> AnnotationArgs;492 493 llvm::StringMap<llvm::GlobalVariable *> CFConstantStringMap;494 495 llvm::DenseMap<llvm::Constant *, llvm::GlobalVariable *> ConstantStringMap;496 llvm::DenseMap<const UnnamedGlobalConstantDecl *, llvm::GlobalVariable *>497 UnnamedGlobalConstantDeclMap;498 llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap;499 llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap;500 llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap;501 502 llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap;503 llvm::DenseMap<QualType, llvm::Constant *> AtomicGetterHelperFnMap;504 505 /// Map used to get unique type descriptor constants for sanitizers.506 llvm::DenseMap<QualType, llvm::Constant *> TypeDescriptorMap;507 508 /// Map used to track internal linkage functions declared within509 /// extern "C" regions.510 typedef llvm::MapVector<IdentifierInfo *,511 llvm::GlobalValue *> StaticExternCMap;512 StaticExternCMap StaticExternCValues;513 514 /// thread_local variables defined or used in this TU.515 std::vector<const VarDecl *> CXXThreadLocals;516 517 /// thread_local variables with initializers that need to run518 /// before any thread_local variable in this TU is odr-used.519 std::vector<llvm::Function *> CXXThreadLocalInits;520 std::vector<const VarDecl *> CXXThreadLocalInitVars;521 522 /// Global variables with initializers that need to run before main.523 std::vector<llvm::Function *> CXXGlobalInits;524 525 /// When a C++ decl with an initializer is deferred, null is526 /// appended to CXXGlobalInits, and the index of that null is placed527 /// here so that the initializer will be performed in the correct528 /// order. Once the decl is emitted, the index is replaced with ~0U to ensure529 /// that we don't re-emit the initializer.530 llvm::DenseMap<const Decl*, unsigned> DelayedCXXInitPosition;531 532 typedef std::pair<OrderGlobalInitsOrStermFinalizers, llvm::Function *>533 GlobalInitData;534 535 // When a tail call is performed on an "undefined" symbol, on PPC without pc536 // relative feature, the tail call is not allowed. In "EmitCall" for such537 // tail calls, the "undefined" symbols may be forward declarations, their538 // definitions are provided in the module after the callsites. For such tail539 // calls, diagnose message should not be emitted.540 llvm::SmallSetVector<std::pair<const FunctionDecl *, SourceLocation>, 4>541 MustTailCallUndefinedGlobals;542 543 struct GlobalInitPriorityCmp {544 bool operator()(const GlobalInitData &LHS,545 const GlobalInitData &RHS) const {546 return LHS.first.priority < RHS.first.priority;547 }548 };549 550 /// Global variables with initializers whose order of initialization is set by551 /// init_priority attribute.552 SmallVector<GlobalInitData, 8> PrioritizedCXXGlobalInits;553 554 /// Global destructor functions and arguments that need to run on termination.555 /// When UseSinitAndSterm is set, it instead contains sterm finalizer556 /// functions, which also run on unloading a shared library.557 typedef std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,558 llvm::Constant *>559 CXXGlobalDtorsOrStermFinalizer_t;560 SmallVector<CXXGlobalDtorsOrStermFinalizer_t, 8>561 CXXGlobalDtorsOrStermFinalizers;562 563 typedef std::pair<OrderGlobalInitsOrStermFinalizers, llvm::Function *>564 StermFinalizerData;565 566 struct StermFinalizerPriorityCmp {567 bool operator()(const StermFinalizerData &LHS,568 const StermFinalizerData &RHS) const {569 return LHS.first.priority < RHS.first.priority;570 }571 };572 573 /// Global variables with sterm finalizers whose order of initialization is574 /// set by init_priority attribute.575 SmallVector<StermFinalizerData, 8> PrioritizedCXXStermFinalizers;576 577 /// The complete set of modules that has been imported.578 llvm::SetVector<clang::Module *> ImportedModules;579 580 /// The set of modules for which the module initializers581 /// have been emitted.582 llvm::SmallPtrSet<clang::Module *, 16> EmittedModuleInitializers;583 584 /// A vector of metadata strings for linker options.585 SmallVector<llvm::MDNode *, 16> LinkerOptionsMetadata;586 587 /// A vector of metadata strings for dependent libraries for ELF.588 SmallVector<llvm::MDNode *, 16> ELFDependentLibraries;589 590 /// @name Cache for Objective-C runtime types591 /// @{592 593 /// Cached reference to the class for constant strings. This value has type594 /// int * but is actually an Obj-C class pointer.595 llvm::WeakTrackingVH CFConstantStringClassRef;596 597 /// The type used to describe the state of a fast enumeration in598 /// Objective-C's for..in loop.599 QualType ObjCFastEnumerationStateType;600 601 /// @}602 603 /// Lazily create the Objective-C runtime604 void createObjCRuntime();605 606 void createOpenCLRuntime();607 void createOpenMPRuntime();608 void createCUDARuntime();609 void createHLSLRuntime();610 611 bool isTriviallyRecursive(const FunctionDecl *F);612 bool shouldEmitFunction(GlobalDecl GD);613 // Whether a global variable should be emitted by CUDA/HIP host/device614 // related attributes.615 bool shouldEmitCUDAGlobalVar(const VarDecl *VD) const;616 bool shouldOpportunisticallyEmitVTables();617 /// Map used to be sure we don't emit the same CompoundLiteral twice.618 llvm::DenseMap<const CompoundLiteralExpr *, llvm::GlobalVariable *>619 EmittedCompoundLiterals;620 621 /// Map of the global blocks we've emitted, so that we don't have to re-emit622 /// them if the constexpr evaluator gets aggressive.623 llvm::DenseMap<const BlockExpr *, llvm::Constant *> EmittedGlobalBlocks;624 625 /// @name Cache for Blocks Runtime Globals626 /// @{627 628 llvm::Constant *NSConcreteGlobalBlock = nullptr;629 llvm::Constant *NSConcreteStackBlock = nullptr;630 631 llvm::FunctionCallee BlockObjectAssign = nullptr;632 llvm::FunctionCallee BlockObjectDispose = nullptr;633 634 llvm::Type *BlockDescriptorType = nullptr;635 llvm::Type *GenericBlockLiteralType = nullptr;636 637 struct {638 int GlobalUniqueCount;639 } Block;640 641 GlobalDecl initializedGlobalDecl;642 643 /// @}644 645 /// void @llvm.lifetime.start(i64 %size, i8* nocapture <ptr>)646 llvm::Function *LifetimeStartFn = nullptr;647 648 /// void @llvm.lifetime.end(i64 %size, i8* nocapture <ptr>)649 llvm::Function *LifetimeEndFn = nullptr;650 651 /// void @llvm.fake.use(...)652 llvm::Function *FakeUseFn = nullptr;653 654 std::unique_ptr<SanitizerMetadata> SanitizerMD;655 656 llvm::MapVector<const Decl *, bool> DeferredEmptyCoverageMappingDecls;657 658 std::unique_ptr<CoverageMappingModuleGen> CoverageMapping;659 660 /// Mapping from canonical types to their metadata identifiers. We need to661 /// maintain this mapping because identifiers may be formed from distinct662 /// MDNodes.663 typedef llvm::DenseMap<QualType, llvm::Metadata *> MetadataTypeMap;664 MetadataTypeMap MetadataIdMap;665 MetadataTypeMap VirtualMetadataIdMap;666 MetadataTypeMap GeneralizedMetadataIdMap;667 668 // Helps squashing blocks of TopLevelStmtDecl into a single llvm::Function669 // when used with -fincremental-extensions.670 std::pair<std::unique_ptr<CodeGenFunction>, const TopLevelStmtDecl *>671 GlobalTopLevelStmtBlockInFlight;672 673 llvm::DenseMap<GlobalDecl, uint16_t> PtrAuthDiscriminatorHashes;674 675 llvm::DenseMap<const CXXRecordDecl *, std::optional<PointerAuthQualifier>>676 VTablePtrAuthInfos;677 std::optional<PointerAuthQualifier>678 computeVTPointerAuthentication(const CXXRecordDecl *ThisClass);679 680 AtomicOptions AtomicOpts;681 682 // A set of functions which should be hot-patched; see683 // -fms-hotpatch-functions-file (and -list). This will nearly always be empty.684 // The list is sorted for binary-searching.685 std::vector<std::string> MSHotPatchFunctions;686 687public:688 CodeGenModule(ASTContext &C, IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,689 const HeaderSearchOptions &headersearchopts,690 const PreprocessorOptions &ppopts,691 const CodeGenOptions &CodeGenOpts, llvm::Module &M,692 DiagnosticsEngine &Diags,693 CoverageSourceInfo *CoverageInfo = nullptr);694 695 ~CodeGenModule();696 697 void clear();698 699 /// Finalize LLVM code generation.700 void Release();701 702 /// Get the current Atomic options.703 AtomicOptions getAtomicOpts() { return AtomicOpts; }704 705 /// Set the current Atomic options.706 void setAtomicOpts(AtomicOptions AO) { AtomicOpts = AO; }707 708 /// Return true if we should emit location information for expressions.709 bool getExpressionLocationsEnabled() const;710 711 /// Return a reference to the configured Objective-C runtime.712 CGObjCRuntime &getObjCRuntime() {713 if (!ObjCRuntime) createObjCRuntime();714 return *ObjCRuntime;715 }716 717 /// Return true iff an Objective-C runtime has been configured.718 bool hasObjCRuntime() { return !!ObjCRuntime; }719 720 const std::string &getModuleNameHash() const { return ModuleNameHash; }721 722 /// Return a reference to the configured OpenCL runtime.723 CGOpenCLRuntime &getOpenCLRuntime() {724 assert(OpenCLRuntime != nullptr);725 return *OpenCLRuntime;726 }727 728 /// Return a reference to the configured OpenMP runtime.729 CGOpenMPRuntime &getOpenMPRuntime() {730 assert(OpenMPRuntime != nullptr);731 return *OpenMPRuntime;732 }733 734 /// Return a reference to the configured CUDA runtime.735 CGCUDARuntime &getCUDARuntime() {736 assert(CUDARuntime != nullptr);737 return *CUDARuntime;738 }739 740 /// Return a reference to the configured HLSL runtime.741 CGHLSLRuntime &getHLSLRuntime() {742 assert(HLSLRuntime != nullptr);743 return *HLSLRuntime;744 }745 746 ObjCEntrypoints &getObjCEntrypoints() const {747 assert(ObjCData != nullptr);748 return *ObjCData;749 }750 751 // Version checking functions, used to implement ObjC's @available:752 // i32 @__isOSVersionAtLeast(i32, i32, i32)753 llvm::FunctionCallee IsOSVersionAtLeastFn = nullptr;754 // i32 @__isPlatformVersionAtLeast(i32, i32, i32, i32)755 llvm::FunctionCallee IsPlatformVersionAtLeastFn = nullptr;756 757 InstrProfStats &getPGOStats() { return PGOStats; }758 llvm::IndexedInstrProfReader *getPGOReader() const { return PGOReader.get(); }759 760 CoverageMappingModuleGen *getCoverageMapping() const {761 return CoverageMapping.get();762 }763 764 llvm::Constant *getStaticLocalDeclAddress(const VarDecl *D) {765 return StaticLocalDeclMap[D];766 }767 void setStaticLocalDeclAddress(const VarDecl *D,768 llvm::Constant *C) {769 StaticLocalDeclMap[D] = C;770 }771 772 llvm::Constant *773 getOrCreateStaticVarDecl(const VarDecl &D,774 llvm::GlobalValue::LinkageTypes Linkage);775 776 llvm::GlobalVariable *getStaticLocalDeclGuardAddress(const VarDecl *D) {777 return StaticLocalDeclGuardMap[D];778 }779 void setStaticLocalDeclGuardAddress(const VarDecl *D,780 llvm::GlobalVariable *C) {781 StaticLocalDeclGuardMap[D] = C;782 }783 784 Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant,785 CharUnits Align);786 787 bool lookupRepresentativeDecl(StringRef MangledName,788 GlobalDecl &Result) const;789 790 llvm::Constant *getAtomicSetterHelperFnMap(QualType Ty) {791 return AtomicSetterHelperFnMap[Ty];792 }793 void setAtomicSetterHelperFnMap(QualType Ty,794 llvm::Constant *Fn) {795 AtomicSetterHelperFnMap[Ty] = Fn;796 }797 798 llvm::Constant *getAtomicGetterHelperFnMap(QualType Ty) {799 return AtomicGetterHelperFnMap[Ty];800 }801 void setAtomicGetterHelperFnMap(QualType Ty,802 llvm::Constant *Fn) {803 AtomicGetterHelperFnMap[Ty] = Fn;804 }805 806 llvm::Constant *getTypeDescriptorFromMap(QualType Ty) {807 return TypeDescriptorMap[Ty];808 }809 void setTypeDescriptorInMap(QualType Ty, llvm::Constant *C) {810 TypeDescriptorMap[Ty] = C;811 }812 813 CGDebugInfo *getModuleDebugInfo() { return DebugInfo.get(); }814 815 llvm::MDNode *getNoObjCARCExceptionsMetadata() {816 if (!NoObjCARCExceptionsMetadata)817 NoObjCARCExceptionsMetadata = llvm::MDNode::get(getLLVMContext(), {});818 return NoObjCARCExceptionsMetadata;819 }820 821 ASTContext &getContext() const { return Context; }822 const LangOptions &getLangOpts() const { return LangOpts; }823 const IntrusiveRefCntPtr<llvm::vfs::FileSystem> &getFileSystem() const {824 return FS;825 }826 const HeaderSearchOptions &getHeaderSearchOpts()827 const { return HeaderSearchOpts; }828 const PreprocessorOptions &getPreprocessorOpts()829 const { return PreprocessorOpts; }830 const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }831 llvm::Module &getModule() const { return TheModule; }832 DiagnosticsEngine &getDiags() const { return Diags; }833 const llvm::DataLayout &getDataLayout() const {834 return TheModule.getDataLayout();835 }836 const TargetInfo &getTarget() const { return Target; }837 const llvm::Triple &getTriple() const { return Target.getTriple(); }838 bool supportsCOMDAT() const;839 void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO);840 841 const ABIInfo &getABIInfo();842 CGCXXABI &getCXXABI() const { return *ABI; }843 llvm::LLVMContext &getLLVMContext() { return VMContext; }844 845 bool shouldUseTBAA() const { return TBAA != nullptr; }846 847 const TargetCodeGenInfo &getTargetCodeGenInfo();848 849 CodeGenTypes &getTypes() { return *Types; }850 851 CodeGenVTables &getVTables() { return VTables; }852 853 ItaniumVTableContext &getItaniumVTableContext() {854 return VTables.getItaniumVTableContext();855 }856 857 const ItaniumVTableContext &getItaniumVTableContext() const {858 return VTables.getItaniumVTableContext();859 }860 861 MicrosoftVTableContext &getMicrosoftVTableContext() {862 return VTables.getMicrosoftVTableContext();863 }864 865 CtorList &getGlobalCtors() { return GlobalCtors; }866 CtorList &getGlobalDtors() { return GlobalDtors; }867 868 /// getTBAATypeInfo - Get metadata used to describe accesses to objects of869 /// the given type.870 llvm::MDNode *getTBAATypeInfo(QualType QTy);871 872 /// getTBAAAccessInfo - Get TBAA information that describes an access to873 /// an object of the given type.874 TBAAAccessInfo getTBAAAccessInfo(QualType AccessType);875 876 /// getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an877 /// access to a virtual table pointer.878 TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType);879 880 llvm::MDNode *getTBAAStructInfo(QualType QTy);881 882 /// getTBAABaseTypeInfo - Get metadata that describes the given base access883 /// type. Return null if the type is not suitable for use in TBAA access tags.884 llvm::MDNode *getTBAABaseTypeInfo(QualType QTy);885 886 /// getTBAAAccessTagInfo - Get TBAA tag for a given memory access.887 llvm::MDNode *getTBAAAccessTagInfo(TBAAAccessInfo Info);888 889 /// mergeTBAAInfoForCast - Get merged TBAA information for the purposes of890 /// type casts.891 TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo,892 TBAAAccessInfo TargetInfo);893 894 /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the895 /// purposes of conditional operator.896 TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA,897 TBAAAccessInfo InfoB);898 899 /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the900 /// purposes of memory transfer calls.901 TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo,902 TBAAAccessInfo SrcInfo);903 904 /// getTBAAInfoForSubobject - Get TBAA information for an access with a given905 /// base lvalue.906 TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType) {907 if (Base.getTBAAInfo().isMayAlias())908 return TBAAAccessInfo::getMayAliasInfo();909 return getTBAAAccessInfo(AccessType);910 }911 912 bool isPaddedAtomicType(QualType type);913 bool isPaddedAtomicType(const AtomicType *type);914 915 /// DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.916 void DecorateInstructionWithTBAA(llvm::Instruction *Inst,917 TBAAAccessInfo TBAAInfo);918 919 /// Adds !invariant.barrier !tag to instruction920 void DecorateInstructionWithInvariantGroup(llvm::Instruction *I,921 const CXXRecordDecl *RD);922 923 /// Emit the given number of characters as a value of type size_t.924 llvm::ConstantInt *getSize(CharUnits numChars);925 926 /// Set the visibility for the given LLVM GlobalValue.927 void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const;928 929 void setDSOLocal(llvm::GlobalValue *GV) const;930 931 bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const {932 return getLangOpts().hasDefaultVisibilityExportMapping() && D &&933 (D->getLinkageAndVisibility().getVisibility() ==934 DefaultVisibility) &&935 (getLangOpts().isAllDefaultVisibilityExportMapping() ||936 (getLangOpts().isExplicitDefaultVisibilityExportMapping() &&937 D->getLinkageAndVisibility().isVisibilityExplicit()));938 }939 void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const;940 void setDLLImportDLLExport(llvm::GlobalValue *GV, const NamedDecl *D) const;941 /// Set visibility, dllimport/dllexport and dso_local.942 /// This must be called after dllimport/dllexport is set.943 void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const;944 void setGVProperties(llvm::GlobalValue *GV, const NamedDecl *D) const;945 946 void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const;947 948 /// Set the TLS mode for the given LLVM GlobalValue for the thread-local949 /// variable declaration D.950 void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const;951 952 /// Get LLVM TLS mode from CodeGenOptions.953 llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const;954 955 static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V) {956 switch (V) {957 case DefaultVisibility: return llvm::GlobalValue::DefaultVisibility;958 case HiddenVisibility: return llvm::GlobalValue::HiddenVisibility;959 case ProtectedVisibility: return llvm::GlobalValue::ProtectedVisibility;960 }961 llvm_unreachable("unknown visibility!");962 }963 964 llvm::Constant *GetAddrOfGlobal(GlobalDecl GD,965 ForDefinition_t IsForDefinition966 = NotForDefinition);967 968 /// Will return a global variable of the given type. If a variable with a969 /// different type already exists then a new variable with the right type970 /// will be created and all uses of the old variable will be replaced with a971 /// bitcast to the new variable.972 llvm::GlobalVariable *973 CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty,974 llvm::GlobalValue::LinkageTypes Linkage,975 llvm::Align Alignment);976 977 llvm::Function *CreateGlobalInitOrCleanUpFunction(978 llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI,979 SourceLocation Loc = SourceLocation(), bool TLS = false,980 llvm::GlobalVariable::LinkageTypes Linkage =981 llvm::GlobalVariable::InternalLinkage);982 983 /// Return the AST address space of the underlying global variable for D, as984 /// determined by its declaration. Normally this is the same as the address985 /// space of D's type, but in CUDA, address spaces are associated with986 /// declarations, not types. If D is nullptr, return the default address987 /// space for global variable.988 ///989 /// For languages without explicit address spaces, if D has default address990 /// space, target-specific global or constant address space may be returned.991 LangAS GetGlobalVarAddressSpace(const VarDecl *D);992 993 /// Return the AST address space of constant literal, which is used to emit994 /// the constant literal as global variable in LLVM IR.995 /// Note: This is not necessarily the address space of the constant literal996 /// in AST. For address space agnostic language, e.g. C++, constant literal997 /// in AST is always in default address space.998 LangAS GetGlobalConstantAddressSpace() const;999 1000 /// Return the llvm::Constant for the address of the given global variable.1001 /// If Ty is non-null and if the global doesn't exist, then it will be created1002 /// with the specified type instead of whatever the normal requested type1003 /// would be. If IsForDefinition is true, it is guaranteed that an actual1004 /// global with type Ty will be returned, not conversion of a variable with1005 /// the same mangled name but some other type.1006 llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,1007 llvm::Type *Ty = nullptr,1008 ForDefinition_t IsForDefinition1009 = NotForDefinition);1010 1011 /// Return the address of the given function. If Ty is non-null, then this1012 /// function will use the specified type if it has to create it.1013 llvm::Constant *GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty = nullptr,1014 bool ForVTable = false,1015 bool DontDefer = false,1016 ForDefinition_t IsForDefinition1017 = NotForDefinition);1018 1019 // Return the function body address of the given function.1020 llvm::Constant *GetFunctionStart(const ValueDecl *Decl);1021 1022 /// Return a function pointer for a reference to the given function.1023 /// This correctly handles weak references, but does not apply a1024 /// pointer signature.1025 llvm::Constant *getRawFunctionPointer(GlobalDecl GD,1026 llvm::Type *Ty = nullptr);1027 1028 /// Return the ABI-correct function pointer value for a reference1029 /// to the given function. This will apply a pointer signature if1030 /// necessary, caching the result for the given function.1031 llvm::Constant *getFunctionPointer(GlobalDecl GD, llvm::Type *Ty = nullptr);1032 1033 /// Return the ABI-correct function pointer value for a reference1034 /// to the given function. This will apply a pointer signature if1035 /// necessary.1036 llvm::Constant *getFunctionPointer(llvm::Constant *Pointer,1037 QualType FunctionType);1038 1039 llvm::Constant *getMemberFunctionPointer(const FunctionDecl *FD,1040 llvm::Type *Ty = nullptr);1041 1042 llvm::Constant *getMemberFunctionPointer(llvm::Constant *Pointer,1043 QualType FT);1044 1045 CGPointerAuthInfo getFunctionPointerAuthInfo(QualType T);1046 1047 CGPointerAuthInfo getMemberFunctionPointerAuthInfo(QualType FT);1048 1049 CGPointerAuthInfo getPointerAuthInfoForPointeeType(QualType type);1050 1051 CGPointerAuthInfo getPointerAuthInfoForType(QualType type);1052 1053 bool shouldSignPointer(const PointerAuthSchema &Schema);1054 llvm::Constant *getConstantSignedPointer(llvm::Constant *Pointer,1055 const PointerAuthSchema &Schema,1056 llvm::Constant *StorageAddress,1057 GlobalDecl SchemaDecl,1058 QualType SchemaType);1059 1060 llvm::Constant *1061 getConstantSignedPointer(llvm::Constant *Pointer, unsigned Key,1062 llvm::Constant *StorageAddress,1063 llvm::ConstantInt *OtherDiscriminator);1064 1065 llvm::ConstantInt *1066 getPointerAuthOtherDiscriminator(const PointerAuthSchema &Schema,1067 GlobalDecl SchemaDecl, QualType SchemaType);1068 1069 uint16_t getPointerAuthDeclDiscriminator(GlobalDecl GD);1070 std::optional<CGPointerAuthInfo>1071 getVTablePointerAuthInfo(CodeGenFunction *Context,1072 const CXXRecordDecl *Record,1073 llvm::Value *StorageAddress);1074 1075 std::optional<PointerAuthQualifier>1076 getVTablePointerAuthentication(const CXXRecordDecl *thisClass);1077 1078 CGPointerAuthInfo EmitPointerAuthInfo(const RecordDecl *RD);1079 1080 // Return whether RTTI information should be emitted for this target.1081 bool shouldEmitRTTI(bool ForEH = false) {1082 return (ForEH || getLangOpts().RTTI) &&1083 (!getLangOpts().isTargetDevice() || !getTriple().isGPU());1084 }1085 1086 /// Get the address of the RTTI descriptor for the given type.1087 llvm::Constant *GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH = false);1088 1089 /// Get the address of a GUID.1090 ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD);1091 1092 /// Get the address of a UnnamedGlobalConstant1093 ConstantAddress1094 GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD);1095 1096 /// Get the address of a template parameter object.1097 ConstantAddress1098 GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO);1099 1100 /// Get the address of the thunk for the given global decl.1101 llvm::Constant *GetAddrOfThunk(StringRef Name, llvm::Type *FnTy,1102 GlobalDecl GD);1103 1104 /// Get a reference to the target of VD.1105 ConstantAddress GetWeakRefReference(const ValueDecl *VD);1106 1107 /// Returns the assumed alignment of an opaque pointer to the given class.1108 CharUnits getClassPointerAlignment(const CXXRecordDecl *CD);1109 1110 /// Returns the minimum object size for an object of the given class type1111 /// (or a class derived from it).1112 CharUnits getMinimumClassObjectSize(const CXXRecordDecl *CD);1113 1114 /// Returns the minimum object size for an object of the given type.1115 CharUnits getMinimumObjectSize(QualType Ty) {1116 if (CXXRecordDecl *RD = Ty->getAsCXXRecordDecl())1117 return getMinimumClassObjectSize(RD);1118 return getContext().getTypeSizeInChars(Ty);1119 }1120 1121 /// Returns the assumed alignment of a virtual base of a class.1122 CharUnits getVBaseAlignment(CharUnits DerivedAlign,1123 const CXXRecordDecl *Derived,1124 const CXXRecordDecl *VBase);1125 1126 /// Given a class pointer with an actual known alignment, and the1127 /// expected alignment of an object at a dynamic offset w.r.t that1128 /// pointer, return the alignment to assume at the offset.1129 CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign,1130 const CXXRecordDecl *Class,1131 CharUnits ExpectedTargetAlign);1132 1133 CharUnits1134 computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass,1135 CastExpr::path_const_iterator Start,1136 CastExpr::path_const_iterator End);1137 1138 /// Returns the offset from a derived class to a class. Returns null if the1139 /// offset is 0.1140 llvm::Constant *1141 GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,1142 CastExpr::path_const_iterator PathBegin,1143 CastExpr::path_const_iterator PathEnd);1144 1145 llvm::FoldingSet<BlockByrefHelpers> ByrefHelpersCache;1146 1147 /// Fetches the global unique block count.1148 int getUniqueBlockCount() { return ++Block.GlobalUniqueCount; }1149 1150 /// Fetches the type of a generic block descriptor.1151 llvm::Type *getBlockDescriptorType();1152 1153 /// The type of a generic block literal.1154 llvm::Type *getGenericBlockLiteralType();1155 1156 /// Gets the address of a block which requires no captures.1157 llvm::Constant *GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name);1158 1159 /// Returns the address of a block which requires no caputres, or null if1160 /// we've yet to emit the block for BE.1161 llvm::Constant *getAddrOfGlobalBlockIfEmitted(const BlockExpr *BE) {1162 return EmittedGlobalBlocks.lookup(BE);1163 }1164 1165 /// Notes that BE's global block is available via Addr. Asserts that BE1166 /// isn't already emitted.1167 void setAddrOfGlobalBlock(const BlockExpr *BE, llvm::Constant *Addr);1168 1169 /// Return a pointer to a constant CFString object for the given string.1170 ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal);1171 1172 /// Return a constant array for the given string.1173 llvm::Constant *GetConstantArrayFromStringLiteral(const StringLiteral *E);1174 1175 /// Return a pointer to a constant array for the given string literal.1176 ConstantAddress1177 GetAddrOfConstantStringFromLiteral(const StringLiteral *S,1178 StringRef Name = ".str");1179 1180 /// Return a pointer to a constant array for the given ObjCEncodeExpr node.1181 ConstantAddress1182 GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *);1183 1184 /// Returns a pointer to a character array containing the literal and a1185 /// terminating '\0' character. The result has pointer to array type.1186 ///1187 /// \param GlobalName If provided, the name to use for the global (if one is1188 /// created).1189 ConstantAddress GetAddrOfConstantCString(const std::string &Str,1190 StringRef GlobalName = ".str");1191 1192 /// Returns a pointer to a constant global variable for the given file-scope1193 /// compound literal expression.1194 ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr*E);1195 1196 /// If it's been emitted already, returns the GlobalVariable corresponding to1197 /// a compound literal. Otherwise, returns null.1198 llvm::GlobalVariable *1199 getAddrOfConstantCompoundLiteralIfEmitted(const CompoundLiteralExpr *E);1200 1201 /// Notes that CLE's GlobalVariable is GV. Asserts that CLE isn't already1202 /// emitted.1203 void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE,1204 llvm::GlobalVariable *GV);1205 1206 /// Returns a pointer to a global variable representing a temporary1207 /// with static or thread storage duration.1208 ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E,1209 const Expr *Inner);1210 1211 /// Retrieve the record type that describes the state of an1212 /// Objective-C fast enumeration loop (for..in).1213 QualType getObjCFastEnumerationStateType();1214 1215 // Produce code for this constructor/destructor. This method doesn't try1216 // to apply any ABI rules about which other constructors/destructors1217 // are needed or if they are alias to each other.1218 llvm::Function *codegenCXXStructor(GlobalDecl GD);1219 1220 /// Return the address of the constructor/destructor of the given type.1221 llvm::Constant *1222 getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo = nullptr,1223 llvm::FunctionType *FnType = nullptr,1224 bool DontDefer = false,1225 ForDefinition_t IsForDefinition = NotForDefinition) {1226 return cast<llvm::Constant>(getAddrAndTypeOfCXXStructor(GD, FnInfo, FnType,1227 DontDefer,1228 IsForDefinition)1229 .getCallee());1230 }1231 1232 llvm::FunctionCallee getAddrAndTypeOfCXXStructor(1233 GlobalDecl GD, const CGFunctionInfo *FnInfo = nullptr,1234 llvm::FunctionType *FnType = nullptr, bool DontDefer = false,1235 ForDefinition_t IsForDefinition = NotForDefinition);1236 1237 /// Given a builtin id for a function like "__builtin_fabsf", return a1238 /// Function* for "fabsf".1239 llvm::Constant *getBuiltinLibFunction(const FunctionDecl *FD,1240 unsigned BuiltinID);1241 1242 llvm::Function *getIntrinsic(unsigned IID, ArrayRef<llvm::Type *> Tys = {});1243 1244 void AddCXXGlobalInit(llvm::Function *F) { CXXGlobalInits.push_back(F); }1245 1246 /// Emit code for a single top level declaration.1247 void EmitTopLevelDecl(Decl *D);1248 1249 /// Stored a deferred empty coverage mapping for an unused1250 /// and thus uninstrumented top level declaration.1251 void AddDeferredUnusedCoverageMapping(Decl *D);1252 1253 /// Remove the deferred empty coverage mapping as this1254 /// declaration is actually instrumented.1255 void ClearUnusedCoverageMapping(const Decl *D);1256 1257 /// Emit all the deferred coverage mappings1258 /// for the uninstrumented functions.1259 void EmitDeferredUnusedCoverageMappings();1260 1261 /// Emit an alias for "main" if it has no arguments (needed for wasm).1262 void EmitMainVoidAlias();1263 1264 /// Tell the consumer that this variable has been instantiated.1265 void HandleCXXStaticMemberVarInstantiation(VarDecl *VD);1266 1267 /// If the declaration has internal linkage but is inside an1268 /// extern "C" linkage specification, prepare to emit an alias for it1269 /// to the expected name.1270 template<typename SomeDecl>1271 void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV);1272 1273 /// Add a global to a list to be added to the llvm.used metadata.1274 void addUsedGlobal(llvm::GlobalValue *GV);1275 1276 /// Add a global to a list to be added to the llvm.compiler.used metadata.1277 void addCompilerUsedGlobal(llvm::GlobalValue *GV);1278 1279 /// Add a global to a list to be added to the llvm.compiler.used metadata.1280 void addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV);1281 1282 /// Add a destructor and object to add to the C++ global destructor function.1283 void AddCXXDtorEntry(llvm::FunctionCallee DtorFn, llvm::Constant *Object) {1284 CXXGlobalDtorsOrStermFinalizers.emplace_back(DtorFn.getFunctionType(),1285 DtorFn.getCallee(), Object);1286 }1287 1288 /// Add an sterm finalizer to the C++ global cleanup function.1289 void AddCXXStermFinalizerEntry(llvm::FunctionCallee DtorFn) {1290 CXXGlobalDtorsOrStermFinalizers.emplace_back(DtorFn.getFunctionType(),1291 DtorFn.getCallee(), nullptr);1292 }1293 1294 /// Add an sterm finalizer to its own llvm.global_dtors entry.1295 void AddCXXStermFinalizerToGlobalDtor(llvm::Function *StermFinalizer,1296 int Priority) {1297 AddGlobalDtor(StermFinalizer, Priority);1298 }1299 1300 void AddCXXPrioritizedStermFinalizerEntry(llvm::Function *StermFinalizer,1301 int Priority) {1302 OrderGlobalInitsOrStermFinalizers Key(Priority,1303 PrioritizedCXXStermFinalizers.size());1304 PrioritizedCXXStermFinalizers.push_back(1305 std::make_pair(Key, StermFinalizer));1306 }1307 1308 /// Create or return a runtime function declaration with the specified type1309 /// and name. If \p AssumeConvergent is true, the call will have the1310 /// convergent attribute added.1311 ///1312 /// For new code, please use the overload that takes a QualType; it sets1313 /// function attributes more accurately.1314 llvm::FunctionCallee1315 CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name,1316 llvm::AttributeList ExtraAttrs = llvm::AttributeList(),1317 bool Local = false, bool AssumeConvergent = false);1318 1319 /// Create or return a runtime function declaration with the specified type1320 /// and name. If \p AssumeConvergent is true, the call will have the1321 /// convergent attribute added.1322 llvm::FunctionCallee1323 CreateRuntimeFunction(QualType ReturnTy, ArrayRef<QualType> ArgTys,1324 StringRef Name,1325 llvm::AttributeList ExtraAttrs = llvm::AttributeList(),1326 bool Local = false, bool AssumeConvergent = false);1327 1328 /// Create a new runtime global variable with the specified type and name.1329 llvm::Constant *CreateRuntimeVariable(llvm::Type *Ty,1330 StringRef Name);1331 1332 ///@name Custom Blocks Runtime Interfaces1333 ///@{1334 1335 llvm::Constant *getNSConcreteGlobalBlock();1336 llvm::Constant *getNSConcreteStackBlock();1337 llvm::FunctionCallee getBlockObjectAssign();1338 llvm::FunctionCallee getBlockObjectDispose();1339 1340 ///@}1341 1342 llvm::Function *getLLVMLifetimeStartFn();1343 llvm::Function *getLLVMLifetimeEndFn();1344 llvm::Function *getLLVMFakeUseFn();1345 1346 // Make sure that this type is translated.1347 void UpdateCompletedType(const TagDecl *TD);1348 1349 llvm::Constant *getMemberPointerConstant(const UnaryOperator *e);1350 1351 /// Emit type info if type of an expression is a variably modified1352 /// type. Also emit proper debug info for cast types.1353 void EmitExplicitCastExprType(const ExplicitCastExpr *E,1354 CodeGenFunction *CGF = nullptr);1355 1356 /// Return the result of value-initializing the given type, i.e. a null1357 /// expression of the given type. This is usually, but not always, an LLVM1358 /// null constant.1359 llvm::Constant *EmitNullConstant(QualType T);1360 1361 /// Return a null constant appropriate for zero-initializing a base class with1362 /// the given type. This is usually, but not always, an LLVM null constant.1363 llvm::Constant *EmitNullConstantForBase(const CXXRecordDecl *Record);1364 1365 /// Emit a general error that something can't be done.1366 void Error(SourceLocation loc, StringRef error);1367 1368 /// Print out an error that codegen doesn't support the specified stmt yet.1369 void ErrorUnsupported(const Stmt *S, const char *Type);1370 1371 /// Print out an error that codegen doesn't support the specified decl yet.1372 void ErrorUnsupported(const Decl *D, const char *Type);1373 1374 /// Run some code with "sufficient" stack space. (Currently, at least 256K is1375 /// guaranteed). Produces a warning if we're low on stack space and allocates1376 /// more in that case. Use this in code that may recurse deeply to avoid stack1377 /// overflow.1378 void runWithSufficientStackSpace(SourceLocation Loc,1379 llvm::function_ref<void()> Fn);1380 1381 /// Set the attributes on the LLVM function for the given decl and function1382 /// info. This applies attributes necessary for handling the ABI as well as1383 /// user specified attributes like section.1384 void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F,1385 const CGFunctionInfo &FI);1386 1387 /// Set the LLVM function attributes (sext, zext, etc).1388 void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info,1389 llvm::Function *F, bool IsThunk);1390 1391 /// Set the LLVM function attributes which only apply to a function1392 /// definition.1393 void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F);1394 1395 /// Set the LLVM function attributes that represent floating point1396 /// environment.1397 void setLLVMFunctionFEnvAttributes(const FunctionDecl *D, llvm::Function *F);1398 1399 /// Return true iff the given type uses 'sret' when used as a return type.1400 bool ReturnTypeUsesSRet(const CGFunctionInfo &FI);1401 1402 /// Return true iff the given type has `inreg` set.1403 bool ReturnTypeHasInReg(const CGFunctionInfo &FI);1404 1405 /// Return true iff the given type uses an argument slot when 'sret' is used1406 /// as a return type.1407 bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI);1408 1409 /// Return true iff the given type uses 'fpret' when used as a return type.1410 bool ReturnTypeUsesFPRet(QualType ResultType);1411 1412 /// Return true iff the given type uses 'fp2ret' when used as a return type.1413 bool ReturnTypeUsesFP2Ret(QualType ResultType);1414 1415 /// Get the LLVM attributes and calling convention to use for a particular1416 /// function type.1417 ///1418 /// \param Name - The function name.1419 /// \param Info - The function type information.1420 /// \param CalleeInfo - The callee information these attributes are being1421 /// constructed for. If valid, the attributes applied to this decl may1422 /// contribute to the function attributes and calling convention.1423 /// \param Attrs [out] - On return, the attribute list to use.1424 /// \param CallingConv [out] - On return, the LLVM calling convention to use.1425 void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info,1426 CGCalleeInfo CalleeInfo,1427 llvm::AttributeList &Attrs, unsigned &CallingConv,1428 bool AttrOnCallSite, bool IsThunk);1429 1430 /// Adjust Memory attribute to ensure that the BE gets the right attribute1431 // in order to generate the library call or the intrinsic for the function1432 // name 'Name'.1433 void AdjustMemoryAttribute(StringRef Name, CGCalleeInfo CalleeInfo,1434 llvm::AttributeList &Attrs);1435 1436 /// Like the overload taking a `Function &`, but intended specifically1437 /// for frontends that want to build on Clang's target-configuration logic.1438 void addDefaultFunctionDefinitionAttributes(llvm::AttrBuilder &attrs);1439 1440 StringRef getMangledName(GlobalDecl GD);1441 StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD);1442 const GlobalDecl getMangledNameDecl(StringRef);1443 1444 void EmitTentativeDefinition(const VarDecl *D);1445 1446 void EmitExternalDeclaration(const DeclaratorDecl *D);1447 1448 void EmitVTable(CXXRecordDecl *Class);1449 1450 void RefreshTypeCacheForClass(const CXXRecordDecl *Class);1451 1452 /// Appends Opts to the "llvm.linker.options" metadata value.1453 void AppendLinkerOptions(StringRef Opts);1454 1455 /// Appends a detect mismatch command to the linker options.1456 void AddDetectMismatch(StringRef Name, StringRef Value);1457 1458 /// Appends a dependent lib to the appropriate metadata value.1459 void AddDependentLib(StringRef Lib);1460 1461 1462 llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD);1463 1464 void setFunctionLinkage(GlobalDecl GD, llvm::Function *F) {1465 F->setLinkage(getFunctionLinkage(GD));1466 }1467 1468 /// Return the appropriate linkage for the vtable, VTT, and type information1469 /// of the given class.1470 llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD);1471 1472 /// Return the store size, in character units, of the given LLVM type.1473 CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const;1474 1475 /// Returns LLVM linkage for a declarator.1476 llvm::GlobalValue::LinkageTypes1477 getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage);1478 1479 /// Returns LLVM linkage for a declarator.1480 llvm::GlobalValue::LinkageTypes1481 getLLVMLinkageVarDefinition(const VarDecl *VD);1482 1483 /// Emit all the global annotations.1484 void EmitGlobalAnnotations();1485 1486 /// Emit an annotation string.1487 llvm::Constant *EmitAnnotationString(StringRef Str);1488 1489 /// Emit the annotation's translation unit.1490 llvm::Constant *EmitAnnotationUnit(SourceLocation Loc);1491 1492 /// Emit the annotation line number.1493 llvm::Constant *EmitAnnotationLineNo(SourceLocation L);1494 1495 /// Emit additional args of the annotation.1496 llvm::Constant *EmitAnnotationArgs(const AnnotateAttr *Attr);1497 1498 /// Generate the llvm::ConstantStruct which contains the annotation1499 /// information for a given GlobalValue. The annotation struct is1500 /// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the1501 /// GlobalValue being annotated. The second field is the constant string1502 /// created from the AnnotateAttr's annotation. The third field is a constant1503 /// string containing the name of the translation unit. The fourth field is1504 /// the line number in the file of the annotated value declaration.1505 llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV,1506 const AnnotateAttr *AA,1507 SourceLocation L);1508 1509 /// Add global annotations that are set on D, for the global GV. Those1510 /// annotations are emitted during finalization of the LLVM code.1511 void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV);1512 1513 bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn,1514 SourceLocation Loc) const;1515 1516 bool isInNoSanitizeList(SanitizerMask Kind, llvm::GlobalVariable *GV,1517 SourceLocation Loc, QualType Ty,1518 StringRef Category = StringRef()) const;1519 1520 /// Imbue XRay attributes to a function, applying the always/never attribute1521 /// lists in the process. Returns true if we did imbue attributes this way,1522 /// false otherwise.1523 bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,1524 StringRef Category = StringRef()) const;1525 1526 /// \returns true if \p Fn at \p Loc should be excluded from profile1527 /// instrumentation by the SCL passed by \p -fprofile-list.1528 ProfileList::ExclusionType1529 isFunctionBlockedByProfileList(llvm::Function *Fn, SourceLocation Loc) const;1530 1531 /// \returns true if \p Fn at \p Loc should be excluded from profile1532 /// instrumentation.1533 ProfileList::ExclusionType1534 isFunctionBlockedFromProfileInstr(llvm::Function *Fn,1535 SourceLocation Loc) const;1536 1537 SanitizerMetadata *getSanitizerMetadata() {1538 return SanitizerMD.get();1539 }1540 1541 void addDeferredVTable(const CXXRecordDecl *RD) {1542 DeferredVTables.push_back(RD);1543 }1544 1545 /// Emit code for a single global function or var decl. Forward declarations1546 /// are emitted lazily.1547 void EmitGlobal(GlobalDecl D);1548 1549 bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);1550 1551 llvm::GlobalValue *GetGlobalValue(StringRef Ref);1552 1553 /// Set attributes which are common to any form of a global definition (alias,1554 /// Objective-C method, function, global variable).1555 ///1556 /// NOTE: This should only be called for definitions.1557 void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV);1558 1559 void addReplacement(StringRef Name, llvm::Constant *C);1560 1561 void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C);1562 1563 /// Emit a code for threadprivate directive.1564 /// \param D Threadprivate declaration.1565 void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);1566 1567 /// Emit a code for declare reduction construct.1568 void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D,1569 CodeGenFunction *CGF = nullptr);1570 1571 /// Emit a code for declare mapper construct.1572 void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D,1573 CodeGenFunction *CGF = nullptr);1574 1575 // Emit code for the OpenACC Declare declaration.1576 void EmitOpenACCDeclare(const OpenACCDeclareDecl *D,1577 CodeGenFunction *CGF = nullptr);1578 // Emit code for the OpenACC Routine declaration.1579 void EmitOpenACCRoutine(const OpenACCRoutineDecl *D,1580 CodeGenFunction *CGF = nullptr);1581 1582 /// Emit a code for requires directive.1583 /// \param D Requires declaration1584 void EmitOMPRequiresDecl(const OMPRequiresDecl *D);1585 1586 /// Emit a code for the allocate directive.1587 /// \param D The allocate declaration1588 void EmitOMPAllocateDecl(const OMPAllocateDecl *D);1589 1590 /// Return the alignment specified in an allocate directive, if present.1591 std::optional<CharUnits> getOMPAllocateAlignment(const VarDecl *VD);1592 1593 /// Returns whether the given record has hidden LTO visibility and therefore1594 /// may participate in (single-module) CFI and whole-program vtable1595 /// optimization.1596 bool HasHiddenLTOVisibility(const CXXRecordDecl *RD);1597 1598 /// Returns whether the given record has public LTO visibility (regardless of1599 /// -lto-whole-program-visibility) and therefore may not participate in1600 /// (single-module) CFI and whole-program vtable optimization.1601 bool AlwaysHasLTOVisibilityPublic(const CXXRecordDecl *RD);1602 1603 /// Returns the vcall visibility of the given type. This is the scope in which1604 /// a virtual function call could be made which ends up being dispatched to a1605 /// member function of this class. This scope can be wider than the visibility1606 /// of the class itself when the class has a more-visible dynamic base class.1607 /// The client should pass in an empty Visited set, which is used to prevent1608 /// redundant recursive processing.1609 llvm::GlobalObject::VCallVisibility1610 GetVCallVisibilityLevel(const CXXRecordDecl *RD,1611 llvm::DenseSet<const CXXRecordDecl *> &Visited);1612 1613 /// Emit type metadata for the given vtable using the given layout.1614 void EmitVTableTypeMetadata(const CXXRecordDecl *RD,1615 llvm::GlobalVariable *VTable,1616 const VTableLayout &VTLayout);1617 1618 llvm::Type *getVTableComponentType() const;1619 1620 /// Generate a cross-DSO type identifier for MD.1621 llvm::ConstantInt *CreateCrossDsoCfiTypeId(llvm::Metadata *MD);1622 1623 /// Generate a KCFI type identifier for T.1624 llvm::ConstantInt *CreateKCFITypeId(QualType T, StringRef Salt);1625 1626 /// Create a metadata identifier for the given function type.1627 llvm::Metadata *CreateMetadataIdentifierForFnType(QualType T);1628 1629 /// Create a metadata identifier for the given type. This may either be an1630 /// MDString (for external identifiers) or a distinct unnamed MDNode (for1631 /// internal identifiers).1632 llvm::Metadata *CreateMetadataIdentifierForType(QualType T);1633 1634 /// Create a metadata identifier that is intended to be used to check virtual1635 /// calls via a member function pointer.1636 llvm::Metadata *CreateMetadataIdentifierForVirtualMemPtrType(QualType T);1637 1638 /// Create a metadata identifier for the generalization of the given type.1639 /// This may either be an MDString (for external identifiers) or a distinct1640 /// unnamed MDNode (for internal identifiers).1641 llvm::Metadata *CreateMetadataIdentifierGeneralized(QualType T);1642 1643 /// Create and attach type metadata to the given function.1644 void createFunctionTypeMetadataForIcall(const FunctionDecl *FD,1645 llvm::Function *F);1646 1647 /// Create and attach type metadata if the function is a potential indirect1648 /// call target to support call graph section.1649 void createIndirectFunctionTypeMD(const FunctionDecl *FD, llvm::Function *F);1650 1651 /// Create and attach type metadata to the given call.1652 void createCalleeTypeMetadataForIcall(const QualType &QT, llvm::CallBase *CB);1653 1654 /// Set type metadata to the given function.1655 void setKCFIType(const FunctionDecl *FD, llvm::Function *F);1656 1657 /// Emit KCFI type identifier constants and remove unused identifiers.1658 void finalizeKCFITypes();1659 1660 /// Whether this function's return type has no side effects, and thus may1661 /// be trivially discarded if it is unused.1662 bool MayDropFunctionReturn(const ASTContext &Context,1663 QualType ReturnType) const;1664 1665 /// Returns whether this module needs the "all-vtables" type identifier.1666 bool NeedAllVtablesTypeId() const;1667 1668 /// Create and attach type metadata for the given vtable.1669 void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset,1670 const CXXRecordDecl *RD);1671 1672 /// Return a vector of most-base classes for RD. This is used to implement1673 /// control flow integrity checks for member function pointers.1674 ///1675 /// A most-base class of a class C is defined as a recursive base class of C,1676 /// including C itself, that does not have any bases.1677 SmallVector<const CXXRecordDecl *, 0>1678 getMostBaseClasses(const CXXRecordDecl *RD);1679 1680 /// Get the declaration of std::terminate for the platform.1681 llvm::FunctionCallee getTerminateFn();1682 1683 llvm::SanitizerStatReport &getSanStats();1684 1685 llvm::Value *1686 createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF);1687 1688 /// OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument1689 /// information in the program executable. The argument information stored1690 /// includes the argument name, its type, the address and access qualifiers1691 /// used. This helper can be used to generate metadata for source code kernel1692 /// function as well as generated implicitly kernels. If a kernel is generated1693 /// implicitly null value has to be passed to the last two parameters,1694 /// otherwise all parameters must have valid non-null values.1695 /// \param FN is a pointer to IR function being generated.1696 /// \param FD is a pointer to function declaration if any.1697 /// \param CGF is a pointer to CodeGenFunction that generates this function.1698 void GenKernelArgMetadata(llvm::Function *FN,1699 const FunctionDecl *FD = nullptr,1700 CodeGenFunction *CGF = nullptr);1701 1702 /// Get target specific null pointer.1703 /// \param T is the LLVM type of the null pointer.1704 /// \param QT is the clang QualType of the null pointer.1705 llvm::Constant *getNullPointer(llvm::PointerType *T, QualType QT);1706 1707 CharUnits getNaturalTypeAlignment(QualType T,1708 LValueBaseInfo *BaseInfo = nullptr,1709 TBAAAccessInfo *TBAAInfo = nullptr,1710 bool forPointeeType = false);1711 CharUnits getNaturalPointeeTypeAlignment(QualType T,1712 LValueBaseInfo *BaseInfo = nullptr,1713 TBAAAccessInfo *TBAAInfo = nullptr);1714 bool stopAutoInit();1715 1716 /// Print the postfix for externalized static variable or kernels for single1717 /// source offloading languages CUDA and HIP. The unique postfix is created1718 /// using either the CUID argument, or the file's UniqueID and active macros.1719 /// The fallback method without a CUID requires that the offloading toolchain1720 /// does not define separate macros via the -cc1 options.1721 void printPostfixForExternalizedDecl(llvm::raw_ostream &OS,1722 const Decl *D) const;1723 1724 /// Move some lazily-emitted states to the NewBuilder. This is especially1725 /// essential for the incremental parsing environment like Clang Interpreter,1726 /// because we'll lose all important information after each repl.1727 void moveLazyEmissionStates(CodeGenModule *NewBuilder);1728 1729 /// Emit the IR encoding to attach the CUDA launch bounds attribute to \p F.1730 /// If \p MaxThreadsVal is not nullptr, the max threads value is stored in it,1731 /// if a valid one was found.1732 void handleCUDALaunchBoundsAttr(llvm::Function *F,1733 const CUDALaunchBoundsAttr *A,1734 int32_t *MaxThreadsVal = nullptr,1735 int32_t *MinBlocksVal = nullptr,1736 int32_t *MaxClusterRankVal = nullptr);1737 1738 /// Emit the IR encoding to attach the AMD GPU flat-work-group-size attribute1739 /// to \p F. Alternatively, the work group size can be taken from a \p1740 /// ReqdWGS. If \p MinThreadsVal is not nullptr, the min threads value is1741 /// stored in it, if a valid one was found. If \p MaxThreadsVal is not1742 /// nullptr, the max threads value is stored in it, if a valid one was found.1743 void handleAMDGPUFlatWorkGroupSizeAttr(1744 llvm::Function *F, const AMDGPUFlatWorkGroupSizeAttr *A,1745 const ReqdWorkGroupSizeAttr *ReqdWGS = nullptr,1746 int32_t *MinThreadsVal = nullptr, int32_t *MaxThreadsVal = nullptr);1747 1748 /// Emit the IR encoding to attach the AMD GPU waves-per-eu attribute to \p F.1749 void handleAMDGPUWavesPerEUAttr(llvm::Function *F,1750 const AMDGPUWavesPerEUAttr *A);1751 1752 llvm::Constant *1753 GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace,1754 const VarDecl *D,1755 ForDefinition_t IsForDefinition = NotForDefinition);1756 1757 // FIXME: Hardcoding priority here is gross.1758 void AddGlobalCtor(llvm::Function *Ctor, int Priority = 65535,1759 unsigned LexOrder = ~0U,1760 llvm::Constant *AssociatedData = nullptr);1761 void AddGlobalDtor(llvm::Function *Dtor, int Priority = 65535,1762 bool IsDtorAttrFunc = false);1763 1764 // Return whether structured convergence intrinsics should be generated for1765 // this target.1766 bool shouldEmitConvergenceTokens() const {1767 // TODO: this should probably become unconditional once the controlled1768 // convergence becomes the norm.1769 return getTriple().isSPIRVLogical();1770 }1771 1772 void addUndefinedGlobalForTailCall(1773 std::pair<const FunctionDecl *, SourceLocation> Global) {1774 MustTailCallUndefinedGlobals.insert(Global);1775 }1776 1777 bool shouldZeroInitPadding() const {1778 // In C23 (N3096) $6.7.10:1779 // """1780 // If any object is initialized with an empty iniitializer, then it is1781 // subject to default initialization:1782 // - if it is an aggregate, every member is initialized (recursively)1783 // according to these rules, and any padding is initialized to zero bits;1784 // - if it is a union, the first named member is initialized (recursively)1785 // according to these rules, and any padding is initialized to zero bits.1786 //1787 // If the aggregate or union contains elements or members that are1788 // aggregates or unions, these rules apply recursively to the subaggregates1789 // or contained unions.1790 //1791 // If there are fewer initializers in a brace-enclosed list than there are1792 // elements or members of an aggregate, or fewer characters in a string1793 // literal used to initialize an array of known size than there are elements1794 // in the array, the remainder of the aggregate is subject to default1795 // initialization.1796 // """1797 //1798 // From my understanding, the standard is ambiguous in the following two1799 // areas:1800 // 1. For a union type with empty initializer, if the first named member is1801 // not the largest member, then the bytes comes after the first named member1802 // but before padding are left unspecified. An example is:1803 // union U { int a; long long b;};1804 // union U u = {}; // The first 4 bytes are 0, but 4-8 bytes are left1805 // unspecified.1806 //1807 // 2. It only mentions padding for empty initializer, but doesn't mention1808 // padding for a non empty initialization list. And if the aggregation or1809 // union contains elements or members that are aggregates or unions, and1810 // some are non empty initializers, while others are empty initiailizers,1811 // the padding initialization is unclear. An example is:1812 // struct S1 { int a; long long b; };1813 // struct S2 { char c; struct S1 s1; };1814 // // The values for paddings between s2.c and s2.s1.a, between s2.s1.a1815 // and s2.s1.b are unclear.1816 // struct S2 s2 = { 'c' };1817 //1818 // Here we choose to zero initiailize left bytes of a union type. Because1819 // projects like the Linux kernel are relying on this behavior. If we don't1820 // explicitly zero initialize them, the undef values can be optimized to1821 // return gabage data. We also choose to zero initialize paddings for1822 // aggregates and unions, no matter they are initialized by empty1823 // initializers or non empty initializers. This can provide a consistent1824 // behavior. So projects like the Linux kernel can rely on it.1825 return !getLangOpts().CPlusPlus;1826 }1827 1828 // Helper to get the alignment for a variable.1829 unsigned getVtableGlobalVarAlignment(const VarDecl *D = nullptr) {1830 LangAS AS = GetGlobalVarAddressSpace(D);1831 unsigned PAlign = getItaniumVTableContext().isRelativeLayout()1832 ? 321833 : getTarget().getPointerAlign(AS);1834 return PAlign;1835 }1836 1837 /// Helper function to construct a TrapReasonBuilder1838 TrapReasonBuilder BuildTrapReason(unsigned DiagID, TrapReason &TR) {1839 return TrapReasonBuilder(&getDiags(), DiagID, TR);1840 }1841 1842private:1843 bool shouldDropDLLAttribute(const Decl *D, const llvm::GlobalValue *GV) const;1844 1845 llvm::Constant *GetOrCreateLLVMFunction(1846 StringRef MangledName, llvm::Type *Ty, GlobalDecl D, bool ForVTable,1847 bool DontDefer = false, bool IsThunk = false,1848 llvm::AttributeList ExtraAttrs = llvm::AttributeList(),1849 ForDefinition_t IsForDefinition = NotForDefinition);1850 1851 // Adds a declaration to the list of multi version functions if not present.1852 void AddDeferredMultiVersionResolverToEmit(GlobalDecl GD);1853 1854 // References to multiversion functions are resolved through an implicitly1855 // defined resolver function. This function is responsible for creating1856 // the resolver symbol for the provided declaration. The value returned1857 // will be for an ifunc (llvm::GlobalIFunc) if the current target supports1858 // that feature and for a regular function (llvm::GlobalValue) otherwise.1859 llvm::Constant *GetOrCreateMultiVersionResolver(GlobalDecl GD);1860 1861 // Set attributes to a resolver function generated by Clang.1862 // GD is either the cpu_dispatch declaration or an arbitrarily chosen1863 // function declaration that triggered the implicit generation of this1864 // resolver function.1865 //1866 /// NOTE: This should only be called for definitions.1867 void setMultiVersionResolverAttributes(llvm::Function *Resolver,1868 GlobalDecl GD);1869 1870 // In scenarios where a function is not known to be a multiversion function1871 // until a later declaration, it is sometimes necessary to change the1872 // previously created mangled name to align with requirements of whatever1873 // multiversion function kind the function is now known to be. This function1874 // is responsible for performing such mangled name updates.1875 void UpdateMultiVersionNames(GlobalDecl GD, const FunctionDecl *FD,1876 StringRef &CurName);1877 1878 bool GetCPUAndFeaturesAttributes(GlobalDecl GD,1879 llvm::AttrBuilder &AttrBuilder,1880 bool SetTargetFeatures = true);1881 void setNonAliasAttributes(GlobalDecl GD, llvm::GlobalObject *GO);1882 1883 /// Set function attributes for a function declaration.1884 void SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,1885 bool IsIncompleteFunction, bool IsThunk);1886 1887 void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue *GV = nullptr);1888 1889 void EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);1890 void EmitMultiVersionFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);1891 1892 void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false);1893 void EmitAliasDefinition(GlobalDecl GD);1894 void emitIFuncDefinition(GlobalDecl GD);1895 void emitCPUDispatchDefinition(GlobalDecl GD);1896 void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);1897 void EmitObjCIvarInitializations(ObjCImplementationDecl *D);1898 1899 // C++ related functions.1900 1901 void EmitDeclContext(const DeclContext *DC);1902 void EmitLinkageSpec(const LinkageSpecDecl *D);1903 void EmitTopLevelStmt(const TopLevelStmtDecl *D);1904 1905 /// Emit the function that initializes C++ thread_local variables.1906 void EmitCXXThreadLocalInitFunc();1907 1908 /// Emit the function that initializes global variables for a C++ Module.1909 void EmitCXXModuleInitFunc(clang::Module *Primary);1910 1911 /// Emit the function that initializes C++ globals.1912 void EmitCXXGlobalInitFunc();1913 1914 /// Emit the function that performs cleanup associated with C++ globals.1915 void EmitCXXGlobalCleanUpFunc();1916 1917 /// Emit the function that initializes the specified global (if PerformInit is1918 /// true) and registers its destructor.1919 void EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,1920 llvm::GlobalVariable *Addr,1921 bool PerformInit);1922 1923 void EmitPointerToInitFunc(const VarDecl *VD, llvm::GlobalVariable *Addr,1924 llvm::Function *InitFunc, InitSegAttr *ISA);1925 1926 /// EmitCtorList - Generates a global array of functions and priorities using1927 /// the given list and name. This array will have appending linkage and is1928 /// suitable for use as a LLVM constructor or destructor array. Clears Fns.1929 void EmitCtorList(CtorList &Fns, const char *GlobalName);1930 1931 /// Emit any needed decls for which code generation was deferred.1932 void EmitDeferred();1933 1934 /// Try to emit external vtables as available_externally if they have emitted1935 /// all inlined virtual functions. It runs after EmitDeferred() and therefore1936 /// is not allowed to create new references to things that need to be emitted1937 /// lazily.1938 void EmitVTablesOpportunistically();1939 1940 /// Call replaceAllUsesWith on all pairs in Replacements.1941 void applyReplacements();1942 1943 /// Call replaceAllUsesWith on all pairs in GlobalValReplacements.1944 void applyGlobalValReplacements();1945 1946 void checkAliases();1947 1948 std::map<int, llvm::TinyPtrVector<llvm::Function *>> DtorsUsingAtExit;1949 1950 /// Register functions annotated with __attribute__((destructor)) using1951 /// __cxa_atexit, if it is available, or atexit otherwise.1952 void registerGlobalDtorsWithAtExit();1953 1954 // When using sinit and sterm functions, unregister1955 // __attribute__((destructor)) annotated functions which were previously1956 // registered by the atexit subroutine using unatexit.1957 void unregisterGlobalDtorsWithUnAtExit();1958 1959 /// Emit deferred multiversion function resolvers and associated variants.1960 void emitMultiVersionFunctions();1961 1962 /// Emit any vtables which we deferred and still have a use for.1963 void EmitDeferredVTables();1964 1965 /// Emit a dummy function that reference a CoreFoundation symbol when1966 /// @available is used on Darwin.1967 void emitAtAvailableLinkGuard();1968 1969 /// Emit the llvm.used and llvm.compiler.used metadata.1970 void emitLLVMUsed();1971 1972 /// For C++20 Itanium ABI, emit the initializers for the module.1973 void EmitModuleInitializers(clang::Module *Primary);1974 1975 /// Emit the link options introduced by imported modules.1976 void EmitModuleLinkOptions();1977 1978 /// Helper function for EmitStaticExternCAliases() to redirect ifuncs that1979 /// have a resolver name that matches 'Elem' to instead resolve to the name of1980 /// 'CppFunc'. This redirection is necessary in cases where 'Elem' has a name1981 /// that will be emitted as an alias of the name bound to 'CppFunc'; ifuncs1982 /// may not reference aliases. Redirection is only performed if 'Elem' is only1983 /// used by ifuncs in which case, 'Elem' is destroyed. 'true' is returned if1984 /// redirection is successful, and 'false' is returned otherwise.1985 bool CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,1986 llvm::GlobalValue *CppFunc);1987 1988 /// Emit aliases for internal-linkage declarations inside "C" language1989 /// linkage specifications, giving them the "expected" name where possible.1990 void EmitStaticExternCAliases();1991 1992 void EmitDeclMetadata();1993 1994 /// Emit the Clang version as llvm.ident metadata.1995 void EmitVersionIdentMetadata();1996 1997 /// Emit the Clang commandline as llvm.commandline metadata.1998 void EmitCommandLineMetadata();1999 2000 /// Emit the module flag metadata used to pass options controlling the2001 /// the backend to LLVM.2002 void EmitBackendOptionsMetadata(const CodeGenOptions &CodeGenOpts);2003 2004 /// Emits OpenCL specific Metadata e.g. OpenCL version.2005 void EmitOpenCLMetadata();2006 2007 /// Emit the llvm.gcov metadata used to tell LLVM where to emit the .gcno and2008 /// .gcda files in a way that persists in .bc files.2009 void EmitCoverageFile();2010 2011 /// Given a sycl_kernel_entry_point attributed function, emit the2012 /// corresponding SYCL kernel caller offload entry point function.2013 void EmitSYCLKernelCaller(const FunctionDecl *KernelEntryPointFn,2014 ASTContext &Ctx);2015 2016 /// Determine whether the definition must be emitted; if this returns \c2017 /// false, the definition can be emitted lazily if it's used.2018 bool MustBeEmitted(const ValueDecl *D);2019 2020 /// Determine whether the definition can be emitted eagerly, or should be2021 /// delayed until the end of the translation unit. This is relevant for2022 /// definitions whose linkage can change, e.g. implicit function instantions2023 /// which may later be explicitly instantiated.2024 bool MayBeEmittedEagerly(const ValueDecl *D);2025 2026 /// Check whether we can use a "simpler", more core exceptions personality2027 /// function.2028 void SimplifyPersonality();2029 2030 /// Helper function for getDefaultFunctionAttributes. Builds a set of function2031 /// attributes which can be simply added to a function.2032 void getTrivialDefaultFunctionAttributes(StringRef Name, bool HasOptnone,2033 bool AttrOnCallSite,2034 llvm::AttrBuilder &FuncAttrs);2035 2036 /// Helper function for ConstructAttributeList and2037 /// addDefaultFunctionDefinitionAttributes. Builds a set of function2038 /// attributes to add to a function with the given properties.2039 void getDefaultFunctionAttributes(StringRef Name, bool HasOptnone,2040 bool AttrOnCallSite,2041 llvm::AttrBuilder &FuncAttrs);2042 2043 llvm::Metadata *CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map,2044 StringRef Suffix);2045};2046 2047} // end namespace CodeGen2048} // end namespace clang2049 2050#endif // LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H2051