//===--- CGDebugInfo.cpp - Emit Debug Information 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 debug information generation while generating code. // //===----------------------------------------------------------------------===// #include "CGDebugInfo.h" #include "CGBlocks.h" #include "CGCXXABI.h" #include "CGObjCRuntime.h" #include "CGRecordLayout.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "ConstantEmitter.h" #include "TargetInfo.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/RecordLayout.h" #include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/VTableBuilder.h" #include "clang/Basic/CodeGenOptions.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/Version.h" #include "clang/CodeGen/ModuleBuilder.h" #include "clang/Frontend/FrontendOptions.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/ModuleMap.h" #include "clang/Lex/PreprocessorOptions.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Module.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MD5.h" #include "llvm/Support/Path.h" #include "llvm/Support/SHA1.h" #include "llvm/Support/SHA256.h" #include "llvm/Support/TimeProfiler.h" #include <optional> usingnamespaceclang; usingnamespaceclang::CodeGen; static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) { … } static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) { … } static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) { … } /// Returns true if \ref VD is a a holding variable (aka a /// VarDecl retrieved using \ref BindingDecl::getHoldingVar). static bool IsDecomposedVarDecl(VarDecl const *VD) { … } /// Returns true if \ref VD is a compiler-generated variable /// and should be treated as artificial for the purposes /// of debug-info generation. static bool IsArtificial(VarDecl const *VD) { … } CGDebugInfo::CGDebugInfo(CodeGenModule &CGM) : … { … } CGDebugInfo::~CGDebugInfo() { … } ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, SourceLocation TemporaryLocation) : … { … } ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, bool DefaultToEmpty, SourceLocation TemporaryLocation) : … { … } void ApplyDebugLocation::init(SourceLocation TemporaryLocation, bool DefaultToEmpty) { … } ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E) : … { … } ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc) : … { … } ApplyDebugLocation::~ApplyDebugLocation() { … } ApplyInlineDebugLocation::ApplyInlineDebugLocation(CodeGenFunction &CGF, GlobalDecl InlinedFn) : … { … } ApplyInlineDebugLocation::~ApplyInlineDebugLocation() { … } void CGDebugInfo::setLocation(SourceLocation Loc) { … } llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) { … } llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context, llvm::DIScope *Default) { … } PrintingPolicy CGDebugInfo::getPrintingPolicy() const { … } StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) { … } StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) { … } StringRef CGDebugInfo::getSelectorName(Selector S) { … } StringRef CGDebugInfo::getClassName(const RecordDecl *RD) { … } std::optional<llvm::DIFile::ChecksumKind> CGDebugInfo::computeChecksum(FileID FID, SmallString<64> &Checksum) const { … } std::optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM, FileID FID) { … } llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) { … } llvm::DIFile *CGDebugInfo::createFile( StringRef FileName, std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo, std::optional<StringRef> Source) { … } std::string CGDebugInfo::remapDIPath(StringRef Path) const { … } unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) { … } unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) { … } StringRef CGDebugInfo::getCurrentDirname() { … } void CGDebugInfo::CreateCompileUnit() { … } llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) { … } llvm::DIType *CGDebugInfo::CreateType(const BitIntType *Ty) { … } llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) { … } static void stripUnusedQualifiers(Qualifiers &Q) { … } static llvm::dwarf::Tag getNextQualifier(Qualifiers &Q) { … } llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateQualifiedType(const FunctionProtoType *F, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty, llvm::DIFile *Unit) { … } /// \return whether a C++ mangling exists for the type defined by TD. static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) { … } // Determines if the debug info for this tag declaration needs a type // identifier. The purpose of the unique identifier is to deduplicate type // information for identical types across TUs. Because of the C++ one definition // rule (ODR), it is valid to assume that the type is defined the same way in // every TU and its debug info is equivalent. // // C does not have the ODR, and it is common for codebases to contain multiple // different definitions of a struct with the same name in different TUs. // Therefore, if the type doesn't have a C++ mangling, don't give it an // identifer. Type information in C is smaller and simpler than C++ type // information, so the increase in debug info size is negligible. // // If the type is not externally visible, it should be unique to the current TU, // and should not need an identifier to participate in type deduplication. // However, when emitting CodeView, the format internally uses these // unique type name identifers for references between debug info. For example, // the method of a class in an anonymous namespace uses the identifer to refer // to its parent class. The Microsoft C++ ABI attempts to provide unique names // for such types, so when emitting CodeView, always use identifiers for C++ // types. This may create problems when attempting to emit CodeView when the MS // C++ ABI is not in use. static bool needsTypeIdentifier(const TagDecl *TD, CodeGenModule &CGM, llvm::DICompileUnit *TheCU) { … } // Returns a unique type identifier string if one exists, or an empty string. static SmallString<256> getTypeIdentifier(const TagType *Ty, CodeGenModule &CGM, llvm::DICompileUnit *TheCU) { … } /// \return the appropriate DWARF tag for a composite type. static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) { … } llvm::DICompositeType * CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty, llvm::DIScope *Ctx) { … } llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag, const Type *Ty, QualType PointeeTy, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name, llvm::DIType *&Cache) { … } uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer( const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy, unsigned LineNo, SmallVectorImpl<llvm::Metadata *> &EltTys) { … } llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty, llvm::DIFile *Unit) { … } static llvm::SmallVector<TemplateArgument> GetTemplateArgs(const TemplateDecl *TD, const TemplateSpecializationType *Ty) { … } llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty, llvm::DIFile *Unit) { … } /// Convert an AccessSpecifier into the corresponding DINode flag. /// As an optimization, return 0 if the access specifier equals the /// default for the containing type. static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access, const RecordDecl *RD) { … } llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty, llvm::DIFile *Unit) { … } static unsigned getDwarfCC(CallingConv CC) { … } static llvm::DINode::DIFlags getRefFlags(const FunctionProtoType *Func) { … } llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty, llvm::DIFile *Unit) { … } llvm::DIDerivedType * CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl, llvm::DIScope *RecordTy, const RecordDecl *RD) { … } llvm::DIDerivedType *CGDebugInfo::createBitFieldSeparatorIfNeeded( const FieldDecl *BitFieldDecl, const llvm::DIDerivedType *BitFieldDI, llvm::ArrayRef<llvm::Metadata *> PreviousFieldsDI, const RecordDecl *RD) { … } llvm::DIType *CGDebugInfo::createFieldType( StringRef name, QualType type, SourceLocation loc, AccessSpecifier AS, uint64_t offsetInBits, uint32_t AlignInBits, llvm::DIFile *tunit, llvm::DIScope *scope, const RecordDecl *RD, llvm::DINodeArray Annotations) { … } llvm::DISubprogram * CGDebugInfo::createInlinedTrapSubprogram(StringRef FuncName, llvm::DIFile *FileScope) { … } void CGDebugInfo::CollectRecordLambdaFields( const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy) { … } llvm::DIDerivedType * CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy, const RecordDecl *RD) { … } void CGDebugInfo::CollectRecordNormalField( const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit, SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy, const RecordDecl *RD) { … } void CGDebugInfo::CollectRecordNestedType( const TypeDecl *TD, SmallVectorImpl<llvm::Metadata *> &elements) { … } void CGDebugInfo::CollectRecordFields( const RecordDecl *record, llvm::DIFile *tunit, SmallVectorImpl<llvm::Metadata *> &elements, llvm::DICompositeType *RecordTy) { … } llvm::DISubroutineType * CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method, llvm::DIFile *Unit) { … } llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType( QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) { … } /// isFunctionLocalClass - Return true if CXXRecordDecl is defined /// inside a function. static bool isFunctionLocalClass(const CXXRecordDecl *RD) { … } llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction( const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) { … } void CGDebugInfo::CollectCXXMemberFunctions( const CXXRecordDecl *RD, llvm::DIFile *Unit, SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) { … } void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit, SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) { … } void CGDebugInfo::CollectCXXBasesAux( const CXXRecordDecl *RD, llvm::DIFile *Unit, SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy, const CXXRecordDecl::base_class_const_range &Bases, llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes, llvm::DINode::DIFlags StartingFlags) { … } llvm::DINodeArray CGDebugInfo::CollectTemplateParams(std::optional<TemplateArgs> OArgs, llvm::DIFile *Unit) { … } std::optional<CGDebugInfo::TemplateArgs> CGDebugInfo::GetTemplateArgs(const FunctionDecl *FD) const { … } std::optional<CGDebugInfo::TemplateArgs> CGDebugInfo::GetTemplateArgs(const VarDecl *VD) const { … } std::optional<CGDebugInfo::TemplateArgs> CGDebugInfo::GetTemplateArgs(const RecordDecl *RD) const { … } llvm::DINodeArray CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD, llvm::DIFile *Unit) { … } llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(const VarDecl *VL, llvm::DIFile *Unit) { … } llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(const RecordDecl *RD, llvm::DIFile *Unit) { … } llvm::DINodeArray CGDebugInfo::CollectBTFDeclTagAnnotations(const Decl *D) { … } llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) { … } StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) { … } StringRef CGDebugInfo::getDynamicInitializerName(const VarDecl *VD, DynamicInitKind StubKind, llvm::Function *InitFn) { … } void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit, SmallVectorImpl<llvm::Metadata *> &EltTys) { … } llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy, SourceLocation Loc) { … } llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D, SourceLocation Loc) { … } llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D, SourceLocation Loc) { … } void CGDebugInfo::addHeapAllocSiteMetadata(llvm::CallBase *CI, QualType AllocatedTy, SourceLocation Loc) { … } void CGDebugInfo::completeType(const EnumDecl *ED) { … } void CGDebugInfo::completeType(const RecordDecl *RD) { … } /// Return true if the class or any of its methods are marked dllimport. static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD) { … } /// Does a type definition exist in an imported clang module? static bool isDefinedInClangModule(const RecordDecl *RD) { … } void CGDebugInfo::completeClassData(const RecordDecl *RD) { … } void CGDebugInfo::completeClass(const RecordDecl *RD) { … } static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I, CXXRecordDecl::method_iterator End) { … } static bool canUseCtorHoming(const CXXRecordDecl *RD) { … } static bool shouldOmitDefinition(llvm::codegenoptions::DebugInfoKind DebugKind, bool DebugTypeExtRefs, const RecordDecl *RD, const LangOptions &LangOpts) { … } void CGDebugInfo::completeRequiredType(const RecordDecl *RD) { … } llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) { … } llvm::DIType *CGDebugInfo::GetPreferredNameType(const CXXRecordDecl *RD, llvm::DIFile *Unit) { … } std::pair<llvm::DIType *, llvm::DIType *> CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) { … } llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty, llvm::DIFile *Unit) { … } /// \return true if Getter has the default name for the property PD. static bool hasDefaultGetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Getter) { … } /// \return true if Setter has the default name for the property PD. static bool hasDefaultSetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Setter) { … } llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, llvm::DIFile *Unit) { … } llvm::DIModule *CGDebugInfo::getOrCreateModuleRef(ASTSourceDescriptor Mod, bool CreateSkeletonCU) { … } llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const ConstantMatrixType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty, llvm::DIFile *Unit) { … } llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty, llvm::DIFile *U) { … } llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) { … } llvm::DIType *CGDebugInfo::CreateType(const PipeType *Ty, llvm::DIFile *U) { … } llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) { … } llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) { … } llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent, unsigned MType, SourceLocation LineLoc, StringRef Name, StringRef Value) { … } llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent, SourceLocation LineLoc, SourceLocation FileLoc) { … } llvm::DILocation *CGDebugInfo::CreateTrapFailureMessageFor( llvm::DebugLoc TrapLocation, StringRef Category, StringRef FailureMsg) { … } static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) { … } llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) { … } void CGDebugInfo::completeTemplateDefinition( const ClassTemplateSpecializationDecl &SD) { … } void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) { … } llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) { … } llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) { … } llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) { … } llvm::DICompositeType * CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty) { … } // TODO: Currently used for context chains when limiting debug info. llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) { … } void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD, llvm::DICompositeType *RealDecl) { … } llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType, StringRef Name, uint64_t *Offset) { … } void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit, StringRef &Name, StringRef &LinkageName, llvm::DIScope *&FDContext, llvm::DINodeArray &TParamsArray, llvm::DINode::DIFlags &Flags) { … } void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit, unsigned &LineNo, QualType &T, StringRef &Name, StringRef &LinkageName, llvm::MDTuple *&TemplateParameters, llvm::DIScope *&VDContext) { … } llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD, bool Stub) { … } llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) { … } llvm::DISubprogram *CGDebugInfo::getFunctionStub(GlobalDecl GD) { … } llvm::DIGlobalVariable * CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) { … } llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) { … } llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) { … } llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration( const Decl *D, llvm::DISubroutineType *FnType, unsigned LineNo, llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) { … } // getOrCreateFunctionType - Construct type. If it is a c++ method, include // implicit parameter "this". llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D, QualType FnType, llvm::DIFile *F) { … } QualType CGDebugInfo::getFunctionType(const FunctionDecl *FD, QualType RetTy, const SmallVectorImpl<const VarDecl *> &Args) { … } void CGDebugInfo::emitFunctionStart(GlobalDecl GD, SourceLocation Loc, SourceLocation ScopeLoc, QualType FnType, llvm::Function *Fn, bool CurFuncIsThunk) { … } void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc, QualType FnType, llvm::Function *Fn) { … } void CGDebugInfo::EmitFuncDeclForCallSite(llvm::CallBase *CallOrInvoke, QualType CalleeType, const FunctionDecl *CalleeDecl) { … } void CGDebugInfo::EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD) { … } void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) { … } void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) { … } void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) { … } void CGDebugInfo::AppendAddressSpaceXDeref( unsigned AddressSpace, SmallVectorImpl<uint64_t> &Expr) const { … } void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc) { … } void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc) { … } void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) { … } CGDebugInfo::BlockByRefType CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD, uint64_t *XOffset) { … } llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::Value *Storage, std::optional<unsigned> ArgNo, CGBuilderTy &Builder, const bool UsePointerValue) { … } llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const BindingDecl *BD, llvm::Value *Storage, std::optional<unsigned> ArgNo, CGBuilderTy &Builder, const bool UsePointerValue) { … } llvm::DILocalVariable * CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder, const bool UsePointerValue) { … } void CGDebugInfo::EmitLabel(const LabelDecl *D, CGBuilderTy &Builder) { … } llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy, llvm::DIType *Ty) { … } void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable( const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder, const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) { … } llvm::DILocalVariable * CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI, unsigned ArgNo, CGBuilderTy &Builder, bool UsePointerValue) { … } namespace { struct BlockLayoutChunk { … }; bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) { … } } // namespace void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare( const CGBlockInfo &Block, const ASTContext &Context, SourceLocation Loc, const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit, SmallVectorImpl<llvm::Metadata *> &Fields) { … } void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block, StringRef Name, unsigned ArgNo, llvm::AllocaInst *Alloca, CGBuilderTy &Builder) { … } llvm::DIDerivedType * CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) { … } llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls( const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo, StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) { … } static bool ReferencesAnonymousEntity(ArrayRef<TemplateArgument> Args); static bool ReferencesAnonymousEntity(RecordType *RT) { … } static bool ReferencesAnonymousEntity(ArrayRef<TemplateArgument> Args) { … } namespace { struct ReconstitutableType : public RecursiveASTVisitor<ReconstitutableType> { … }; } // anonymous namespace // Test whether a type name could be rebuilt from emitted debug info. static bool IsReconstitutableType(QualType QT) { … } bool CGDebugInfo::HasReconstitutableArgs( ArrayRef<TemplateArgument> Args) const { … } std::string CGDebugInfo::GetName(const Decl *D, bool Qualified) const { … } void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, const VarDecl *D) { … } void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) { … } void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var, const VarDecl *D) { … } void CGDebugInfo::EmitPseudoVariable(CGBuilderTy &Builder, llvm::Instruction *Value, QualType Ty) { … } void CGDebugInfo::EmitGlobalAlias(const llvm::GlobalValue *GV, const GlobalDecl GD) { … } void CGDebugInfo::AddStringLiteralDebugInfo(llvm::GlobalVariable *GV, const StringLiteral *S) { … } llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) { … } void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) { … } void CGDebugInfo::EmitUsingShadowDecl(const UsingShadowDecl &USD) { … } void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) { … } void CGDebugInfo::EmitUsingEnumDecl(const UsingEnumDecl &UD) { … } void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) { … } llvm::DIImportedEntity * CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) { … } llvm::DINamespace * CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) { … } void CGDebugInfo::setDwoId(uint64_t Signature) { … } void CGDebugInfo::finalize() { … } // Don't ignore in case of explicit cast where it is referenced indirectly. void CGDebugInfo::EmitExplicitCastType(QualType Ty) { … } void CGDebugInfo::EmitAndRetainType(QualType Ty) { … } llvm::DebugLoc CGDebugInfo::SourceLocToDebugLoc(SourceLocation Loc) { … } llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const { … } llvm::DIExpression * CGDebugInfo::createConstantValueExpression(const clang::ValueDecl *VD, const APValue &Val) { … }
Codebase Browser
llvm