14#ifndef LLVM_IR_DIBUILDER_H 
   15#define LLVM_IR_DIBUILDER_H 
   65    bool AllowUnresolvedNodes;
 
   74        SubprogramTrackedNodes;
 
   77    getImportTrackingVector(
const DIScope *S) {
 
   79                 ? getSubprogramNodesTrackingVector(S)
 
   83    getSubprogramNodesTrackingVector(
const DIScope *S) {
 
   90    void trackIfUnresolved(
MDNode *
N);
 
  154                      uint64_t DWOId = 0, 
bool SplitDebugInlining = 
true,
 
  155                      bool DebugInfoForProfiling = 
false,
 
  158                      bool RangesBaseAddress = 
false, 
StringRef SysRoot = {},
 
  168        StringRef Filename, StringRef Directory,
 
  169        std::optional<DIFile::ChecksumInfo<StringRef>> Checksum = std::nullopt,
 
  170        std::optional<StringRef> Source = std::nullopt);
 
  179                                  unsigned MacroType, StringRef Name,
 
  180                                  StringRef Value = StringRef());
 
  189                                              unsigned Line, DIFile *File);
 
  193                                            const APSInt &Value);
 
  195                                            bool IsUnsigned = 
false);
 
  230                               uint32_t AlignInBits, 
unsigned Encoding,
 
  241                                uint32_t AlignInBits, 
unsigned Encoding,
 
  254                                 uint32_t AlignInBits, 
unsigned Encoding,
 
  272                     DIExpression *StrLocationExp = 
nullptr);
 
  281                     DIExpression *StrLocationExp = 
nullptr);
 
  299                      std::optional<unsigned> DWARFAddressSpace = std::nullopt,
 
  300                      StringRef Name = 
"", DINodeArray Annotations = 
nullptr);
 
  305                               bool IsAddressDiscriminated,
 
  306                               unsigned ExtraDiscriminator, 
bool IsaPointer,
 
  307                               bool authenticatesNullValues);
 
  322        unsigned Tag, DIType *RTy, 
uint64_t SizeInBits = 0,
 
  324        std::optional<unsigned> DWARFAddressSpace = std::nullopt);
 
  336    createTypedef(DIType *Ty, StringRef Name, DIFile *File, 
unsigned LineNo,
 
  337                  DIScope *Context, 
uint32_t AlignInBits = 0,
 
  339                  DINodeArray Annotations = 
nullptr);
 
  354                        unsigned LineNo, DIScope *Context, DINodeArray TParams,
 
  357                        DINodeArray Annotations = 
nullptr);
 
  387        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNo,
 
  406                     DINodeArray Annotations = 
nullptr);
 
  424        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNo,
 
  439                                                    DINodeArray Elements,
 
  440                                                    Constant *Discriminant,
 
  455        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNo,
 
  458        DINodeArray Annotations = 
nullptr);
 
  472        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNo,
 
  475        DINodeArray Annotations = 
nullptr);
 
  489                                                   StringRef Name, DIFile *File,
 
  490                                                   unsigned LineNo, DIType *Ty,
 
  492                                                   Constant *Val, 
unsigned Tag,
 
  507                                           unsigned LineNo, 
uint64_t SizeInBits,
 
  511                                           MDNode *PropertyNode);
 
  524                       StringRef GetterName, StringRef SetterName,
 
  525                       unsigned PropertyAttributes, DIType *Ty);
 
  545        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNumber,
 
  548        unsigned RunTimeLang = 0, DIType *VTableHolder = 
nullptr,
 
  549        MDNode *TemplateParms = 
nullptr, StringRef UniqueIdentifier = 
"");
 
  568        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNumber,
 
  570        DIType *DerivedFrom, DINodeArray Elements, 
unsigned RunTimeLang = 0,
 
  571        DIType *VTableHolder = 
nullptr, StringRef UniqueIdentifier = 
"",
 
  572        DIType *Specification = 
nullptr, 
uint32_t NumExtraInhabitants = 0);
 
  591        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNumber,
 
  593        DIType *DerivedFrom, DINodeArray Elements, 
unsigned RunTimeLang = 0,
 
  594        DIType *VTableHolder = 
nullptr, StringRef UniqueIdentifier = 
"",
 
  595        DIType *Specification = 
nullptr, 
uint32_t NumExtraInhabitants = 0);
 
  610                    unsigned LineNumber, 
uint64_t SizeInBits,
 
  612                    DINodeArray Elements, 
unsigned RunTimeLang = 0,
 
  613                    StringRef UniqueIdentifier = 
"");
 
  630                      unsigned LineNumber, 
uint64_t SizeInBits,
 
  632                      DIDerivedType *Discriminator, DINodeArray Elements,
 
  633                      StringRef UniqueIdentifier = 
"");
 
  654                                 bool IsDefault, Constant *Val);
 
  664                                    StringRef Val, 
bool IsDefault = 
false);
 
  694        PointerUnion<DIExpression *, DIVariable *> DataLocation = 
nullptr,
 
  695        PointerUnion<DIExpression *, DIVariable *> Associated = 
nullptr,
 
  696        PointerUnion<DIExpression *, DIVariable *> Allocated = 
nullptr,
 
  697        PointerUnion<DIExpression *, DIVariable *> Rank = 
nullptr);
 
  722        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNumber,
 
  724        PointerUnion<DIExpression *, DIVariable *> DataLocation = 
nullptr,
 
  725        PointerUnion<DIExpression *, DIVariable *> Associated = 
nullptr,
 
  726        PointerUnion<DIExpression *, DIVariable *> Allocated = 
nullptr,
 
  727        PointerUnion<DIExpression *, DIVariable *> Rank = 
nullptr,
 
  737                                               DINodeArray Subscripts,
 
  755        DIScope *Scope, StringRef Name, DIFile *File, 
unsigned LineNumber,
 
  757        DIType *UnderlyingType, 
unsigned RunTimeLang = 0,
 
  758        StringRef UniqueIdentifier = 
"", 
bool IsScoped = 
false,
 
  759        std::optional<uint32_t> EnumKind = std::nullopt);
 
  769                                          DIFile *File, 
unsigned LineNo,
 
  809                       DIScope *Scope, 
uint64_t SizeInBits,
 
  817                      unsigned Line, 
unsigned RuntimeLang = 0,
 
  819                      StringRef UniqueIdentifier = 
"",
 
  820                      std::optional<uint32_t> EnumKind = std::nullopt);
 
  824        unsigned Tag, StringRef Name, DIScope *Scope, DIFile *
F, 
unsigned Line,
 
  825        unsigned RuntimeLang = 0, 
uint64_t SizeInBits = 0,
 
  827        StringRef UniqueIdentifier = 
"", DINodeArray Annotations = 
nullptr,
 
  828        std::optional<uint32_t> EnumKind = std::nullopt);
 
  878        DIScope *Context, StringRef Name, StringRef 
LinkageName, DIFile *File,
 
  879        unsigned LineNo, DIType *Ty, 
bool IsLocalToUnit, 
bool isDefined = 
true,
 
  880        DIExpression *Expr = 
nullptr, MDNode *Decl = 
nullptr,
 
  881        MDTuple *TemplateParams = 
nullptr, 
uint32_t AlignInBits = 0,
 
  882        DINodeArray Annotations = 
nullptr);
 
  887        DIScope *Context, StringRef Name, StringRef 
LinkageName, DIFile *File,
 
  888        unsigned LineNo, DIType *Ty, 
bool IsLocalToUnit, MDNode *Decl = 
nullptr,
 
  889        MDTuple *TemplateParams = 
nullptr, 
uint32_t AlignInBits = 0);
 
  901                       unsigned LineNo, DIType *Ty, 
bool AlwaysPreserve = 
false,
 
  910                                  unsigned LineNo, 
unsigned Column,
 
  912                                  std::optional<unsigned> CoroSuspendIdx,
 
  913                                  bool AlwaysPreserve = 
false);
 
  928                            DIFile *File, 
unsigned LineNo, DIType *Ty,
 
  929                            bool AlwaysPreserve = 
false,
 
  931                            DINodeArray Annotations = 
nullptr);
 
  942          VMContext, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_stack_value});
 
 
  969        DITemplateParameterArray TParams = 
nullptr,
 
  970        DISubprogram *Decl = 
nullptr, DITypeArray ThrownTypes = 
nullptr,
 
  972        bool UseKeyInstructions = 
false);
 
  981        DITemplateParameterArray TParams = 
nullptr,
 
  982        DISubprogram *Decl = 
nullptr, DITypeArray ThrownTypes = 
nullptr);
 
 1007        int ThisAdjustment = 0, 
DIType *VTableHolder = 
nullptr,
 
 1010        DITemplateParameterArray TParams = 
nullptr,
 
 1011        DITypeArray ThrownTypes = 
nullptr, 
bool UseKeyInstructions = 
false);
 
 1030                                          bool ExportSymbols);
 
 1053                                    DIFile *File = 
nullptr, 
unsigned LineNo = 0,
 
 1054                                    bool IsDecl = 
false);
 
 1064                           unsigned Discriminator = 0);
 
 1073                                                unsigned Line, 
unsigned Col);
 
 1083                         unsigned Line, DINodeArray Elements = 
nullptr);
 
 1093                         unsigned Line, DINodeArray Elements = 
nullptr);
 
 1103                         unsigned Line, DINodeArray Elements = 
nullptr);
 
 1114                              unsigned Line, StringRef Name = 
"",
 
 1115                              DINodeArray Elements = 
nullptr);
 
 1124                                      DILocalVariable *VarInfo,
 
 1125                                      DIExpression *Expr, 
const DILocation *
DL,
 
 1126                                      BasicBlock *InsertAtEnd);
 
 1143                                        DILocalVariable *SrcVar,
 
 1144                                        DIExpression *ValExpr, Value *Addr,
 
 1145                                        DIExpression *AddrExpr,
 
 1146                                        const DILocation *
DL);
 
 1155                                      DILocalVariable *VarInfo,
 
 1156                                      DIExpression *Expr, 
const DILocation *
DL,
 
 1157                                      InsertPosition InsertPt);
 
 1164                                    InsertPosition InsertPt);
 
 1173                                                DILocalVariable *VarInfo,
 
 1175                                                const DILocation *
DL,
 
 1176                                                InsertPosition InsertPt);
 
 1183                                      DIType *VTableHolder);
 
 1191                                DINodeArray TParams = DINodeArray());
 
 1201    template <
class NodeTy>
 
 1203      if (
N.get() == Replacement)
 
 1206      N->replaceAllUsesWith(Replacement);
 
 
 
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
This file implements a map that provides insertion order iteration.
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallVector class.
Annotations lets you mark points and ranges inside source code, for tests:
LLVM Basic Block Representation.
This is an important base class in LLVM.
static LLVM_ABI DIType * createObjectPointerType(DIType *Ty, bool Implicit)
Create a uniqued clone of Ty with FlagObjectPointer set.
LLVM_ABI DIBasicType * createUnspecifiedParameter()
Create unspecified parameter type for a subroutine type.
LLVM_ABI DIGlobalVariable * createTempGlobalVariableFwdDecl(DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DIType *Ty, bool IsLocalToUnit, MDNode *Decl=nullptr, MDTuple *TemplateParams=nullptr, uint32_t AlignInBits=0)
Identical to createGlobalVariable except that the resulting DbgNode is temporary and meant to be RAUW...
LLVM_ABI DITemplateValueParameter * createTemplateTemplateParameter(DIScope *Scope, StringRef Name, DIType *Ty, StringRef Val, bool IsDefault=false)
Create debugging information for a template template parameter.
NodeTy * replaceTemporary(TempMDNode &&N, NodeTy *Replacement)
Replace a temporary node.
LLVM_ABI DIDerivedType * createTypedef(DIType *Ty, StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagZero, DINodeArray Annotations=nullptr)
Create debugging information entry for a typedef.
DIBuilder & operator=(const DIBuilder &)=delete
LLVM_ABI void finalize()
Construct any deferred debug info descriptors.
LLVM_ABI DISubroutineType * createSubroutineType(DITypeRefArray ParameterTypes, DINode::DIFlags Flags=DINode::FlagZero, unsigned CC=0)
Create subroutine type.
LLVM_ABI DIMacro * createMacro(DIMacroFile *Parent, unsigned Line, unsigned MacroType, StringRef Name, StringRef Value=StringRef())
Create debugging information entry for a macro.
LLVM_ABI DIDerivedType * createInheritance(DIType *Ty, DIType *BaseTy, uint64_t BaseOffset, uint32_t VBPtrOffset, DINode::DIFlags Flags)
Create debugging information entry to establish inheritance relationship between two types.
LLVM_ABI DICompositeType * createVectorType(uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts, Metadata *BitStride=nullptr)
Create debugging information entry for a vector type.
LLVM_ABI DIDerivedType * createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, DIType *Ty, DINode::DIFlags Flags, Constant *Val, unsigned Tag, uint32_t AlignInBits=0)
Create debugging information entry for a C++ static data member.
LLVM_ABI DIDerivedType * createVariantMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty)
Create debugging information entry for a variant.
LLVM_ABI DICompositeType * createClassType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang=0, DIType *VTableHolder=nullptr, MDNode *TemplateParms=nullptr, StringRef UniqueIdentifier="")
Create debugging information entry for a class.
LLVM_ABI DILexicalBlockFile * createLexicalBlockFile(DIScope *Scope, DIFile *File, unsigned Discriminator=0)
This creates a descriptor for a lexical block with a new file attached.
LLVM_ABI void finalizeSubprogram(DISubprogram *SP)
Finalize a specific subprogram - no new variables may be added to this subprogram afterwards.
LLVM_ABI DIDerivedType * createQualifiedType(unsigned Tag, DIType *FromTy)
Create debugging information entry for a qualified type, e.g.
LLVM_ABI DISubprogram * createTempFunctionFwdDecl(DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, DINode::DIFlags Flags=DINode::FlagZero, DISubprogram::DISPFlags SPFlags=DISubprogram::SPFlagZero, DITemplateParameterArray TParams=nullptr, DISubprogram *Decl=nullptr, DITypeArray ThrownTypes=nullptr)
Identical to createFunction, except that the resulting DbgNode is meant to be RAUWed.
LLVM_ABI DIDerivedType * createObjCIVar(StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DINode::DIFlags Flags, DIType *Ty, MDNode *PropertyNode)
Create debugging information entry for Objective-C instance variable.
static LLVM_ABI DIType * createArtificialType(DIType *Ty)
Create a uniqued clone of Ty with FlagArtificial set.
LLVM_ABI DIDerivedType * createBitFieldMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, Metadata *SizeInBits, Metadata *OffsetInBits, uint64_t StorageOffsetInBits, DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations=nullptr)
Create debugging information entry for a bit field member.
LLVM_ABI DIFixedPointType * createRationalFixedPointType(StringRef Name, uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding, DINode::DIFlags Flags, APInt Numerator, APInt Denominator)
Create debugging information entry for an arbitrary rational fixed-point type.
LLVM_ABI DISubprogram * createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned VTableIndex=0, int ThisAdjustment=0, DIType *VTableHolder=nullptr, DINode::DIFlags Flags=DINode::FlagZero, DISubprogram::DISPFlags SPFlags=DISubprogram::SPFlagZero, DITemplateParameterArray TParams=nullptr, DITypeArray ThrownTypes=nullptr, bool UseKeyInstructions=false)
Create a new descriptor for the specified C++ method.
LLVM_ABI DINamespace * createNameSpace(DIScope *Scope, StringRef Name, bool ExportSymbols)
This creates new descriptor for a namespace with the specified parent scope.
LLVM_ABI DIStringType * createStringType(StringRef Name, uint64_t SizeInBits)
Create debugging information entry for a string type.
LLVM_ABI DbgInstPtr insertDbgAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *SrcVar, DIExpression *ValExpr, Value *Addr, DIExpression *AddrExpr, const DILocation *DL)
Insert a new llvm.dbg.assign intrinsic call.
LLVM_ABI DILexicalBlock * createLexicalBlock(DIScope *Scope, DIFile *File, unsigned Line, unsigned Col)
This creates a descriptor for a lexical block with the specified parent context.
LLVM_ABI DICompositeType * createUnionType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DINodeArray Elements, unsigned RunTimeLang=0, StringRef UniqueIdentifier="")
Create debugging information entry for an union.
LLVM_ABI DIMacroNodeArray getOrCreateMacroArray(ArrayRef< Metadata * > Elements)
Get a DIMacroNodeArray, create one if required.
LLVM_ABI DIDerivedType * createMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, Metadata *SizeInBits, uint32_t AlignInBits, Metadata *OffsetInBits, DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations=nullptr)
Create debugging information entry for a member.
LLVM_ABI DIDerivedType * createSetType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, DIType *Ty)
Create debugging information entry for a set.
LLVM_ABI void replaceVTableHolder(DICompositeType *&T, DIType *VTableHolder)
Replace the vtable holder in the given type.
DIExpression * createConstantValueExpression(uint64_t Val)
Create an expression for a variable that does not have an address, but does have a constant value.
LLVM_ABI DIBasicType * createNullPtrType()
Create C++11 nullptr type.
LLVM_ABI DICommonBlock * createCommonBlock(DIScope *Scope, DIGlobalVariable *decl, StringRef Name, DIFile *File, unsigned LineNo)
Create common block entry for a Fortran common block.
LLVM_ABI DIDerivedType * createFriend(DIType *Ty, DIType *FriendTy)
Create debugging information entry for a 'friend'.
LLVM_ABI DILabel * createLabel(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, unsigned Column, bool IsArtificial, std::optional< unsigned > CoroSuspendIdx, bool AlwaysPreserve=false)
Create a new descriptor for an label.
LLVM_ABI void retainType(DIScope *T)
Retain DIScope* in a module even if it is not referenced through debug info anchors.
LLVM_ABI DIDerivedType * createTemplateAlias(DIType *Ty, StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context, DINodeArray TParams, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagZero, DINodeArray Annotations=nullptr)
Create debugging information entry for a template alias.
DIBuilder(const DIBuilder &)=delete
LLVM_ABI DISubprogram * createFunction(DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, DINode::DIFlags Flags=DINode::FlagZero, DISubprogram::DISPFlags SPFlags=DISubprogram::SPFlagZero, DITemplateParameterArray TParams=nullptr, DISubprogram *Decl=nullptr, DITypeArray ThrownTypes=nullptr, DINodeArray Annotations=nullptr, StringRef TargetFuncName="", bool UseKeyInstructions=false)
Create a new descriptor for the specified subprogram.
LLVM_ABI DIDerivedType * createPointerType(DIType *PointeeTy, uint64_t SizeInBits, uint32_t AlignInBits=0, std::optional< unsigned > DWARFAddressSpace=std::nullopt, StringRef Name="", DINodeArray Annotations=nullptr)
Create debugging information entry for a pointer.
LLVM_ABI DbgInstPtr insertDeclare(llvm::Value *Storage, DILocalVariable *VarInfo, DIExpression *Expr, const DILocation *DL, BasicBlock *InsertAtEnd)
Insert a new llvm.dbg.declare intrinsic call.
LLVM_ABI DbgInstPtr insertDbgValueIntrinsic(llvm::Value *Val, DILocalVariable *VarInfo, DIExpression *Expr, const DILocation *DL, InsertPosition InsertPt)
Insert a new llvm.dbg.value intrinsic call.
LLVM_ABI DITemplateValueParameter * createTemplateParameterPack(DIScope *Scope, StringRef Name, DIType *Ty, DINodeArray Val)
Create debugging information for a template parameter pack.
LLVM_ABI DIGlobalVariableExpression * createGlobalVariableExpression(DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DIType *Ty, bool IsLocalToUnit, bool isDefined=true, DIExpression *Expr=nullptr, MDNode *Decl=nullptr, MDTuple *TemplateParams=nullptr, uint32_t AlignInBits=0, DINodeArray Annotations=nullptr)
Create a new descriptor for the specified variable.
LLVM_ABI DICompositeType * createReplaceableCompositeType(unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line, unsigned RuntimeLang=0, uint64_t SizeInBits=0, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagFwdDecl, StringRef UniqueIdentifier="", DINodeArray Annotations=nullptr, std::optional< uint32_t > EnumKind=std::nullopt)
Create a temporary forward-declared type.
LLVM_ABI DICompositeType * createEnumerationType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements, DIType *UnderlyingType, unsigned RunTimeLang=0, StringRef UniqueIdentifier="", bool IsScoped=false, std::optional< uint32_t > EnumKind=std::nullopt)
Create debugging information entry for an enumeration.
LLVM_ABI DIFixedPointType * createDecimalFixedPointType(StringRef Name, uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding, DINode::DIFlags Flags, int Factor)
Create debugging information entry for a decimal fixed-point type.
LLVM_ABI DIBasicType * createBasicType(StringRef Name, uint64_t SizeInBits, unsigned Encoding, DINode::DIFlags Flags=DINode::FlagZero, uint32_t NumExtraInhabitants=0, uint32_t DataSizeInBits=0)
Create debugging information entry for a basic type.
LLVM_ABI DISubrange * getOrCreateSubrange(int64_t Lo, int64_t Count)
Create a descriptor for a value range.
LLVM_ABI DISubrangeType * createSubrangeType(StringRef Name, DIFile *File, unsigned LineNo, DIScope *Scope, uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DIType *Ty, Metadata *LowerBound, Metadata *UpperBound, Metadata *Stride, Metadata *Bias)
Create a type describing a subrange of another type.
LLVM_ABI DIDerivedType * createReferenceType(unsigned Tag, DIType *RTy, uint64_t SizeInBits=0, uint32_t AlignInBits=0, std::optional< unsigned > DWARFAddressSpace=std::nullopt)
Create debugging information entry for a c++ style reference or rvalue reference type.
LLVM_ABI DIMacroFile * createTempMacroFile(DIMacroFile *Parent, unsigned Line, DIFile *File)
Create debugging information temporary entry for a macro file.
LLVM_ABI DICompositeType * createArrayType(uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts, PointerUnion< DIExpression *, DIVariable * > DataLocation=nullptr, PointerUnion< DIExpression *, DIVariable * > Associated=nullptr, PointerUnion< DIExpression *, DIVariable * > Allocated=nullptr, PointerUnion< DIExpression *, DIVariable * > Rank=nullptr)
Create debugging information entry for an array.
LLVM_ABI DIDerivedType * createMemberPointerType(DIType *PointeeTy, DIType *Class, uint64_t SizeInBits, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagZero)
Create debugging information entry for a pointer to member.
LLVM_ABI DICompositeType * createStructType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, Metadata *SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang=0, DIType *VTableHolder=nullptr, StringRef UniqueIdentifier="", DIType *Specification=nullptr, uint32_t NumExtraInhabitants=0)
Create debugging information entry for a struct.
LLVM_ABI DITypeRefArray getOrCreateTypeArray(ArrayRef< Metadata * > Elements)
Get a DITypeRefArray, create one if required.
LLVM_ABI DINodeArray getOrCreateArray(ArrayRef< Metadata * > Elements)
Get a DINodeArray, create one if required.
LLVM_ABI DICompileUnit * createCompileUnit(DISourceLanguageName Lang, DIFile *File, StringRef Producer, bool isOptimized, StringRef Flags, unsigned RV, StringRef SplitName=StringRef(), DICompileUnit::DebugEmissionKind Kind=DICompileUnit::DebugEmissionKind::FullDebug, uint64_t DWOId=0, bool SplitDebugInlining=true, bool DebugInfoForProfiling=false, DICompileUnit::DebugNameTableKind NameTableKind=DICompileUnit::DebugNameTableKind::Default, bool RangesBaseAddress=false, StringRef SysRoot={}, StringRef SDK={})
A CompileUnit provides an anchor for all debugging information generated during this instance of comp...
LLVM_ABI DIEnumerator * createEnumerator(StringRef Name, const APSInt &Value)
Create a single enumerator value.
LLVM_ABI DITemplateTypeParameter * createTemplateTypeParameter(DIScope *Scope, StringRef Name, DIType *Ty, bool IsDefault)
Create debugging information for template type parameter.
LLVM_ABI DIBuilder(Module &M, bool AllowUnresolved=true, DICompileUnit *CU=nullptr)
Construct a builder for a module.
LLVM_ABI DIExpression * createExpression(ArrayRef< uint64_t > Addr={})
Create a new descriptor for the specified variable which has a complex address expression for its add...
LLVM_ABI DIDerivedType * createPtrAuthQualifiedType(DIType *FromTy, unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, bool IsaPointer, bool authenticatesNullValues)
Create a __ptrauth qualifier.
LLVM_ABI DICompositeType * createForwardDecl(unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line, unsigned RuntimeLang=0, uint64_t SizeInBits=0, uint32_t AlignInBits=0, StringRef UniqueIdentifier="", std::optional< uint32_t > EnumKind=std::nullopt)
Create a permanent forward-declared type.
LLVM_ABI DICompositeType * createVariantPart(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DIDerivedType *Discriminator, DINodeArray Elements, StringRef UniqueIdentifier="")
Create debugging information entry for a variant part.
LLVM_ABI DIImportedEntity * createImportedModule(DIScope *Context, DINamespace *NS, DIFile *File, unsigned Line, DINodeArray Elements=nullptr)
Create a descriptor for an imported module.
LLVM_ABI DbgInstPtr insertLabel(DILabel *LabelInfo, const DILocation *DL, InsertPosition InsertPt)
Insert a new llvm.dbg.label intrinsic call.
LLVM_ABI DIImportedEntity * createImportedDeclaration(DIScope *Context, DINode *Decl, DIFile *File, unsigned Line, StringRef Name="", DINodeArray Elements=nullptr)
Create a descriptor for an imported function.
LLVM_ABI DILocalVariable * createAutoVariable(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, DIType *Ty, bool AlwaysPreserve=false, DINode::DIFlags Flags=DINode::FlagZero, uint32_t AlignInBits=0)
Create a new descriptor for an auto variable.
static LLVM_ABI DISubprogram * createArtificialSubprogram(DISubprogram *SP)
Create a distinct clone of SP with FlagArtificial set.
LLVM_ABI DIGenericSubrange * getOrCreateGenericSubrange(DIGenericSubrange::BoundType Count, DIGenericSubrange::BoundType LowerBound, DIGenericSubrange::BoundType UpperBound, DIGenericSubrange::BoundType Stride)
LLVM_ABI DIBasicType * createUnspecifiedType(StringRef Name)
Create a DWARF unspecified type.
LLVM_ABI DIObjCProperty * createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber, StringRef GetterName, StringRef SetterName, unsigned PropertyAttributes, DIType *Ty)
Create debugging information entry for Objective-C property.
LLVM_ABI DITemplateValueParameter * createTemplateValueParameter(DIScope *Scope, StringRef Name, DIType *Ty, bool IsDefault, Constant *Val)
Create debugging information for template value parameter.
LLVM_ABI DILocalVariable * createParameterVariable(DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, unsigned LineNo, DIType *Ty, bool AlwaysPreserve=false, DINode::DIFlags Flags=DINode::FlagZero, DINodeArray Annotations=nullptr)
Create a new descriptor for a parameter variable.
LLVM_ABI DIFile * createFile(StringRef Filename, StringRef Directory, std::optional< DIFile::ChecksumInfo< StringRef > > Checksum=std::nullopt, std::optional< StringRef > Source=std::nullopt)
Create a file descriptor to hold debugging information for a file.
LLVM_ABI void replaceArrays(DICompositeType *&T, DINodeArray Elements, DINodeArray TParams=DINodeArray())
Replace arrays on a composite type.
LLVM_ABI DIFixedPointType * createBinaryFixedPointType(StringRef Name, uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding, DINode::DIFlags Flags, int Factor)
Create debugging information entry for a binary fixed-point type.
LLVM_ABI DIModule * createModule(DIScope *Scope, StringRef Name, StringRef ConfigurationMacros, StringRef IncludePath, StringRef APINotesFile={}, DIFile *File=nullptr, unsigned LineNo=0, bool IsDecl=false)
This creates new descriptor for a module with the specified parent scope.
PointerUnion< DIVariable *, DIExpression * > BoundType
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Base class for scope-like contexts.
Wrapper structure that holds a language name and its version.
Subprogram description. Uses SubclassData1.
DISPFlags
Debug info subprogram flags.
Type array for a subprogram.
This represents the llvm.dbg.assign instruction.
Base class for non-instruction debug metadata records that have positions within IR.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
This is an important class for using LLVM in a threaded context.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
This class implements a map that also provides access to all stored values in a deterministic order.
A Module instance is used to store all the information related to an LLVM module.
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
LLVM Value Representation.
struct LLVMOpaqueDIBuilder * LLVMDIBuilderRef
Represents an LLVM debug info builder.
This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM.
This is an optimization pass for GlobalISel generic memory operations.
bool isa_and_nonnull(const Y &Val)
FunctionAddr VTableAddr Count
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
ArrayRef(const T &OneElt) -> ArrayRef< T >
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
PointerUnion< Instruction *, DbgRecord * > DbgInstPtr