//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This coordinates the per-module state used while generating code. // //===----------------------------------------------------------------------===// #include "CodeGenModule.h" #include "ABIInfo.h" #include "CGBlocks.h" #include "CGCUDARuntime.h" #include "CGCXXABI.h" #include "CGCall.h" #include "CGDebugInfo.h" #include "CGHLSLRuntime.h" #include "CGObjCRuntime.h" #include "CGOpenCLRuntime.h" #include "CGOpenMPRuntime.h" #include "CGOpenMPRuntimeGPU.h" #include "CodeGenFunction.h" #include "CodeGenPGO.h" #include "ConstantEmitter.h" #include "CoverageMappingGen.h" #include "TargetInfo.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTLambda.h" #include "clang/AST/CharUnits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Mangle.h" #include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/StmtVisitor.h" #include "clang/Basic/Builtins.h" #include "clang/Basic/CharInfo.h" #include "clang/Basic/CodeGenOptions.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/Module.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/Version.h" #include "clang/CodeGen/BackendUtil.h" #include "clang/CodeGen/ConstantInitBuilder.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/BinaryFormat/ELF.h" #include "llvm/Frontend/OpenMP/OMPIRBuilder.h" #include "llvm/IR/AttributeMask.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/IR/ProfileSummary.h" #include "llvm/ProfileData/InstrProfReader.h" #include "llvm/ProfileData/SampleProf.h" #include "llvm/Support/CRC.h" #include "llvm/Support/CodeGen.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/TimeProfiler.h" #include "llvm/Support/xxhash.h" #include "llvm/TargetParser/RISCVISAInfo.h" #include "llvm/TargetParser/Triple.h" #include "llvm/TargetParser/X86TargetParser.h" #include "llvm/Transforms/Utils/BuildLibCalls.h" #include <optional> usingnamespaceclang; usingnamespaceCodeGen; static llvm::cl::opt<bool> LimitedCoverage( "limited-coverage-experimental", llvm::cl::Hidden, llvm::cl::desc("Emit limited coverage mapping information (experimental)")); static const char AnnotationSection[] = …; static CGCXXABI *createCXXABI(CodeGenModule &CGM) { … } static std::unique_ptr<TargetCodeGenInfo> createTargetCodeGenInfo(CodeGenModule &CGM) { … } const TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() { … } CodeGenModule::CodeGenModule(ASTContext &C, IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS, const HeaderSearchOptions &HSO, const PreprocessorOptions &PPO, const CodeGenOptions &CGO, llvm::Module &M, DiagnosticsEngine &diags, CoverageSourceInfo *CoverageInfo) : … { … } CodeGenModule::~CodeGenModule() { … } void CodeGenModule::createObjCRuntime() { … } void CodeGenModule::createOpenCLRuntime() { … } void CodeGenModule::createOpenMPRuntime() { … } void CodeGenModule::createCUDARuntime() { … } void CodeGenModule::createHLSLRuntime() { … } void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) { … } void CodeGenModule::applyReplacements() { … } void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) { … } void CodeGenModule::applyGlobalValReplacements() { … } // This is only used in aliases that we created and we know they have a // linear structure. static const llvm::GlobalValue *getAliasedGlobal(const llvm::GlobalValue *GV) { … } static bool checkAliasedGlobal( const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) { … } // Emit a warning if toc-data attribute is requested for global variables that // have aliases and remove the toc-data attribute. static void checkAliasForTocData(llvm::GlobalVariable *GVar, const CodeGenOptions &CodeGenOpts, DiagnosticsEngine &Diags, SourceLocation Location) { … } void CodeGenModule::checkAliases() { … } void CodeGenModule::clear() { … } void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile) { … } static std::optional<llvm::GlobalValue::VisibilityTypes> getLLVMVisibility(clang::LangOptions::VisibilityFromDLLStorageClassKinds K) { … } void setLLVMVisibility(llvm::GlobalValue &GV, std::optional<llvm::GlobalValue::VisibilityTypes> V) { … } static void setVisibilityFromDLLStorageClass(const clang::LangOptions &LO, llvm::Module &M) { … } static bool isStackProtectorOn(const LangOptions &LangOpts, const llvm::Triple &Triple, clang::LangOptions::StackProtectorMode Mode) { … } void CodeGenModule::Release() { … } void CodeGenModule::EmitOpenCLMetadata() { … } void CodeGenModule::EmitBackendOptionsMetadata( const CodeGenOptions &CodeGenOpts) { … } void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { … } void CodeGenModule::RefreshTypeCacheForClass(const CXXRecordDecl *RD) { … } llvm::MDNode *CodeGenModule::getTBAATypeInfo(QualType QTy) { … } TBAAAccessInfo CodeGenModule::getTBAAAccessInfo(QualType AccessType) { … } TBAAAccessInfo CodeGenModule::getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType) { … } llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { … } llvm::MDNode *CodeGenModule::getTBAABaseTypeInfo(QualType QTy) { … } llvm::MDNode *CodeGenModule::getTBAAAccessTagInfo(TBAAAccessInfo Info) { … } TBAAAccessInfo CodeGenModule::mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo) { … } TBAAAccessInfo CodeGenModule::mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB) { … } TBAAAccessInfo CodeGenModule::mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, TBAAAccessInfo SrcInfo) { … } void CodeGenModule::DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo) { … } void CodeGenModule::DecorateInstructionWithInvariantGroup( llvm::Instruction *I, const CXXRecordDecl *RD) { … } void CodeGenModule::Error(SourceLocation loc, StringRef message) { … } /// ErrorUnsupported - Print out an error that codegen doesn't support the /// specified stmt yet. void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) { … } /// ErrorUnsupported - Print out an error that codegen doesn't support the /// specified decl yet. void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) { … } llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { … } void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const { … } static bool shouldAssumeDSOLocal(const CodeGenModule &CGM, llvm::GlobalValue *GV) { … } void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const { … } void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl GD) const { … } void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV, const NamedDecl *D) const { … } void CodeGenModule::setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const { … } void CodeGenModule::setGVProperties(llvm::GlobalValue *GV, const NamedDecl *D) const { … } void CodeGenModule::setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const { … } static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) { … } llvm::GlobalVariable::ThreadLocalMode CodeGenModule::GetDefaultLLVMTLSModel() const { … } void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const { … } static std::string getCPUSpecificMangling(const CodeGenModule &CGM, StringRef Name) { … } static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM, const CPUSpecificAttr *Attr, unsigned CPUIndex, raw_ostream &Out) { … } // Returns true if GD is a function decl with internal linkage and // needs a unique suffix after the mangled name. static bool isUniqueInternalLinkageDecl(GlobalDecl GD, CodeGenModule &CGM) { … } static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD, const NamedDecl *ND, bool OmitMultiVersionMangling = false) { … } void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD, const FunctionDecl *FD, StringRef &CurName) { … } StringRef CodeGenModule::getMangledName(GlobalDecl GD) { … } StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD, const BlockDecl *BD) { … } const GlobalDecl CodeGenModule::getMangledNameDecl(StringRef Name) { … } llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { … } /// AddGlobalCtor - Add a function to the list that will be called before /// main() runs. void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority, unsigned LexOrder, llvm::Constant *AssociatedData) { … } /// AddGlobalDtor - Add a function to the list that will be called /// when the module is unloaded. void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority, bool IsDtorAttrFunc) { … } void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) { … } llvm::GlobalValue::LinkageTypes CodeGenModule::getFunctionLinkage(GlobalDecl GD) { … } llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) { … } llvm::ConstantInt *CodeGenModule::CreateKCFITypeId(QualType T) { … } void CodeGenModule::SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk) { … } static void removeImageAccessQualifier(std::string& TyName) { … } // Returns the address space id that should be produced to the // kernel_arg_addr_space metadata. This is always fixed to the ids // as specified in the SPIR 2.0 specification in order to differentiate // for example in clGetKernelArgInfo() implementation between the address // spaces with targets without unique mapping to the OpenCL address spaces // (basically all single AS CPUs). static unsigned ArgInfoAddressSpace(LangAS AS) { … } void CodeGenModule::GenKernelArgMetadata(llvm::Function *Fn, const FunctionDecl *FD, CodeGenFunction *CGF) { … } /// Determines whether the language options require us to model /// unwind exceptions. We treat -fexceptions as mandating this /// except under the fragile ObjC ABI with only ObjC exceptions /// enabled. This means, for example, that C with -fexceptions /// enables this. static bool hasUnwindExceptions(const LangOptions &LangOpts) { … } static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM, const CXXMethodDecl *MD) { … } SmallVector<const CXXRecordDecl *, 0> CodeGenModule::getMostBaseClasses(const CXXRecordDecl *RD) { … } void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F) { … } void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) { … } bool CodeGenModule::GetCPUAndFeaturesAttributes(GlobalDecl GD, llvm::AttrBuilder &Attrs, bool SetTargetFeatures) { … } void CodeGenModule::setNonAliasAttributes(GlobalDecl GD, llvm::GlobalObject *GO) { … } void CodeGenModule::SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI) { … } static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) { … } void CodeGenModule::CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD, llvm::Function *F) { … } void CodeGenModule::setKCFIType(const FunctionDecl *FD, llvm::Function *F) { … } static bool allowKCFIIdentifier(StringRef Name) { … } void CodeGenModule::finalizeKCFITypes() { … } void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F, bool IsIncompleteFunction, bool IsThunk) { … } void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) { … } void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) { … } void CodeGenModule::addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV) { … } static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector<llvm::WeakTrackingVH> &List) { … } void CodeGenModule::emitLLVMUsed() { … } void CodeGenModule::AppendLinkerOptions(StringRef Opts) { … } void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) { … } void CodeGenModule::AddDependentLib(StringRef Lib) { … } /// Add link options implied by the given module, including modules /// it depends on, using a postorder walk. static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl<llvm::MDNode *> &Metadata, llvm::SmallPtrSet<Module *, 16> &Visited) { … } void CodeGenModule::EmitModuleInitializers(clang::Module *Primary) { … } void CodeGenModule::EmitModuleLinkOptions() { … } void CodeGenModule::EmitDeferred() { … } void CodeGenModule::EmitVTablesOpportunistically() { … } void CodeGenModule::EmitGlobalAnnotations() { … } llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) { … } llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { … } llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { … } llvm::Constant *CodeGenModule::EmitAnnotationArgs(const AnnotateAttr *Attr) { … } llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, const AnnotateAttr *AA, SourceLocation L) { … } void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV) { … } bool CodeGenModule::isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const { … } bool CodeGenModule::isInNoSanitizeList(SanitizerMask Kind, llvm::GlobalVariable *GV, SourceLocation Loc, QualType Ty, StringRef Category) const { … } bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category) const { … } ProfileList::ExclusionType CodeGenModule::isFunctionBlockedByProfileList(llvm::Function *Fn, SourceLocation Loc) const { … } ProfileList::ExclusionType CodeGenModule::isFunctionBlockedFromProfileInstr(llvm::Function *Fn, SourceLocation Loc) const { … } bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) { … } bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) { … } ConstantAddress CodeGenModule::GetAddrOfMSGuidDecl(const MSGuidDecl *GD) { … } ConstantAddress CodeGenModule::GetAddrOfUnnamedGlobalConstantDecl( const UnnamedGlobalConstantDecl *GCD) { … } ConstantAddress CodeGenModule::GetAddrOfTemplateParamObject( const TemplateParamObjectDecl *TPO) { … } ConstantAddress CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { … } template <typename AttrT> static bool hasImplicitAttr(const ValueDecl *D) { … } bool CodeGenModule::shouldEmitCUDAGlobalVar(const VarDecl *Global) const { … } void CodeGenModule::EmitGlobal(GlobalDecl GD) { … } // Check if T is a class type with a destructor that's not dllimport. static bool HasNonDllImportDtor(QualType T) { … } namespace { struct FunctionIsDirectlyRecursive : public ConstStmtVisitor<FunctionIsDirectlyRecursive, bool> { … }; // Make sure we're not referencing non-imported vars or functions. struct DLLImportFunctionVisitor : public RecursiveASTVisitor<DLLImportFunctionVisitor> { … }; } // isTriviallyRecursive - Check if this function calls another // decl that, because of the asm attribute or the other decl being a builtin, // ends up pointing to itself. bool CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) { … } bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) { … } bool CodeGenModule::shouldOpportunisticallyEmitVTables() { … } void CodeGenModule::EmitMultiVersionFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { … } void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { … } static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, llvm::Function *NewFn); static unsigned TargetMVPriority(const TargetInfo &TI, const CodeGenFunction::MultiVersionResolverOption &RO) { … } // Multiversion functions should be at most 'WeakODRLinkage' so that a different // TU can forward declare the function without causing problems. Particularly // in the cases of CPUDispatch, this causes issues. This also makes sure we // work with internal linkage functions, so that the same function name can be // used with internal linkage in multiple TUs. llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM, GlobalDecl GD) { … } void CodeGenModule::emitMultiVersionFunctions() { … } static void replaceDeclarationWith(llvm::GlobalValue *Old, llvm::Constant *New) { … } void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) { … } /// Adds a declaration to the list of multi version functions if not present. void CodeGenModule::AddDeferredMultiVersionResolverToEmit(GlobalDecl GD) { … } /// If a dispatcher for the specified mangled name is not in the module, create /// and return it. The dispatcher is either an llvm Function with the specified /// type, or a global ifunc. llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(GlobalDecl GD) { … } bool CodeGenModule::shouldDropDLLAttribute(const Decl *D, const llvm::GlobalValue *GV) const { … } /// GetOrCreateLLVMFunction - If the specified mangled name is not in the /// module, create and return an llvm Function with the specified type. If there /// is something in the module with the specified name, return it potentially /// bitcasted to the right type. /// /// If D is non-null, it specifies a decl that correspond to this. This is used /// to set the attributes on the function when it is first created. llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction( StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable, bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs, ForDefinition_t IsForDefinition) { … } /// GetAddrOfFunction - Return the address of the given function. If Ty is /// non-null, then this function will use the specified type if it has to /// create it (this occurs when we see a definition of the function). llvm::Constant * CodeGenModule::GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty, bool ForVTable, bool DontDefer, ForDefinition_t IsForDefinition) { … } llvm::Constant *CodeGenModule::GetFunctionStart(const ValueDecl *Decl) { … } static const FunctionDecl * GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) { … } /// CreateRuntimeFunction - Create a new runtime function with the specified /// type and name. llvm::FunctionCallee CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name, llvm::AttributeList ExtraAttrs, bool Local, bool AssumeConvergent) { … } /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, /// create and return an llvm GlobalVariable with the specified type and address /// space. If there is something in the module with the specified name, return /// it potentially bitcasted to the right type. /// /// If D is non-null, it specifies a decl that correspond to this. This is used /// to set the attributes on the global when it is first created. /// /// If IsForDefinition is true, it is guaranteed that an actual global with /// type Ty will be returned, not conversion of a variable with the same /// mangled name but some other type. llvm::Constant * CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace, const VarDecl *D, ForDefinition_t IsForDefinition) { … } llvm::Constant * CodeGenModule::GetAddrOfGlobal(GlobalDecl GD, ForDefinition_t IsForDefinition) { … } llvm::GlobalVariable *CodeGenModule::CreateOrReplaceCXXRuntimeVariable( StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment) { … } /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the /// given global variable. If Ty is non-null and if the global doesn't exist, /// then it will be created with the specified type instead of whatever the /// normal requested type would be. If IsForDefinition is true, it is guaranteed /// that an actual global with type Ty will be returned, not conversion of a /// variable with the same mangled name but some other type. llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty, ForDefinition_t IsForDefinition) { … } /// CreateRuntimeVariable - Create a new runtime global variable with the /// specified type and name. llvm::Constant * CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, StringRef Name) { … } void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { … } void CodeGenModule::EmitExternalDeclaration(const DeclaratorDecl *D) { … } CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { … } LangAS CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D) { … } LangAS CodeGenModule::GetGlobalConstantAddressSpace() const { … } // In address space agnostic languages, string literals are in default address // space in AST. However, certain targets (e.g. amdgcn) request them to be // emitted in constant address space in LLVM IR. To be consistent with other // parts of AST, string literal global variables in constant address space // need to be casted to default address space before being put into address // map and referenced by other part of CodeGen. // In OpenCL, string literals are in constant address space in AST, therefore // they should not be casted to default address space. static llvm::Constant * castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM, llvm::GlobalVariable *GV) { … } template<typename SomeDecl> void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV) { … } static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) { … } bool CodeGenModule::supportsCOMDAT() const { … } void CodeGenModule::maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO) { … } const ABIInfo &CodeGenModule::getABIInfo() { … } /// Pass IsTentative as true if you want to create a tentative definition. void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative) { … } void CodeGenModule::EmitExternalVarDeclaration(const VarDecl *D) { … } void CodeGenModule::EmitExternalFunctionDeclaration(const FunctionDecl *FD) { … } static bool isVarDeclStrongDefinition(const ASTContext &Context, CodeGenModule &CGM, const VarDecl *D, bool NoCommon) { … } llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage) { … } llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(const VarDecl *VD) { … } /// Replace the uses of a function that was declared with a non-proto type. /// We want to silently drop extra arguments from call sites static void replaceUsesOfNonProtoConstant(llvm::Constant *old, llvm::Function *newFn) { … } /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we /// implement a function with no prototype, e.g. "int foo() {}". If there are /// existing call uses of the old function in the module, this adjusts them to /// call the new function directly. /// /// This is not just a cleanup: the always_inline pass requires direct calls to /// functions to be able to inline them. If there is a bitcast in the way, it /// won't inline them. Instcombine normally deletes these calls, but it isn't /// run at -O0. static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, llvm::Function *NewFn) { … } void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { … } void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { … } void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { … } void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) { … } llvm::Function *CodeGenModule::getIntrinsic(unsigned IID, ArrayRef<llvm::Type*> Tys) { … } static llvm::StringMapEntry<llvm::GlobalVariable *> & GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map, const StringLiteral *Literal, bool TargetIsLSB, bool &IsUTF16, unsigned &StringLength) { … } ConstantAddress CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { … } bool CodeGenModule::getExpressionLocationsEnabled() const { … } QualType CodeGenModule::getObjCFastEnumerationStateType() { … } llvm::Constant * CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { … } static llvm::GlobalVariable * GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, CodeGenModule &CGM, StringRef GlobalName, CharUnits Alignment) { … } /// GetAddrOfConstantStringFromLiteral - Return a pointer to a /// constant array for the given string literal. ConstantAddress CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name) { … } /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant /// array for the given ObjCEncodeExpr node. ConstantAddress CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { … } /// GetAddrOfConstantCString - Returns a pointer to a character array containing /// the literal and a terminating '\0' character. /// The result has pointer to array type. ConstantAddress CodeGenModule::GetAddrOfConstantCString( const std::string &Str, const char *GlobalName) { … } ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary( const MaterializeTemporaryExpr *E, const Expr *Init) { … } /// EmitObjCPropertyImplementations - Emit information for synthesized /// properties for an implementation. void CodeGenModule::EmitObjCPropertyImplementations(const ObjCImplementationDecl *D) { … } static bool needsDestructMethod(ObjCImplementationDecl *impl) { … } static bool AllTrivialInitializers(CodeGenModule &CGM, ObjCImplementationDecl *D) { … } /// EmitObjCIvarInitializations - Emit information for ivar initialization /// for an implementation. void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { … } // EmitLinkageSpec - Emit all declarations in a linkage spec. void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { … } void CodeGenModule::EmitTopLevelStmt(const TopLevelStmtDecl *D) { … } void CodeGenModule::EmitDeclContext(const DeclContext *DC) { … } /// EmitTopLevelDecl - Emit code for a single top level declaration. void CodeGenModule::EmitTopLevelDecl(Decl *D) { … } void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) { … } void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) { … } void CodeGenModule::EmitDeferredUnusedCoverageMappings() { … } void CodeGenModule::EmitMainVoidAlias() { … } /// Turns the given pointer into a constant. static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, const void *Ptr) { … } static void EmitGlobalDeclMetadata(CodeGenModule &CGM, llvm::NamedMDNode *&GlobalMetadata, GlobalDecl D, llvm::GlobalValue *Addr) { … } bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem, llvm::GlobalValue *CppFunc) { … } /// For each function which is declared within an extern "C" region and marked /// as 'used', but has internal linkage, create an alias from the unmangled /// name to the mangled name if possible. People expect to be able to refer /// to such functions with an unmangled name from inline assembly within the /// same translation unit. void CodeGenModule::EmitStaticExternCAliases() { … } bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName, GlobalDecl &Result) const { … } /// Emits metadata nodes associating all the global values in the /// current module with the Decls they came from. This is useful for /// projects using IR gen as a subroutine. /// /// Since there's currently no way to associate an MDNode directly /// with an llvm::GlobalValue, we create a global named metadata /// with the name 'clang.global.decl.ptrs'. void CodeGenModule::EmitDeclMetadata() { … } /// Emits metadata nodes for all the local variables in the current /// function. void CodeGenFunction::EmitDeclMetadata() { … } void CodeGenModule::EmitVersionIdentMetadata() { … } void CodeGenModule::EmitCommandLineMetadata() { … } void CodeGenModule::EmitCoverageFile() { … } llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH) { … } void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { … } llvm::Metadata * CodeGenModule::CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map, StringRef Suffix) { … } llvm::Metadata *CodeGenModule::CreateMetadataIdentifierForType(QualType T) { … } llvm::Metadata * CodeGenModule::CreateMetadataIdentifierForVirtualMemPtrType(QualType T) { … } // Generalize pointer types to a void pointer with the qualifiers of the // originally pointed-to type, e.g. 'const char *' and 'char * const *' // generalize to 'const void *' while 'char *' and 'const char **' generalize to // 'void *'. static QualType GeneralizeType(ASTContext &Ctx, QualType Ty) { … } // Apply type generalization to a FunctionType's return and argument types static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty) { … } llvm::Metadata *CodeGenModule::CreateMetadataIdentifierGeneralized(QualType T) { … } /// Returns whether this module needs the "all-vtables" type identifier. bool CodeGenModule::NeedAllVtablesTypeId() const { … } void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD) { … } llvm::SanitizerStatReport &CodeGenModule::getSanStats() { … } llvm::Value * CodeGenModule::createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF) { … } CharUnits CodeGenModule::getNaturalPointeeTypeAlignment( QualType T, LValueBaseInfo *BaseInfo, TBAAAccessInfo *TBAAInfo) { … } CharUnits CodeGenModule::getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo, TBAAAccessInfo *TBAAInfo, bool forPointeeType) { … } bool CodeGenModule::stopAutoInit() { … } void CodeGenModule::printPostfixForExternalizedDecl(llvm::raw_ostream &OS, const Decl *D) const { … } void CodeGenModule::moveLazyEmissionStates(CodeGenModule *NewBuilder) { … }
Codebase Browser
llvm