6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-06-02 04:41:58 +00:00
Code Issues Projects Releases Wiki Activity

DebugInfo: Remove DIDescriptor from the DIBuilder API

Browse Source 
As a step toward killing `DIDescriptor` and its subclasses, remove it
from the `DIBuilder` API.  Replace the subclasses with appropriate
pointers from the new debug info hierarchy.  There are a couple of
possible surprises in type choices for out-of-tree frontends:

  - Subroutine types: `MDSubroutineType`, not `MDCompositeTypeBase`.
  - Composite types: `MDCompositeType`, not `MDCompositeTypeBase`.
  - Scopes: `MDScope`, not `MDNode`.
  - Generic debug info nodes: `DebugNode`, not `MDNode`.

This is part of PR23080.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@235111 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan P. N. Exon Smith 2015-04-16 16:36:23 +00:00
parent e2711530de
commit afc67405f8
5 changed files with 407 additions and 485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
bindings/go/llvm/DIBuilderBindings.cpp
View File

@ -58,9 +58,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
unsigned Line,
unsigned Column) {
DIBuilder *D = unwrap(Dref);
DILexicalBlock LB =
D->createLexicalBlock(DIDescriptor(unwrap<MDLocalScope>(Scope)),
unwrap<MDFile>(File), Line, Column);
auto *LB = D->createLexicalBlock(unwrap<MDLocalScope>(Scope),
unwrap<MDFile>(File), Line, Column);
return wrap(LB);
}
@ -69,9 +68,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
LLVMMetadataRef File,
unsigned Discriminator) {
DIBuilder *D = unwrap(Dref);
DILexicalBlockFile LBF =
D->createLexicalBlockFile(DIDescriptor(unwrap<MDLocalScope>(Scope)),
unwrap<MDFile>(File), Discriminator);
DILexicalBlockFile LBF = D->createLexicalBlockFile(
unwrap<MDLocalScope>(Scope), unwrap<MDFile>(File), Discriminator);
return wrap(LBF);
}
@ -82,9 +80,9 @@ LLVMMetadataRef LLVMDIBuilderCreateFunction(
unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Func) {
DIBuilder *D = unwrap(Dref);
DISubprogram SP = D->createFunction(
DIDescriptor(unwrap<MDScope>(Scope)), Name, LinkageName,
unwrap<MDScope>(Scope), Name, LinkageName,
File ? unwrap<MDFile>(File) : nullptr, Line,
unwrap<MDCompositeTypeBase>(CompositeType), IsLocalToUnit, IsDefinition,
unwrap<MDSubroutineType>(CompositeType), IsLocalToUnit, IsDefinition,
ScopeLine, Flags, IsOptimized, unwrap<Function>(Func));
return wrap(SP);
}
@ -95,8 +93,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLocalVariable(
int AlwaysPreserve, unsigned Flags, unsigned ArgNo) {
DIBuilder *D = unwrap(Dref);
DIVariable V = D->createLocalVariable(
Tag, DIDescriptor(unwrap<MDScope>(Scope)), Name, unwrap<MDFile>(File),
Line, unwrap<MDType>(Ty), AlwaysPreserve, Flags, ArgNo);
Tag, unwrap<MDScope>(Scope), Name, unwrap<MDFile>(File), Line,
unwrap<MDType>(Ty), AlwaysPreserve, Flags, ArgNo);
return wrap(V);
}
@ -138,9 +136,9 @@ LLVMMetadataRef LLVMDIBuilderCreateStructType(
LLVMMetadataRef ElementTypes) {
DIBuilder *D = unwrap(Dref);
DICompositeType CT = D->createStructType(
DIDescriptor(unwrap<MDScope>(Scope)), Name,
File ? unwrap<MDFile>(File) : nullptr, Line, SizeInBits, AlignInBits,
Flags, DerivedFrom ? unwrap<MDType>(DerivedFrom) : nullptr,
unwrap<MDScope>(Scope), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
SizeInBits, AlignInBits, Flags,
DerivedFrom ? unwrap<MDType>(DerivedFrom) : nullptr,
ElementTypes ? DIArray(unwrap<MDTuple>(ElementTypes)) : nullptr);
return wrap(CT);
}
@ -152,9 +150,8 @@ LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
unsigned Flags) {
DIBuilder *D = unwrap(Dref);
DICompositeType CT = D->createReplaceableCompositeType(
Tag, Name, DIDescriptor(unwrap<MDScope>(Scope)),
File ? unwrap<MDFile>(File) : nullptr, Line, RuntimeLang, SizeInBits,
AlignInBits, Flags);
Tag, Name, unwrap<MDScope>(Scope), File ? unwrap<MDFile>(File) : nullptr,
Line, RuntimeLang, SizeInBits, AlignInBits, Flags);
return wrap(CT);
}
@ -166,9 +163,8 @@ LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
unsigned Flags, LLVMMetadataRef Ty) {
DIBuilder *D = unwrap(Dref);
DIDerivedType DT = D->createMemberType(
DIDescriptor(unwrap<MDScope>(Scope)), Name,
File ? unwrap<MDFile>(File) : nullptr, Line, SizeInBits, AlignInBits,
OffsetInBits, Flags, unwrap<MDType>(Ty));
unwrap<MDScope>(Scope), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
SizeInBits, AlignInBits, OffsetInBits, Flags, unwrap<MDType>(Ty));
return wrap(DT);
}
@ -191,7 +187,7 @@ LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
DIBuilder *D = unwrap(Dref);
DIDerivedType DT = D->createTypedef(
unwrap<MDType>(Ty), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
Context ? DIDescriptor(unwrap<MDScope>(Context)) : DIDescriptor());
Context ? unwrap<MDScope>(Context) : nullptr);
return wrap(DT);
}

4
examples/Kaleidoscope/Chapter8/toy.cpp
View File

@ -836,7 +836,7 @@ void DebugInfo::emitLocation(ExprAST *AST) {
DebugLoc::get(AST->getLine(), AST->getCol(), Scope));
}
static DICompositeType CreateFunctionType(unsigned NumArgs, DIFile Unit) {
static MDSubroutineType *CreateFunctionType(unsigned NumArgs, DIFile Unit) {
SmallVector<Metadata *, 8> EltTys;
DIType DblTy = KSDbgInfo.getDoubleTy();
@ -1226,7 +1226,7 @@ Function *PrototypeAST::Codegen() {
// Create a subprogram DIE for this function.
DIFile Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
KSDbgInfo.TheCU->getDirectory());
DIDescriptor FContext = Unit;
MDScope *FContext = Unit;
unsigned LineNo = Line;
unsigned ScopeLine = Line;
DISubprogram SP = DBuilder->createFunction(

399
include/llvm/IR/DIBuilder.h
View File

@ -30,28 +30,7 @@ namespace llvm {
class Value;
class Constant;
class LLVMContext;
class MDNode;
class StringRef;
class DIBasicType;
class DICompileUnit;
class DICompositeType;
class DIDerivedType;
class DIDescriptor;
class DIFile;
class DIEnumerator;
class DIType;
class DIGlobalVariable;
class DIImportedEntity;
class DINameSpace;
class DIVariable;
class DISubrange;
class DILexicalBlockFile;
class DILexicalBlock;
class DIScope;
class DISubprogram;
class DITemplateTypeParameter;
class DITemplateValueParameter;
class DIObjCProperty;
class DIBuilder {
Module &M;
@ -125,26 +104,25 @@ namespace llvm {
/// source location information in the back end
/// without actually changing the output (e.g.,
/// when using optimization remarks).
DICompileUnit createCompileUnit(unsigned Lang, StringRef File,
StringRef Dir, StringRef Producer,
bool isOptimized, StringRef Flags,
unsigned RV,
StringRef SplitName = StringRef(),
DebugEmissionKind Kind = FullDebug,
bool EmitDebugInfo = true);
MDCompileUnit *createCompileUnit(unsigned Lang, StringRef File,
StringRef Dir, StringRef Producer,
bool isOptimized, StringRef Flags,
unsigned RV, StringRef SplitName = "",
DebugEmissionKind Kind = FullDebug,
bool EmitDebugInfo = true);
/// createFile - Create a file descriptor to hold debugging information
/// for a file.
DIFile createFile(StringRef Filename, StringRef Directory);
MDFile *createFile(StringRef Filename, StringRef Directory);
/// createEnumerator - Create a single enumerator value.
DIEnumerator createEnumerator(StringRef Name, int64_t Val);
MDEnumerator *createEnumerator(StringRef Name, int64_t Val);
/// \brief Create a DWARF unspecified type.
DIBasicType createUnspecifiedType(StringRef Name);
MDBasicType *createUnspecifiedType(StringRef Name);
/// \brief Create C++11 nullptr type.
DIBasicType createNullPtrType();
MDBasicType *createNullPtrType();
/// createBasicType - Create debugging information entry for a basic
/// type.
@ -152,36 +130,36 @@ namespace llvm {
/// @param SizeInBits Size of the type.
/// @param AlignInBits Type alignment.
/// @param Encoding DWARF encoding code, e.g. dwarf::DW_ATE_float.
DIBasicType createBasicType(StringRef Name, uint64_t SizeInBits,
uint64_t AlignInBits, unsigned Encoding);
MDBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
uint64_t AlignInBits, unsigned Encoding);
/// createQualifiedType - Create debugging information entry for a qualified
/// type, e.g. 'const int'.
/// @param Tag Tag identifing type, e.g. dwarf::TAG_volatile_type
/// @param FromTy Base Type.
DIDerivedType createQualifiedType(unsigned Tag, DIType FromTy);
MDDerivedType *createQualifiedType(unsigned Tag, MDType *FromTy);
/// createPointerType - Create debugging information entry for a pointer.
/// @param PointeeTy Type pointed by this pointer.
/// @param SizeInBits Size.
/// @param AlignInBits Alignment. (optional)
/// @param Name Pointer type name. (optional)
DIDerivedType
createPointerType(DIType PointeeTy, uint64_t SizeInBits,
uint64_t AlignInBits = 0, StringRef Name = StringRef());
MDDerivedType *createPointerType(MDType *PointeeTy, uint64_t SizeInBits,
uint64_t AlignInBits = 0,
StringRef Name = "");
/// \brief Create debugging information entry for a pointer to member.
/// @param PointeeTy Type pointed to by this pointer.
/// @param SizeInBits Size.
/// @param AlignInBits Alignment. (optional)
/// @param Class Type for which this pointer points to members of.
DIDerivedType createMemberPointerType(DIType PointeeTy, DIType Class,
uint64_t SizeInBits,
uint64_t AlignInBits = 0);
MDDerivedType *createMemberPointerType(MDType *PointeeTy, MDType *Class,
uint64_t SizeInBits,
uint64_t AlignInBits = 0);
/// createReferenceType - Create debugging information entry for a c++
/// style reference or rvalue reference type.
DIDerivedType createReferenceType(unsigned Tag, DIType RTy);
MDDerivedType *createReferenceType(unsigned Tag, MDType *RTy);
/// createTypedef - Create debugging information entry for a typedef.
/// @param Ty Original type.
@ -189,11 +167,11 @@ namespace llvm {
/// @param File File where this type is defined.
/// @param LineNo Line number.
/// @param Context The surrounding context for the typedef.
DIDerivedType createTypedef(DIType Ty, StringRef Name, DIFile File,
unsigned LineNo, DIDescriptor Context);
MDDerivedType *createTypedef(MDType *Ty, StringRef Name, MDFile *File,
unsigned LineNo, MDScope *Context);
/// createFriend - Create debugging information entry for a 'friend'.
DIDerivedType createFriend(DIType Ty, DIType FriendTy);
MDDerivedType *createFriend(MDType *Ty, MDType *FriendTy);
/// createInheritance - Create debugging information entry to establish
/// inheritance relationship between two types.
@ -202,8 +180,8 @@ namespace llvm {
/// @param BaseOffset Base offset.
/// @param Flags Flags to describe inheritance attribute,
/// e.g. private
DIDerivedType createInheritance(DIType Ty, DIType BaseTy,
uint64_t BaseOffset, unsigned Flags);
MDDerivedType *createInheritance(MDType *Ty, MDType *BaseTy,
uint64_t BaseOffset, unsigned Flags);
/// createMemberType - Create debugging information entry for a member.
/// @param Scope Member scope.
@ -215,10 +193,11 @@ namespace llvm {
/// @param OffsetInBits Member offset.
/// @param Flags Flags to encode member attribute, e.g. private
/// @param Ty Parent type.
DIDerivedType
createMemberType(DIDescriptor Scope, StringRef Name, DIFile File,
unsigned LineNo, uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags, DIType Ty);
MDDerivedType *createMemberType(MDScope *Scope, StringRef Name,
MDFile *File, unsigned LineNo,
uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
MDType *Ty);
/// createStaticMemberType - Create debugging information entry for a
/// C++ static data member.
@ -229,10 +208,10 @@ namespace llvm {
/// @param Ty Type of the static member.
/// @param Flags Flags to encode member attribute, e.g. private.
/// @param Val Const initializer of the member.
DIDerivedType createStaticMemberType(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNo,
DIType Ty, unsigned Flags,
llvm::Constant *Val);
MDDerivedType *createStaticMemberType(MDScope *Scope, StringRef Name,
MDFile *File, unsigned LineNo,
MDType *Ty, unsigned Flags,
llvm::Constant *Val);
/// createObjCIVar - Create debugging information entry for Objective-C
/// instance variable.
@ -245,11 +224,10 @@ namespace llvm {
/// @param Flags Flags to encode member attribute, e.g. private
/// @param Ty Parent type.
/// @param PropertyNode Property associated with this ivar.
DIDerivedType createObjCIVar(StringRef Name, DIFile File,
unsigned LineNo, uint64_t SizeInBits,
uint64_t AlignInBits, uint64_t OffsetInBits,
unsigned Flags, DIType Ty,
MDNode *PropertyNode);
MDDerivedType *createObjCIVar(StringRef Name, MDFile *File, unsigned LineNo,
uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
MDType *Ty, MDNode *PropertyNode);
/// createObjCProperty - Create debugging information entry for Objective-C
/// property.
@ -260,12 +238,11 @@ namespace llvm {
/// @param SetterName Name of the Objective C property setter selector.
/// @param PropertyAttributes Objective C property attributes.
/// @param Ty Type.
DIObjCProperty createObjCProperty(StringRef Name,
DIFile File, unsigned LineNumber,
StringRef GetterName,
StringRef SetterName,
unsigned PropertyAttributes,
DIType Ty);
MDObjCProperty *createObjCProperty(StringRef Name, MDFile *File,
unsigned LineNumber,
StringRef GetterName,
StringRef SetterName,
unsigned PropertyAttributes, MDType *Ty);
/// createClassType - Create debugging information entry for a class.
/// @param Scope Scope in which this class is defined.
@ -283,14 +260,14 @@ namespace llvm {
/// for more info.
/// @param TemplateParms Template type parameters.
/// @param UniqueIdentifier A unique identifier for the class.
DICompositeType createClassType(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
DIType DerivedFrom, DIArray Elements,
DIType VTableHolder = DIType(),
MDNode *TemplateParms = nullptr,
StringRef UniqueIdentifier = StringRef());
MDCompositeType *createClassType(MDScope *Scope, StringRef Name,
MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
MDType *DerivedFrom, DIArray Elements,
MDType *VTableHolder = nullptr,
MDNode *TemplateParms = nullptr,
StringRef UniqueIdentifier = "");
/// createStructType - Create debugging information entry for a struct.
/// @param Scope Scope in which this struct is defined.
@ -303,13 +280,11 @@ namespace llvm {
/// @param Elements Struct elements.
/// @param RunTimeLang Optional parameter, Objective-C runtime version.
/// @param UniqueIdentifier A unique identifier for the struct.
DICompositeType createStructType(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits,
unsigned Flags, DIType DerivedFrom,
DIArray Elements, unsigned RunTimeLang = 0,
DIType VTableHolder = DIType(),
StringRef UniqueIdentifier = StringRef());
MDCompositeType *createStructType(
MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
MDType *DerivedFrom, DIArray Elements, unsigned RunTimeLang = 0,
MDType *VTableHolder = nullptr, StringRef UniqueIdentifier = "");
/// createUnionType - Create debugging information entry for an union.
/// @param Scope Scope in which this union is defined.
@ -322,19 +297,20 @@ namespace llvm {
/// @param Elements Union elements.
/// @param RunTimeLang Optional parameter, Objective-C runtime version.
/// @param UniqueIdentifier A unique identifier for the union.
DICompositeType createUnionType(
DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
DIArray Elements, unsigned RunTimeLang = 0,
StringRef UniqueIdentifier = StringRef());
MDCompositeType *createUnionType(MDScope *Scope, StringRef Name,
MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits,
unsigned Flags, DIArray Elements,
unsigned RunTimeLang = 0,
StringRef UniqueIdentifier = "");
/// createTemplateTypeParameter - Create debugging information for template
/// type parameter.
/// @param Scope Scope in which this type is defined.
/// @param Name Type parameter name.
/// @param Ty Parameter type.
DITemplateTypeParameter
createTemplateTypeParameter(DIDescriptor Scope, StringRef Name, DIType Ty);
MDTemplateTypeParameter *
createTemplateTypeParameter(MDScope *Scope, StringRef Name, MDType *Ty);
/// createTemplateValueParameter - Create debugging information for template
/// value parameter.
@ -342,46 +318,46 @@ namespace llvm {
/// @param Name Value parameter name.
/// @param Ty Parameter type.
/// @param Val Constant parameter value.
DITemplateValueParameter createTemplateValueParameter(DIDescriptor Scope,
StringRef Name,
DIType Ty,
Constant *Val);
MDTemplateValueParameter *createTemplateValueParameter(MDScope *Scope,
StringRef Name,
MDType *Ty,
Constant *Val);
/// \brief Create debugging information for a template template parameter.
/// @param Scope Scope in which this type is defined.
/// @param Name Value parameter name.
/// @param Ty Parameter type.
/// @param Val The fully qualified name of the template.
DITemplateValueParameter createTemplateTemplateParameter(DIDescriptor Scope,
StringRef Name,
DIType Ty,
StringRef Val);
MDTemplateValueParameter *createTemplateTemplateParameter(MDScope *Scope,
StringRef Name,
MDType *Ty,
StringRef Val);
/// \brief Create debugging information for a template parameter pack.
/// @param Scope Scope in which this type is defined.
/// @param Name Value parameter name.
/// @param Ty Parameter type.
/// @param Val An array of types in the pack.
DITemplateValueParameter createTemplateParameterPack(DIDescriptor Scope,
StringRef Name,
DIType Ty,
DIArray Val);
MDTemplateValueParameter *createTemplateParameterPack(MDScope *Scope,
StringRef Name,
MDType *Ty,
DIArray Val);
/// createArrayType - Create debugging information entry for an array.
/// @param Size Array size.
/// @param AlignInBits Alignment.
/// @param Ty Element type.
/// @param Subscripts Subscripts.
DICompositeType createArrayType(uint64_t Size, uint64_t AlignInBits,
DIType Ty, DIArray Subscripts);
MDCompositeType *createArrayType(uint64_t Size, uint64_t AlignInBits,
MDType *Ty, DIArray Subscripts);
/// createVectorType - Create debugging information entry for a vector type.
/// @param Size Array size.
/// @param AlignInBits Alignment.
/// @param Ty Element type.
/// @param Subscripts Subscripts.
DICompositeType createVectorType(uint64_t Size, uint64_t AlignInBits,
DIType Ty, DIArray Subscripts);
MDCompositeType *createVectorType(uint64_t Size, uint64_t AlignInBits,
MDType *Ty, DIArray Subscripts);
/// createEnumerationType - Create debugging information entry for an
/// enumeration.
@ -394,10 +370,10 @@ namespace llvm {
/// @param Elements Enumeration elements.
/// @param UnderlyingType Underlying type of a C++11/ObjC fixed enum.
/// @param UniqueIdentifier A unique identifier for the enum.
DICompositeType createEnumerationType(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNumber, uint64_t SizeInBits,
uint64_t AlignInBits, DIArray Elements, DIType UnderlyingType,
StringRef UniqueIdentifier = StringRef());
MDCompositeType *createEnumerationType(
MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
MDType *UnderlyingType, StringRef UniqueIdentifier = "");
/// createSubroutineType - Create subroutine type.
/// @param File File in which this subroutine is defined.
@ -405,39 +381,39 @@ namespace llvm {
/// includes return type at 0th index.
/// @param Flags E.g.: LValueReference.
/// These flags are used to emit dwarf attributes.
DISubroutineType createSubroutineType(DIFile File,
DITypeArray ParameterTypes,
unsigned Flags = 0);
MDSubroutineType *createSubroutineType(MDFile *File,
DITypeArray ParameterTypes,
unsigned Flags = 0);
/// createArtificialType - Create a new DIType with "artificial" flag set.
DIType createArtificialType(DIType Ty);
/// createArtificialType - Create a new MDType* with "artificial" flag set.
MDType *createArtificialType(MDType *Ty);
/// createObjectPointerType - Create a new DIType with the "object pointer"
/// createObjectPointerType - Create a new MDType* with the "object pointer"
/// flag set.
DIType createObjectPointerType(DIType Ty);
MDType *createObjectPointerType(MDType *Ty);
/// \brief Create a permanent forward-declared type.
DICompositeType createForwardDecl(unsigned Tag, StringRef Name,
DIDescriptor Scope, DIFile F,
unsigned Line, unsigned RuntimeLang = 0,
uint64_t SizeInBits = 0,
uint64_t AlignInBits = 0,
StringRef UniqueIdentifier = StringRef());
MDCompositeType *createForwardDecl(unsigned Tag, StringRef Name,
MDScope *Scope, MDFile *F, unsigned Line,
unsigned RuntimeLang = 0,
uint64_t SizeInBits = 0,
uint64_t AlignInBits = 0,
StringRef UniqueIdentifier = "");
/// \brief Create a temporary forward-declared type.
DICompositeType createReplaceableCompositeType(
unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F,
unsigned Line, unsigned RuntimeLang = 0, uint64_t SizeInBits = 0,
MDCompositeType *createReplaceableCompositeType(
unsigned Tag, StringRef Name, MDScope *Scope, MDFile *F, unsigned Line,
unsigned RuntimeLang = 0, uint64_t SizeInBits = 0,
uint64_t AlignInBits = 0, unsigned Flags = DebugNode::FlagFwdDecl,
StringRef UniqueIdentifier = StringRef());
StringRef UniqueIdentifier = "");
/// retainType - Retain DIType in a module even if it is not referenced
/// retainType - Retain MDType* in a module even if it is not referenced
/// through debug info anchors.
void retainType(DIType T);
void retainType(MDType *T);
/// createUnspecifiedParameter - Create unspecified parameter type
/// for a subroutine type.
DIBasicType createUnspecifiedParameter();
MDBasicType *createUnspecifiedParameter();
/// getOrCreateArray - Get a DIArray, create one if required.
DIArray getOrCreateArray(ArrayRef<Metadata *> Elements);
@ -447,8 +423,7 @@ namespace llvm {
/// getOrCreateSubrange - Create a descriptor for a value range. This
/// implicitly uniques the values returned.
DISubrange getOrCreateSubrange(int64_t Lo, int64_t Count);
MDSubrange *getOrCreateSubrange(int64_t Lo, int64_t Count);
/// createGlobalVariable - Create a new descriptor for the specified
/// variable.
@ -462,19 +437,19 @@ namespace llvm {
/// externally visible or not.
/// @param Val llvm::Value of the variable.
/// @param Decl Reference to the corresponding declaration.
DIGlobalVariable createGlobalVariable(DIDescriptor Context, StringRef Name,
StringRef LinkageName, DIFile File,
unsigned LineNo, DIType Ty,
bool isLocalToUnit,
llvm::Constant *Val,
MDNode *Decl = nullptr);
MDGlobalVariable *createGlobalVariable(MDScope *Context, StringRef Name,
StringRef LinkageName, MDFile *File,
unsigned LineNo, MDType *Ty,
bool isLocalToUnit,
llvm::Constant *Val,
MDNode *Decl = nullptr);
/// createTempGlobalVariableFwdDecl - Identical to createGlobalVariable
/// except that the resulting DbgNode is temporary and meant to be RAUWed.
DIGlobalVariable createTempGlobalVariableFwdDecl(
DIDescriptor Context, StringRef Name, StringRef LinkageName,
DIFile File, unsigned LineNo, DIType Ty, bool isLocalToUnit,
llvm::Constant *Val, MDNode *Decl = nullptr);
MDGlobalVariable *createTempGlobalVariableFwdDecl(
MDScope *Context, StringRef Name, StringRef LinkageName, MDFile *File,
unsigned LineNo, MDType *Ty, bool isLocalToUnit, llvm::Constant *Val,
MDNode *Decl = nullptr);
/// createLocalVariable - Create a new descriptor for the specified
/// local variable.
@ -490,27 +465,29 @@ namespace llvm {
/// @param Flags Flags, e.g. artificial variable.
/// @param ArgNo If this variable is an argument then this argument's
/// number. 1 indicates 1st argument.
DIVariable createLocalVariable(unsigned Tag, DIDescriptor Scope,
StringRef Name, DIFile File, unsigned LineNo,
DIType Ty, bool AlwaysPreserve = false,
unsigned Flags = 0, unsigned ArgNo = 0);
MDLocalVariable *createLocalVariable(unsigned Tag, MDScope *Scope,
StringRef Name, MDFile *File,
unsigned LineNo, MDType *Ty,
bool AlwaysPreserve = false,
unsigned Flags = 0,
unsigned ArgNo = 0);
/// createExpression - Create a new descriptor for the specified
/// variable which has a complex address expression for its address.
/// @param Addr An array of complex address operations.
DIExpression createExpression(ArrayRef<uint64_t> Addr = None);
DIExpression createExpression(ArrayRef<int64_t> Addr);
MDExpression *createExpression(ArrayRef<uint64_t> Addr = None);
MDExpression *createExpression(ArrayRef<int64_t> Addr);
/// createBitPieceExpression - Create a descriptor to describe one part
/// of aggregate variable that is fragmented across multiple Values.
///
/// @param OffsetInBits Offset of the piece in bits.
/// @param SizeInBits Size of the piece in bits.
DIExpression createBitPieceExpression(unsigned OffsetInBits,
unsigned SizeInBits);
MDExpression *createBitPieceExpression(unsigned OffsetInBits,
unsigned SizeInBits);
/// createFunction - Create a new descriptor for the specified subprogram.
/// See comments in DISubprogram for descriptions of these fields.
/// See comments in MDSubprogram* for descriptions of these fields.
/// @param Scope Function scope.
/// @param Name Function name.
/// @param LinkageName Mangled function name.
@ -525,49 +502,35 @@ namespace llvm {
/// @param isOptimized True if optimization is ON.
/// @param Fn llvm::Function pointer.
/// @param TParam Function template parameters.
DISubprogram createFunction(DIDescriptor Scope, StringRef Name,
StringRef LinkageName,
DIFile File, unsigned LineNo,
DICompositeType Ty, bool isLocalToUnit,
bool isDefinition,
unsigned ScopeLine,
unsigned Flags = 0,
bool isOptimized = false,
Function *Fn = nullptr,
MDNode *TParam = nullptr,
MDNode *Decl = nullptr);
MDSubprogram *
createFunction(MDScope *Scope, StringRef Name, StringRef LinkageName,
MDFile *File, unsigned LineNo, MDSubroutineType *Ty,
bool isLocalToUnit, bool isDefinition, unsigned ScopeLine,
unsigned Flags = 0, bool isOptimized = false,
Function *Fn = nullptr, MDNode *TParam = nullptr,
MDNode *Decl = nullptr);
/// createTempFunctionFwdDecl - Identical to createFunction,
/// except that the resulting DbgNode is meant to be RAUWed.
DISubprogram createTempFunctionFwdDecl(DIDescriptor Scope, StringRef Name,
StringRef LinkageName,
DIFile File, unsigned LineNo,
DICompositeType Ty, bool isLocalToUnit,
bool isDefinition,
unsigned ScopeLine,
unsigned Flags = 0,
bool isOptimized = false,
Function *Fn = nullptr,
MDNode *TParam = nullptr,
MDNode *Decl = nullptr);
MDSubprogram *createTempFunctionFwdDecl(
MDScope *Scope, StringRef Name, StringRef LinkageName, MDFile *File,
unsigned LineNo, MDSubroutineType *Ty, bool isLocalToUnit,
bool isDefinition, unsigned ScopeLine, unsigned Flags = 0,
bool isOptimized = false, Function *Fn = nullptr,
MDNode *TParam = nullptr, MDNode *Decl = nullptr);
/// FIXME: this is added for dragonegg. Once we update dragonegg
/// to call resolve function, this will be removed.
DISubprogram createFunction(DIScopeRef Scope, StringRef Name,
StringRef LinkageName,
DIFile File, unsigned LineNo,
DICompositeType Ty, bool isLocalToUnit,
bool isDefinition,
unsigned ScopeLine,
unsigned Flags = 0,
bool isOptimized = false,
Function *Fn = nullptr,
MDNode *TParam = nullptr,
MDNode *Decl = nullptr);
MDSubprogram *
createFunction(DIScopeRef Scope, StringRef Name, StringRef LinkageName,
MDFile *File, unsigned LineNo, MDSubroutineType *Ty,
bool isLocalToUnit, bool isDefinition, unsigned ScopeLine,
unsigned Flags = 0, bool isOptimized = false,
Function *Fn = nullptr, MDNode *TParam = nullptr,
MDNode *Decl = nullptr);
/// createMethod - Create a new descriptor for the specified C++ method.
/// See comments in DISubprogram for descriptions of these fields.
/// See comments in MDSubprogram* for descriptions of these fields.
/// @param Scope Function scope.
/// @param Name Function name.
/// @param LinkageName Mangled function name.
@ -585,17 +548,13 @@ namespace llvm {
/// @param isOptimized True if optimization is ON.
/// @param Fn llvm::Function pointer.
/// @param TParam Function template parameters.
DISubprogram createMethod(DIDescriptor Scope, StringRef Name,
StringRef LinkageName,
DIFile File, unsigned LineNo,
DICompositeType Ty, bool isLocalToUnit,
bool isDefinition,
unsigned Virtuality = 0, unsigned VTableIndex = 0,
DIType VTableHolder = DIType(),
unsigned Flags = 0,
bool isOptimized = false,
Function *Fn = nullptr,
MDNode *TParam = nullptr);
MDSubprogram *
createMethod(MDScope *Scope, StringRef Name, StringRef LinkageName,
MDFile *File, unsigned LineNo, MDSubroutineType *Ty,
bool isLocalToUnit, bool isDefinition, unsigned Virtuality = 0,
unsigned VTableIndex = 0, MDType *VTableHolder = nullptr,
unsigned Flags = 0, bool isOptimized = false,
Function *Fn = nullptr, MDNode *TParam = nullptr);
/// createNameSpace - This creates new descriptor for a namespace
/// with the specified parent scope.
@ -603,9 +562,8 @@ namespace llvm {
/// @param Name Name of this namespace
/// @param File Source file
/// @param LineNo Line number
DINameSpace createNameSpace(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNo);
MDNamespace *createNameSpace(MDScope *Scope, StringRef Name, MDFile *File,
unsigned LineNo);
/// createLexicalBlockFile - This creates a descriptor for a lexical
/// block with a new file attached. This merely extends the existing
@ -613,8 +571,8 @@ namespace llvm {
/// @param Scope Lexical block.
/// @param File Source file.
/// @param Discriminator DWARF path discriminator value.
DILexicalBlockFile createLexicalBlockFile(DIDescriptor Scope, DIFile File,
unsigned Discriminator = 0);
MDLexicalBlockFile *createLexicalBlockFile(MDScope *Scope, MDFile *File,
unsigned Discriminator = 0);
/// createLexicalBlock - This creates a descriptor for a lexical block
/// with the specified parent context.
@ -622,35 +580,31 @@ namespace llvm {
/// @param File Source file.
/// @param Line Line number.
/// @param Col Column number.
DILexicalBlock createLexicalBlock(DIDescriptor Scope, DIFile File,
unsigned Line, unsigned Col);
MDLexicalBlock *createLexicalBlock(MDScope *Scope, MDFile *File,
unsigned Line, unsigned Col);
/// \brief Create a descriptor for an imported module.
/// @param Context The scope this module is imported into
/// @param NS The namespace being imported here
/// @param Line Line number
DIImportedEntity createImportedModule(DIScope Context, DINameSpace NS,
unsigned Line);
MDImportedEntity *createImportedModule(MDScope *Context, MDNamespace *NS,
unsigned Line);
/// \brief Create a descriptor for an imported module.
/// @param Context The scope this module is imported into
/// @param NS An aliased namespace
/// @param Line Line number
DIImportedEntity createImportedModule(DIScope Context, DIImportedEntity NS,
unsigned Line);
MDImportedEntity *createImportedModule(MDScope *Context,
MDImportedEntity *NS, unsigned Line);
/// \brief Create a descriptor for an imported function.
/// @param Context The scope this module is imported into
/// @param Decl The declaration (or definition) of a function, type, or
/// variable
/// @param Line Line number
DIImportedEntity createImportedDeclaration(DIScope Context, DIDescriptor Decl,
unsigned Line,
StringRef Name = StringRef());
DIImportedEntity createImportedDeclaration(DIScope Context,
DIImportedEntity NS,
unsigned Line,
StringRef Name = StringRef());
MDImportedEntity *createImportedDeclaration(MDScope *Context,
DebugNode *Decl, unsigned Line,
StringRef Name = "");
/// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
/// @param Storage llvm::Value of the variable
@ -658,8 +612,8 @@ namespace llvm {
/// @param Expr A complex location expression.
/// @param DL Debug info location.
/// @param InsertAtEnd Location for the new intrinsic.
Instruction *insertDeclare(llvm::Value *Storage, DIVariable VarInfo,
DIExpression Expr, const MDLocation *DL,
Instruction *insertDeclare(llvm::Value *Storage, MDLocalVariable *VarInfo,
MDExpression *Expr, const MDLocation *DL,
BasicBlock *InsertAtEnd);
/// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
@ -668,8 +622,8 @@ namespace llvm {
/// @param Expr A complex location expression.
/// @param DL Debug info location.
/// @param InsertBefore Location for the new intrinsic.
Instruction *insertDeclare(llvm::Value *Storage, DIVariable VarInfo,
DIExpression Expr, const MDLocation *DL,
Instruction *insertDeclare(llvm::Value *Storage, MDLocalVariable *VarInfo,
MDExpression *Expr, const MDLocation *DL,
Instruction *InsertBefore);
/// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
@ -680,7 +634,8 @@ namespace llvm {
/// @param DL Debug info location.
/// @param InsertAtEnd Location for the new intrinsic.
Instruction *insertDbgValueIntrinsic(llvm::Value *Val, uint64_t Offset,
DIVariable VarInfo, DIExpression Expr,
MDLocalVariable *VarInfo,
MDExpression *Expr,
const MDLocation *DL,
BasicBlock *InsertAtEnd);
@ -692,7 +647,8 @@ namespace llvm {
/// @param DL Debug info location.
/// @param InsertBefore Location for the new intrinsic.
Instruction *insertDbgValueIntrinsic(llvm::Value *Val, uint64_t Offset,
DIVariable VarInfo, DIExpression Expr,
MDLocalVariable *VarInfo,
MDExpression *Expr,
const MDLocation *DL,
Instruction *InsertBefore);
@ -700,14 +656,15 @@ namespace llvm {
///
/// If this creates a self reference, it may orphan some unresolved cycles
/// in the operands of \c T, so \a DIBuilder needs to track that.
void replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder);
void replaceVTableHolder(MDCompositeType *&T,
MDCompositeType *VTableHolder);
/// \brief Replace arrays on a composite type.
///
/// If \c T is resolved, but the arrays aren't -- which can happen if \c T
/// has a self-reference -- \a DIBuilder needs to track the array to
/// resolve cycles.
void replaceArrays(DICompositeType &T, DIArray Elements,
void replaceArrays(MDCompositeType *&T, DIArray Elements,
DIArray TParems = DIArray());
/// \brief Replace a temporary node.

450
lib/IR/DIBuilder.cpp
View File

@ -74,8 +74,7 @@ void DIBuilder::trackIfUnresolved(MDNode *N) {
}
void DIBuilder::finalize() {
DIArray Enums = getOrCreateArray(AllEnumTypes);
TempEnumTypes->replaceAllUsesWith(Enums.get());
TempEnumTypes->replaceAllUsesWith(MDTuple::get(VMContext, AllEnumTypes));
SmallVector<Metadata *, 16> RetainValues;
// Declarations and definitions of the same type may be retained. Some
@ -86,13 +85,11 @@ void DIBuilder::finalize() {
for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
if (RetainSet.insert(AllRetainTypes[I]).second)
RetainValues.push_back(AllRetainTypes[I]);
DIArray RetainTypes = getOrCreateArray(RetainValues);
TempRetainTypes->replaceAllUsesWith(RetainTypes.get());
TempRetainTypes->replaceAllUsesWith(MDTuple::get(VMContext, RetainValues));
DIArray SPs = getOrCreateArray(AllSubprograms);
MDSubprogramArray SPs = MDTuple::get(VMContext, AllSubprograms);
TempSubprograms->replaceAllUsesWith(SPs.get());
for (unsigned i = 0, e = SPs.size(); i != e; ++i) {
DISubprogram SP = cast<MDSubprogram>(SPs[i]);
for (auto *SP : SPs) {
if (MDTuple *Temp = SP->getVariables().get()) {
const auto &PV = PreservedVariables.lookup(SP);
SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
@ -101,13 +98,11 @@ void DIBuilder::finalize() {
}
}
DIArray GVs = getOrCreateArray(AllGVs);
TempGVs->replaceAllUsesWith(GVs.get());
TempGVs->replaceAllUsesWith(MDTuple::get(VMContext, AllGVs));
SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
AllImportedModules.end());
DIArray IMs = getOrCreateArray(RetainValuesI);
TempImportedModules->replaceAllUsesWith(IMs.get());
TempImportedModules->replaceAllUsesWith(MDTuple::get(
VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
AllImportedModules.end())));
// Now that all temp nodes have been replaced or deleted, resolve remaining
// cycles.
@ -121,19 +116,16 @@ void DIBuilder::finalize() {
}
/// If N is compile unit return NULL otherwise return N.
static MDScope *getNonCompileUnitScope(MDNode *N) {
static MDScope *getNonCompileUnitScope(MDScope *N) {
if (!N || isa<MDCompileUnit>(N))
return nullptr;
return cast<MDScope>(N);
}
DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
StringRef Directory,
StringRef Producer, bool isOptimized,
StringRef Flags, unsigned RunTimeVer,
StringRef SplitName,
DebugEmissionKind Kind,
bool EmitDebugInfo) {
MDCompileUnit *DIBuilder::createCompileUnit(
unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer,
bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
DebugEmissionKind Kind, bool EmitDebugInfo) {
assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
(Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
@ -171,113 +163,107 @@ DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
return CUNode;
}
static DIImportedEntity
createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
static MDImportedEntity*
createImportedModule(LLVMContext &C, dwarf::Tag Tag, MDScope* Context,
Metadata *NS, unsigned Line, StringRef Name,
SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
DIImportedEntity M =
auto *M =
MDImportedEntity::get(C, Tag, Context, DebugNodeRef(NS), Line, Name);
AllImportedModules.emplace_back(M);
return M;
}
DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
DINameSpace NS,
MDImportedEntity* DIBuilder::createImportedModule(MDScope* Context,
MDNamespace* NS,
unsigned Line) {
return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
Context, NS, Line, StringRef(), AllImportedModules);
}
DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
DIImportedEntity NS,
MDImportedEntity* DIBuilder::createImportedModule(MDScope* Context,
MDImportedEntity* NS,
unsigned Line) {
return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
Context, NS, Line, StringRef(), AllImportedModules);
}
DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
DIDescriptor Decl,
unsigned Line,
StringRef Name) {
MDImportedEntity *DIBuilder::createImportedDeclaration(MDScope *Context,
DebugNode *Decl,
unsigned Line,
StringRef Name) {
// Make sure to use the unique identifier based metadata reference for
// types that have one.
return ::createImportedModule(
VMContext, dwarf::DW_TAG_imported_declaration, Context,
DebugNodeRef::get(cast_or_null<DebugNode>(Decl)), Line, Name,
AllImportedModules);
}
DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
DIImportedEntity Imp,
unsigned Line, StringRef Name) {
return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
Context, Imp, Line, Name, AllImportedModules);
Context, DebugNodeRef::get(Decl), Line, Name,
AllImportedModules);
}
DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
MDFile* DIBuilder::createFile(StringRef Filename, StringRef Directory) {
return MDFile::get(VMContext, Filename, Directory);
}
DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
MDEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
assert(!Name.empty() && "Unable to create enumerator without name");
return MDEnumerator::get(VMContext, Val, Name);
}
DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
MDBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
assert(!Name.empty() && "Unable to create type without name");
return MDBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
}
DIBasicType DIBuilder::createNullPtrType() {
MDBasicType *DIBuilder::createNullPtrType() {
return createUnspecifiedType("decltype(nullptr)");
}
DIBasicType
DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
uint64_t AlignInBits, unsigned Encoding) {
MDBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
uint64_t AlignInBits,
unsigned Encoding) {
assert(!Name.empty() && "Unable to create type without name");
return MDBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
AlignInBits, Encoding);
}
DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
MDDerivedType *DIBuilder::createQualifiedType(unsigned Tag, MDType *FromTy) {
return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
MDTypeRef::get(FromTy), 0, 0, 0, 0);
}
DIDerivedType
DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
uint64_t AlignInBits, StringRef Name) {
MDDerivedType *DIBuilder::createPointerType(MDType *PointeeTy,
uint64_t SizeInBits,
uint64_t AlignInBits,
StringRef Name) {
// FIXME: Why is there a name here?
return MDDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
SizeInBits, AlignInBits, 0, 0);
}
DIDerivedType
DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
uint64_t SizeInBits, uint64_t AlignInBits) {
MDDerivedType *DIBuilder::createMemberPointerType(MDType *PointeeTy,
MDType *Base,
uint64_t SizeInBits,
uint64_t AlignInBits) {
return MDDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
SizeInBits, AlignInBits, 0, 0, MDTypeRef::get(Base));
}
DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
MDDerivedType *DIBuilder::createReferenceType(unsigned Tag, MDType *RTy) {
assert(RTy && "Unable to create reference type");
return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
MDTypeRef::get(RTy), 0, 0, 0, 0);
}
DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
unsigned LineNo, DIDescriptor Context) {
return MDDerivedType::get(
VMContext, dwarf::DW_TAG_typedef, Name, File, LineNo,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
MDTypeRef::get(Ty), 0, 0, 0, 0);
MDDerivedType *DIBuilder::createTypedef(MDType *Ty, StringRef Name,
MDFile *File, unsigned LineNo,
MDScope *Context) {
return MDDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name, File,
LineNo,
MDScopeRef::get(getNonCompileUnitScope(Context)),
MDTypeRef::get(Ty), 0, 0, 0, 0);
}
DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
// typedefs are encoded in DIDerivedType format.
MDDerivedType *DIBuilder::createFriend(MDType *Ty, MDType *FriendTy) {
assert(Ty && "Invalid type!");
assert(FriendTy && "Invalid friend type!");
return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0,
@ -285,25 +271,25 @@ DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
0, 0);
}
DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
uint64_t BaseOffset,
unsigned Flags) {
MDDerivedType *DIBuilder::createInheritance(MDType *Ty, MDType *BaseTy,
uint64_t BaseOffset,
unsigned Flags) {
assert(Ty && "Unable to create inheritance");
return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
0, MDTypeRef::get(Ty), MDTypeRef::get(BaseTy), 0, 0,
BaseOffset, Flags);
}
DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
DIType Ty) {
MDDerivedType *DIBuilder::createMemberType(MDScope *Scope, StringRef Name,
MDFile *File, unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits,
uint64_t OffsetInBits,
unsigned Flags, MDType *Ty) {
return MDDerivedType::get(
VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
MDTypeRef::get(Ty), SizeInBits, AlignInBits, OffsetInBits, Flags);
MDScopeRef::get(getNonCompileUnitScope(Scope)), MDTypeRef::get(Ty),
SizeInBits, AlignInBits, OffsetInBits, Flags);
}
static ConstantAsMetadata *getConstantOrNull(Constant *C) {
@ -312,95 +298,89 @@ static ConstantAsMetadata *getConstantOrNull(Constant *C) {
return nullptr;
}
DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
StringRef Name, DIFile File,
unsigned LineNumber, DIType Ty,
unsigned Flags,
llvm::Constant *Val) {
// TAG_member is encoded in DIDerivedType format.
MDDerivedType *DIBuilder::createStaticMemberType(MDScope *Scope, StringRef Name,
MDFile *File,
unsigned LineNumber,
MDType *Ty, unsigned Flags,
llvm::Constant *Val) {
Flags |= DebugNode::FlagStaticMember;
return MDDerivedType::get(
VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
MDTypeRef::get(Ty), 0, 0, 0, Flags, getConstantOrNull(Val));
MDScopeRef::get(getNonCompileUnitScope(Scope)), MDTypeRef::get(Ty), 0, 0,
0, Flags, getConstantOrNull(Val));
}
DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
DIType Ty, MDNode *PropertyNode) {
MDDerivedType *DIBuilder::createObjCIVar(StringRef Name, MDFile *File,
unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
MDType *Ty, MDNode *PropertyNode) {
return MDDerivedType::get(
VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
MDScopeRef::get(getNonCompileUnitScope(File)), MDTypeRef::get(Ty),
SizeInBits, AlignInBits, OffsetInBits, Flags, PropertyNode);
}
DIObjCProperty
DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
MDObjCProperty *
DIBuilder::createObjCProperty(StringRef Name, MDFile *File, unsigned LineNumber,
StringRef GetterName, StringRef SetterName,
unsigned PropertyAttributes, DIType Ty) {
unsigned PropertyAttributes, MDType *Ty) {
return MDObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
SetterName, PropertyAttributes, Ty);
}
DITemplateTypeParameter
DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
DIType Ty) {
MDTemplateTypeParameter *
DIBuilder::createTemplateTypeParameter(MDScope *Context, StringRef Name,
MDType *Ty) {
assert((!Context || isa<MDCompileUnit>(Context)) && "Expected compile unit");
return MDTemplateTypeParameter::get(VMContext, Name, MDTypeRef::get(Ty));
}
static DITemplateValueParameter
static MDTemplateValueParameter *
createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
DIDescriptor Context, StringRef Name,
DIType Ty, Metadata *MD) {
MDScope *Context, StringRef Name, MDType *Ty,
Metadata *MD) {
assert((!Context || isa<MDCompileUnit>(Context)) && "Expected compile unit");
return MDTemplateValueParameter::get(VMContext, Tag, Name, MDTypeRef::get(Ty),
MD);
}
DITemplateValueParameter
DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
DIType Ty, Constant *Val) {
MDTemplateValueParameter *
DIBuilder::createTemplateValueParameter(MDScope *Context, StringRef Name,
MDType *Ty, Constant *Val) {
return createTemplateValueParameterHelper(
VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
getConstantOrNull(Val));
}
DITemplateValueParameter
DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
DIType Ty, StringRef Val) {
MDTemplateValueParameter *
DIBuilder::createTemplateTemplateParameter(MDScope *Context, StringRef Name,
MDType *Ty, StringRef Val) {
return createTemplateValueParameterHelper(
VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
MDString::get(VMContext, Val));
}
DITemplateValueParameter
DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
DIType Ty, DIArray Val) {
MDTemplateValueParameter *
DIBuilder::createTemplateParameterPack(MDScope *Context, StringRef Name,
MDType *Ty, DIArray Val) {
return createTemplateValueParameterHelper(
VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
Val.get());
}
DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
DIFile File, unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits,
uint64_t OffsetInBits,
unsigned Flags, DIType DerivedFrom,
DIArray Elements,
DIType VTableHolder,
MDNode *TemplateParams,
StringRef UniqueIdentifier) {
MDCompositeType *DIBuilder::createClassType(
MDScope *Context, StringRef Name, MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
unsigned Flags, MDType *DerivedFrom, DIArray Elements, MDType *VTableHolder,
MDNode *TemplateParams, StringRef UniqueIdentifier) {
assert((!Context || isa<MDScope>(Context)) &&
"createClassType should be called with a valid Context");
// TAG_class_type is encoded in DICompositeType format.
DICompositeType R = MDCompositeType::get(
auto *R = MDCompositeType::get(
VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
MDScopeRef::get(getNonCompileUnitScope(Context)),
MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, OffsetInBits, Flags,
Elements, 0, MDTypeRef::get(VTableHolder),
cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
@ -410,19 +390,14 @@ DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
return R;
}
DICompositeType DIBuilder::createStructType(DIDescriptor Context,
StringRef Name, DIFile File,
unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits,
unsigned Flags, DIType DerivedFrom,
DIArray Elements,
unsigned RunTimeLang,
DIType VTableHolder,
StringRef UniqueIdentifier) {
DICompositeType R = MDCompositeType::get(
MDCompositeType *DIBuilder::createStructType(
MDScope *Context, StringRef Name, MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
MDType *DerivedFrom, DIArray Elements, unsigned RunTimeLang,
MDType *VTableHolder, StringRef UniqueIdentifier) {
auto *R = MDCompositeType::get(
VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
MDScopeRef::get(getNonCompileUnitScope(Context)),
MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, 0, Flags, Elements,
RunTimeLang, MDTypeRef::get(VTableHolder), nullptr, UniqueIdentifier);
if (!UniqueIdentifier.empty())
@ -431,37 +406,37 @@ DICompositeType DIBuilder::createStructType(DIDescriptor Context,
return R;
}
DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNumber,
MDCompositeType* DIBuilder::createUnionType(MDScope * Scope, StringRef Name,
MDFile* File, unsigned LineNumber,
uint64_t SizeInBits,
uint64_t AlignInBits, unsigned Flags,
DIArray Elements,
unsigned RunTimeLang,
StringRef UniqueIdentifier) {
DICompositeType R = MDCompositeType::get(
auto *R = MDCompositeType::get(
VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
SizeInBits, AlignInBits, 0, Flags, Elements, RunTimeLang, nullptr,
nullptr, UniqueIdentifier);
MDScopeRef::get(getNonCompileUnitScope(Scope)), nullptr, SizeInBits,
AlignInBits, 0, Flags, Elements, RunTimeLang, nullptr, nullptr,
UniqueIdentifier);
if (!UniqueIdentifier.empty())
retainType(R);
trackIfUnresolved(R);
return R;
}
DISubroutineType DIBuilder::createSubroutineType(DIFile File,
DITypeArray ParameterTypes,
unsigned Flags) {
MDSubroutineType *DIBuilder::createSubroutineType(MDFile *File,
DITypeArray ParameterTypes,
unsigned Flags) {
return MDSubroutineType::get(VMContext, Flags, ParameterTypes);
}
DICompositeType DIBuilder::createEnumerationType(
DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
MDCompositeType *DIBuilder::createEnumerationType(
MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
DIType UnderlyingType, StringRef UniqueIdentifier) {
DICompositeType CTy = MDCompositeType::get(
MDType *UnderlyingType, StringRef UniqueIdentifier) {
auto *CTy = MDCompositeType::get(
VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
MDScopeRef::get(getNonCompileUnitScope(Scope)),
MDTypeRef::get(UnderlyingType), SizeInBits, AlignInBits, 0, 0, Elements,
0, nullptr, nullptr, UniqueIdentifier);
AllEnumTypes.push_back(CTy);
@ -471,8 +446,8 @@ DICompositeType DIBuilder::createEnumerationType(
return CTy;
}
DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
DIType Ty, DIArray Subscripts) {
MDCompositeType *DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
MDType *Ty, DIArray Subscripts) {
auto *R = MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
nullptr, 0, nullptr, MDTypeRef::get(Ty), Size,
AlignInBits, 0, 0, Subscripts, 0, nullptr);
@ -480,8 +455,9 @@ DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
return R;
}
DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
DIType Ty, DIArray Subscripts) {
MDCompositeType *DIBuilder::createVectorType(uint64_t Size,
uint64_t AlignInBits, MDType *Ty,
DIArray Subscripts) {
auto *R =
MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0,
nullptr, MDTypeRef::get(Ty), Size, AlignInBits, 0,
@ -490,21 +466,21 @@ DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
return R;
}
static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
unsigned FlagsToSet) {
TempMDType NewTy = cast<MDType>(static_cast<MDNode *>(Ty))->clone();
static MDType *createTypeWithFlags(LLVMContext &Context, MDType *Ty,
unsigned FlagsToSet) {
auto NewTy = Ty->clone();
NewTy->setFlags(NewTy->getFlags() | FlagsToSet);
return MDNode::replaceWithUniqued(std::move(NewTy));
}
DIType DIBuilder::createArtificialType(DIType Ty) {
MDType *DIBuilder::createArtificialType(MDType *Ty) {
// FIXME: Restrict this to the nodes where it's valid.
if (Ty->isArtificial())
return Ty;
return createTypeWithFlags(VMContext, Ty, DebugNode::FlagArtificial);
}
DIType DIBuilder::createObjectPointerType(DIType Ty) {
MDType *DIBuilder::createObjectPointerType(MDType *Ty) {
// FIXME: Restrict this to the nodes where it's valid.
if (Ty->isObjectPointer())
return Ty;
@ -512,42 +488,40 @@ DIType DIBuilder::createObjectPointerType(DIType Ty) {
return createTypeWithFlags(VMContext, Ty, Flags);
}
void DIBuilder::retainType(DIType T) {
void DIBuilder::retainType(MDType *T) {
assert(T && "Expected non-null type");
AllRetainTypes.emplace_back(T);
}
DIBasicType DIBuilder::createUnspecifiedParameter() { return nullptr; }
MDBasicType *DIBuilder::createUnspecifiedParameter() { return nullptr; }
DICompositeType
DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
DIFile F, unsigned Line, unsigned RuntimeLang,
MDCompositeType*
DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, MDScope * Scope,
MDFile* F, unsigned Line, unsigned RuntimeLang,
uint64_t SizeInBits, uint64_t AlignInBits,
StringRef UniqueIdentifier) {
// FIXME: Define in terms of createReplaceableForwardDecl() by calling
// replaceWithUniqued().
DICompositeType RetTy = MDCompositeType::get(
auto *RetTy = MDCompositeType::get(
VMContext, Tag, Name, F, Line,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
SizeInBits, AlignInBits, 0, DebugNode::FlagFwdDecl, nullptr, RuntimeLang,
nullptr, nullptr, UniqueIdentifier);
MDScopeRef::get(getNonCompileUnitScope(Scope)), nullptr, SizeInBits,
AlignInBits, 0, DebugNode::FlagFwdDecl, nullptr, RuntimeLang, nullptr,
nullptr, UniqueIdentifier);
if (!UniqueIdentifier.empty())
retainType(RetTy);
trackIfUnresolved(RetTy);
return RetTy;
}
DICompositeType DIBuilder::createReplaceableCompositeType(
unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
MDCompositeType* DIBuilder::createReplaceableCompositeType(
unsigned Tag, StringRef Name, MDScope * Scope, MDFile* F, unsigned Line,
unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
unsigned Flags, StringRef UniqueIdentifier) {
DICompositeType RetTy =
MDCompositeType::getTemporary(
VMContext, Tag, Name, F, Line,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
nullptr, UniqueIdentifier)
.release();
auto *RetTy = MDCompositeType::getTemporary(
VMContext, Tag, Name, F, Line,
MDScopeRef::get(getNonCompileUnitScope(Scope)), nullptr,
SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang,
nullptr, nullptr, UniqueIdentifier).release();
if (!UniqueIdentifier.empty())
retainType(RetTy);
trackIfUnresolved(RetTy);
@ -555,7 +529,7 @@ DICompositeType DIBuilder::createReplaceableCompositeType(
}
DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
return DIArray(MDNode::get(VMContext, Elements));
return MDTuple::get(VMContext, Elements);
}
DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
@ -569,11 +543,11 @@ DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
return DITypeArray(MDNode::get(VMContext, Elts));
}
DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
MDSubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
return MDSubrange::get(VMContext, Count, Lo);
}
static void checkGlobalVariableScope(DIDescriptor Context) {
static void checkGlobalVariableScope(MDScope * Context) {
#ifndef NDEBUG
if (auto *CT =
dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
@ -582,9 +556,9 @@ static void checkGlobalVariableScope(DIDescriptor Context) {
#endif
}
DIGlobalVariable DIBuilder::createGlobalVariable(
DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
MDGlobalVariable *DIBuilder::createGlobalVariable(
MDScope *Context, StringRef Name, StringRef LinkageName, MDFile *F,
unsigned LineNumber, MDType *Ty, bool isLocalToUnit, Constant *Val,
MDNode *Decl) {
checkGlobalVariableScope(Context);
@ -596,9 +570,9 @@ DIGlobalVariable DIBuilder::createGlobalVariable(
return N;
}
DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
MDGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
MDScope *Context, StringRef Name, StringRef LinkageName, MDFile *F,
unsigned LineNumber, MDType *Ty, bool isLocalToUnit, Constant *Val,
MDNode *Decl) {
checkGlobalVariableScope(Context);
@ -609,16 +583,14 @@ DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
.release();
}
DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
StringRef Name, DIFile File,
unsigned LineNo, DIType Ty,
bool AlwaysPreserve, unsigned Flags,
unsigned ArgNo) {
MDLocalVariable *DIBuilder::createLocalVariable(
unsigned Tag, MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNo,
MDType *Ty, bool AlwaysPreserve, unsigned Flags, unsigned ArgNo) {
// FIXME: Why getNonCompileUnitScope()?
// FIXME: Why is "!Context" okay here?
// FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
// the only valid scopes)?
DIScope Context = getNonCompileUnitScope(Scope);
MDScope* Context = getNonCompileUnitScope(Scope);
auto *Node = MDLocalVariable::get(
VMContext, Tag, cast_or_null<MDLocalScope>(Context), Name, File, LineNo,
@ -627,32 +599,32 @@ DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
// The optimizer may remove local variable. If there is an interest
// to preserve variable info in such situation then stash it in a
// named mdnode.
DISubprogram Fn(getDISubprogram(Scope));
MDSubprogram *Fn = getDISubprogram(Scope);
assert(Fn && "Missing subprogram for local variable");
PreservedVariables[Fn].emplace_back(Node);
}
return Node;
}
DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
MDExpression* DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
return MDExpression::get(VMContext, Addr);
}
DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
MDExpression* DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
// TODO: Remove the callers of this signed version and delete.
SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
return createExpression(Addr);
}
DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
MDExpression* DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
unsigned SizeInBytes) {
uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
return MDExpression::get(VMContext, Addr);
}
DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
StringRef LinkageName, DIFile File,
unsigned LineNo, DICompositeType Ty,
MDSubprogram* DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
StringRef LinkageName, MDFile* File,
unsigned LineNo, MDSubroutineType* Ty,
bool isLocalToUnit, bool isDefinition,
unsigned ScopeLine, unsigned Flags,
bool isOptimized, Function *Fn,
@ -665,9 +637,9 @@ DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
Flags, isOptimized, Fn, TParams, Decl);
}
DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
StringRef LinkageName, DIFile File,
unsigned LineNo, DICompositeType Ty,
MDSubprogram* DIBuilder::createFunction(MDScope * Context, StringRef Name,
StringRef LinkageName, MDFile* File,
unsigned LineNo, MDSubroutineType* Ty,
bool isLocalToUnit, bool isDefinition,
unsigned ScopeLine, unsigned Flags,
bool isOptimized, Function *Fn,
@ -675,8 +647,8 @@ DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
assert(Ty->getTag() == dwarf::DW_TAG_subroutine_type &&
"function types should be subroutines");
auto *Node = MDSubprogram::get(
VMContext, MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
Name, LinkageName, File, LineNo, cast_or_null<MDSubroutineType>(Ty),
VMContext, MDScopeRef::get(getNonCompileUnitScope(Context)), Name,
LinkageName, File, LineNo, Ty,
isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags, isOptimized,
Fn, cast_or_null<MDTuple>(TParams), cast_or_null<MDSubprogram>(Decl),
MDTuple::getTemporary(VMContext, None).release());
@ -687,32 +659,28 @@ DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
return Node;
}
DISubprogram
DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
StringRef LinkageName, DIFile File,
unsigned LineNo, DICompositeType Ty,
MDSubprogram*
DIBuilder::createTempFunctionFwdDecl(MDScope * Context, StringRef Name,
StringRef LinkageName, MDFile* File,
unsigned LineNo, MDSubroutineType* Ty,
bool isLocalToUnit, bool isDefinition,
unsigned ScopeLine, unsigned Flags,
bool isOptimized, Function *Fn,
MDNode *TParams, MDNode *Decl) {
return MDSubprogram::getTemporary(
VMContext,
MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))), Name,
LinkageName, File, LineNo, cast_or_null<MDSubroutineType>(Ty),
VMContext, MDScopeRef::get(getNonCompileUnitScope(Context)), Name,
LinkageName, File, LineNo, Ty,
isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags,
isOptimized, Fn, cast_or_null<MDTuple>(TParams),
cast_or_null<MDSubprogram>(Decl), nullptr)
.release();
cast_or_null<MDSubprogram>(Decl), nullptr).release();
}
DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
StringRef LinkageName, DIFile F,
unsigned LineNo, DICompositeType Ty,
bool isLocalToUnit, bool isDefinition,
unsigned VK, unsigned VIndex,
DIType VTableHolder, unsigned Flags,
bool isOptimized, Function *Fn,
MDNode *TParam) {
MDSubprogram *
DIBuilder::createMethod(MDScope *Context, StringRef Name, StringRef LinkageName,
MDFile *F, unsigned LineNo, MDSubroutineType *Ty,
bool isLocalToUnit, bool isDefinition, unsigned VK,
unsigned VIndex, MDType *VTableHolder, unsigned Flags,
bool isOptimized, Function *Fn, MDNode *TParam) {
assert(Ty->getTag() == dwarf::DW_TAG_subroutine_type &&
"function types should be subroutines");
assert(getNonCompileUnitScope(Context) &&
@ -721,8 +689,8 @@ DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
// FIXME: Do we want to use different scope/lines?
auto *SP = MDSubprogram::get(
VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName, F,
LineNo, cast_or_null<MDSubroutineType>(Ty), isLocalToUnit, isDefinition,
LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags, isOptimized, Fn,
LineNo, Ty, isLocalToUnit, isDefinition, LineNo,
MDTypeRef::get(VTableHolder), VK, VIndex, Flags, isOptimized, Fn,
cast_or_null<MDTuple>(TParam), nullptr, nullptr);
if (isDefinition)
@ -731,19 +699,19 @@ DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
return SP;
}
DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNo) {
MDNamespace* DIBuilder::createNameSpace(MDScope * Scope, StringRef Name,
MDFile* File, unsigned LineNo) {
return MDNamespace::get(VMContext, getNonCompileUnitScope(Scope), File, Name,
LineNo);
}
DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
DIFile File,
MDLexicalBlockFile* DIBuilder::createLexicalBlockFile(MDScope * Scope,
MDFile* File,
unsigned Discriminator) {
return MDLexicalBlockFile::get(VMContext, Scope, File, Discriminator);
}
DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
MDLexicalBlock* DIBuilder::createLexicalBlock(MDScope * Scope, MDFile* File,
unsigned Line, unsigned Col) {
// Make these distinct, to avoid merging two lexical blocks on the same
// file/line/column.
@ -761,10 +729,10 @@ static Instruction *withDebugLoc(Instruction *I, const MDLocation *DL) {
return I;
}
Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
DIExpression Expr, const MDLocation *DL,
Instruction *DIBuilder::insertDeclare(Value *Storage, MDLocalVariable* VarInfo,
MDExpression* Expr, const MDLocation *DL,
Instruction *InsertBefore) {
assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
assert(VarInfo && "empty or invalid MDLocalVariable* passed to dbg.declare");
assert(DL && "Expected debug loc");
assert(DL->getScope()->getSubprogram() ==
VarInfo->getScope()->getSubprogram() &&
@ -780,10 +748,10 @@ Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertBefore), DL);
}
Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
DIExpression Expr, const MDLocation *DL,
Instruction *DIBuilder::insertDeclare(Value *Storage, MDLocalVariable* VarInfo,
MDExpression* Expr, const MDLocation *DL,
BasicBlock *InsertAtEnd) {
assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
assert(VarInfo && "empty or invalid MDLocalVariable* passed to dbg.declare");
assert(DL && "Expected debug loc");
assert(DL->getScope()->getSubprogram() ==
VarInfo->getScope()->getSubprogram() &&
@ -805,12 +773,12 @@ Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
}
Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
DIVariable VarInfo,
DIExpression Expr,
MDLocalVariable* VarInfo,
MDExpression* Expr,
const MDLocation *DL,
Instruction *InsertBefore) {
assert(V && "no value passed to dbg.value");
assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
assert(VarInfo && "empty or invalid MDLocalVariable* passed to dbg.value");
assert(DL && "Expected debug loc");
assert(DL->getScope()->getSubprogram() ==
VarInfo->getScope()->getSubprogram() &&
@ -828,12 +796,12 @@ Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
}
Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
DIVariable VarInfo,
DIExpression Expr,
MDLocalVariable* VarInfo,
MDExpression* Expr,
const MDLocation *DL,
BasicBlock *InsertAtEnd) {
assert(V && "no value passed to dbg.value");
assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
assert(VarInfo && "empty or invalid MDLocalVariable* passed to dbg.value");
assert(DL && "Expected debug loc");
assert(DL->getScope()->getSubprogram() ==
VarInfo->getScope()->getSubprogram() &&
@ -851,9 +819,9 @@ Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertAtEnd), DL);
}
void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
void DIBuilder::replaceVTableHolder(MDCompositeType* &T, MDCompositeType* VTableHolder) {
{
TypedTrackingMDRef<MDCompositeTypeBase> N(T);
TypedTrackingMDRef<MDCompositeType> N(T);
N->replaceVTableHolder(MDTypeRef::get(VTableHolder));
T = N.get();
}
@ -870,10 +838,10 @@ void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHo
trackIfUnresolved(N);
}
void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
void DIBuilder::replaceArrays(MDCompositeType* &T, DIArray Elements,
DIArray TParams) {
{
TypedTrackingMDRef<MDCompositeTypeBase> N(T);
TypedTrackingMDRef<MDCompositeType> N(T);
if (Elements)
N->replaceElements(Elements);
if (TParams)

3
unittests/Transforms/Utils/Cloning.cpp
View File

@ -230,7 +230,8 @@ protected:
// Function DI
DIFile File = DBuilder.createFile("filename.c", "/file/dir/");
DITypeArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
DICompositeType FuncType = DBuilder.createSubroutineType(File, ParamTypes);
MDSubroutineType *FuncType =
DBuilder.createSubroutineType(File, ParamTypes);
DICompileUnit CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
"filename.c", "/file/dir", "CloneFunc", false, "", 0);