Author: Tobias Gysi Date: 2024-08-31T07:44:01+02:00 New Revision: dcb1265cdefd5e712a395cbcac632f8898ba4e2d
URL: https://github.com/llvm/llvm-project/commit/dcb1265cdefd5e712a395cbcac632f8898ba4e2d DIFF: https://github.com/llvm/llvm-project/commit/dcb1265cdefd5e712a395cbcac632f8898ba4e2d.diff LOG: Revert "[MLIR][LLVM] Make DISubprogramAttr cyclic (#106571)" This reverts commit d884b77c662374bd779ccbf20ba3b31cb9949a18. Added: Modified: flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp mlir/include/mlir-c/Dialect/LLVM.h mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td mlir/lib/CAPI/Dialect/LLVM.cpp mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp mlir/lib/Target/LLVMIR/DebugImporter.cpp mlir/lib/Target/LLVMIR/DebugTranslation.cpp mlir/lib/Target/LLVMIR/DebugTranslation.h mlir/test/CAPI/llvm.c mlir/test/Target/LLVMIR/Import/debug-info.ll mlir/test/Target/LLVMIR/llvmir-debug.mlir Removed: ################################################################################ diff --git a/flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp b/flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp index 029d3776bcc0b8..54f2a12d800085 100644 --- a/flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp +++ b/flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp @@ -146,8 +146,8 @@ mlir::LLVM::DITypeAttr DebugTypeGenerator::convertBoxedSequenceType( elements.push_back(subrangeTy); } return mlir::LLVM::DICompositeTypeAttr::get( - context, llvm::dwarf::DW_TAG_array_type, /*name=*/nullptr, - /*file=*/nullptr, /*line=*/0, /*scope=*/nullptr, elemTy, + context, llvm::dwarf::DW_TAG_array_type, /*recursive_id=*/{}, + /*name=*/nullptr, /*file=*/nullptr, /*line=*/0, /*scope=*/nullptr, elemTy, mlir::LLVM::DIFlags::Zero, /*sizeInBits=*/0, /*alignInBits=*/0, elements, dataLocation, /*rank=*/nullptr, allocated, associated); } @@ -188,7 +188,7 @@ mlir::LLVM::DITypeAttr DebugTypeGenerator::convertRecordType( } return mlir::LLVM::DICompositeTypeAttr::get( - context, llvm::dwarf::DW_TAG_structure_type, + context, llvm::dwarf::DW_TAG_structure_type, /*recursive_id=*/{}, mlir::StringAttr::get(context, result.second.name), fileAttr, line, scope, /*baseType=*/nullptr, mlir::LLVM::DIFlags::Zero, offset * 8, /*alignInBits=*/0, elements, /*dataLocation=*/nullptr, /*rank=*/nullptr, @@ -236,8 +236,8 @@ mlir::LLVM::DITypeAttr DebugTypeGenerator::convertSequenceType( // have been set to some valid default values. return mlir::LLVM::DICompositeTypeAttr::get( - context, llvm::dwarf::DW_TAG_array_type, /*name=*/nullptr, - /*file=*/nullptr, /*line=*/0, /*scope=*/nullptr, elemTy, + context, llvm::dwarf::DW_TAG_array_type, /*recursive_id=*/{}, + /*name=*/nullptr, /*file=*/nullptr, /*line=*/0, /*scope=*/nullptr, elemTy, mlir::LLVM::DIFlags::Zero, /*sizeInBits=*/0, /*alignInBits=*/0, elements, /*dataLocation=*/nullptr, /*rank=*/nullptr, /*allocated=*/nullptr, /*associated=*/nullptr); diff --git a/mlir/include/mlir-c/Dialect/LLVM.h b/mlir/include/mlir-c/Dialect/LLVM.h index 38bd4d2f3587be..5eb96a86e472d6 100644 --- a/mlir/include/mlir-c/Dialect/LLVM.h +++ b/mlir/include/mlir-c/Dialect/LLVM.h @@ -234,13 +234,10 @@ MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDIBasicTypeAttrGet( MlirContext ctx, unsigned int tag, MlirAttribute name, uint64_t sizeInBits, MlirLLVMTypeEncoding encoding); -/// Creates a self-referencing LLVM DICompositeType attribute. -MlirAttribute mlirLLVMDICompositeTypeAttrGetRecSelf(MlirAttribute recId); - /// Creates a LLVM DICompositeType attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDICompositeTypeAttrGet( - MlirContext ctx, MlirAttribute recId, bool isRecSelf, unsigned int tag, - MlirAttribute name, MlirAttribute file, uint32_t line, MlirAttribute scope, + MlirContext ctx, unsigned int tag, MlirAttribute recId, MlirAttribute name, + MlirAttribute file, uint32_t line, MlirAttribute scope, MlirAttribute baseType, int64_t flags, uint64_t sizeInBits, uint64_t alignInBits, intptr_t nElements, MlirAttribute const *elements, MlirAttribute dataLocation, MlirAttribute rank, MlirAttribute allocated, @@ -314,16 +311,13 @@ MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDILocalVariableAttrGet( MlirAttribute diFile, unsigned int line, unsigned int arg, unsigned int alignInBits, MlirAttribute diType, int64_t flags); -/// Creates a self-referencing LLVM DISubprogramAttr attribute. -MlirAttribute mlirLLVMDISubprogramAttrGetRecSelf(MlirAttribute recId); - /// Creates a LLVM DISubprogramAttr attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDISubprogramAttrGet( - MlirContext ctx, MlirAttribute recId, bool isRecSelf, MlirAttribute id, - MlirAttribute compileUnit, MlirAttribute scope, MlirAttribute name, - MlirAttribute linkageName, MlirAttribute file, unsigned int line, - unsigned int scopeLine, uint64_t subprogramFlags, MlirAttribute type, - intptr_t nRetainedNodes, MlirAttribute const *retainedNodes); + MlirContext ctx, MlirAttribute id, MlirAttribute compileUnit, + MlirAttribute scope, MlirAttribute name, MlirAttribute linkageName, + MlirAttribute file, unsigned int line, unsigned int scopeLine, + uint64_t subprogramFlags, MlirAttribute type, intptr_t nRetainedNodes, + MlirAttribute const *retainedNodes); /// Gets the scope from this DISubprogramAttr. MLIR_CAPI_EXPORTED MlirAttribute @@ -362,9 +356,9 @@ MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDIModuleAttrGet( /// Creates a LLVM DIImportedEntityAttr attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDIImportedEntityAttrGet( - MlirContext ctx, unsigned int tag, MlirAttribute scope, - MlirAttribute entity, MlirAttribute file, unsigned int line, - MlirAttribute name, intptr_t nElements, MlirAttribute const *elements); + MlirContext ctx, unsigned int tag, MlirAttribute entity, MlirAttribute file, + unsigned int line, MlirAttribute name, intptr_t nElements, + MlirAttribute const *elements); /// Gets the scope of this DIModuleAttr. MLIR_CAPI_EXPORTED MlirAttribute diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td index 49e54df3436ff3..e57be7f760d380 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td @@ -271,7 +271,7 @@ def LLVM_DILanguageParameter : LLVM_DIParameter< >; def LLVM_DITagParameter : LLVM_DIParameter< - "tag", /*default=*/"0", "Tag", /*errorCase=*/"llvm::dwarf::DW_TAG_invalid" + "tag", /*default=*/"", "Tag", /*errorCase=*/"llvm::dwarf::DW_TAG_invalid" >; def LLVM_DIOperationEncodingParameter : LLVM_DIParameter< @@ -375,17 +375,14 @@ def LLVM_DICompositeTypeAttr : LLVM_Attr<"DICompositeType", "di_composite_type", [LLVM_DIRecursiveTypeAttrInterface], "DITypeAttr"> { let parameters = (ins - // DIRecursiveTypeAttrInterface specific parameters. - OptionalParameter<"DistinctAttr">:$recId, - OptionalParameter<"bool">:$isRecSelf, - // DICompositeType specific parameters. LLVM_DITagParameter:$tag, + OptionalParameter<"DistinctAttr">:$recId, OptionalParameter<"StringAttr">:$name, OptionalParameter<"DIFileAttr">:$file, OptionalParameter<"uint32_t">:$line, OptionalParameter<"DIScopeAttr">:$scope, OptionalParameter<"DITypeAttr">:$baseType, - OptionalParameter<"DIFlags">:$flags, + OptionalParameter<"DIFlags", "DIFlags::Zero">:$flags, OptionalParameter<"uint64_t">:$sizeInBits, OptionalParameter<"uint64_t">:$alignInBits, OptionalArrayRefParameter<"DINodeAttr">:$elements, @@ -394,26 +391,14 @@ def LLVM_DICompositeTypeAttr : LLVM_Attr<"DICompositeType", "di_composite_type", OptionalParameter<"DIExpressionAttr">:$allocated, OptionalParameter<"DIExpressionAttr">:$associated ); - let builders = [ - AttrBuilder<(ins - "unsigned":$tag, "StringAttr":$name, "DIFileAttr":$file, - "uint32_t":$line, "DIScopeAttr":$scope, "DITypeAttr":$baseType, - "DIFlags":$flags, "uint64_t":$sizeInBits, "uint64_t":$alignInBits, - "ArrayRef<DINodeAttr>":$elements, "DIExpressionAttr":$dataLocation, - "DIExpressionAttr":$rank, "DIExpressionAttr":$allocated, - "DIExpressionAttr":$associated - ), [{ - return $_get($_ctxt, /*recId=*/nullptr, /*isRecSelf=*/nullptr, - tag, name, file, line, scope, baseType, flags, sizeInBits, - alignInBits, elements, dataLocation, rank, allocated, - associated); - }]> - ]; let assemblyFormat = "`<` struct(params) `>`"; let extraClassDeclaration = [{ /// Requirements of DIRecursiveTypeAttrInterface. /// @{ + /// Get whether this attr describes a recursive self reference. + bool isRecSelf() { return getTag() == 0; } + /// Get a copy of this type attr but with the recursive ID set to `recId`. DIRecursiveTypeAttrInterface withRecId(DistinctAttr recId); @@ -569,19 +554,14 @@ def LLVM_DILocalVariableAttr : LLVM_Attr<"DILocalVariable", "di_local_variable", //===----------------------------------------------------------------------===// def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", - [LLVM_DIRecursiveTypeAttrInterface], - "DIScopeAttr"> { + /*traits=*/[], "DIScopeAttr"> { let parameters = (ins - // DIRecursiveTypeAttrInterface specific parameters. - OptionalParameter<"DistinctAttr">:$recId, - OptionalParameter<"bool">:$isRecSelf, - // DISubprogramAttr specific parameters. OptionalParameter<"DistinctAttr">:$id, OptionalParameter<"DICompileUnitAttr">:$compileUnit, - OptionalParameter<"DIScopeAttr">:$scope, + "DIScopeAttr":$scope, OptionalParameter<"StringAttr">:$name, OptionalParameter<"StringAttr">:$linkageName, - OptionalParameter<"DIFileAttr">:$file, + "DIFileAttr":$file, OptionalParameter<"unsigned">:$line, OptionalParameter<"unsigned">:$scopeLine, OptionalParameter<"DISubprogramFlags">:$subprogramFlags, @@ -589,31 +569,21 @@ def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", OptionalArrayRefParameter<"DINodeAttr">:$retainedNodes ); let builders = [ - AttrBuilder<(ins + AttrBuilderWithInferredContext<(ins "DistinctAttr":$id, "DICompileUnitAttr":$compileUnit, - "DIScopeAttr":$scope, "StringAttr":$name, "StringAttr":$linkageName, + "DIScopeAttr":$scope, "StringRef":$name, "StringRef":$linkageName, "DIFileAttr":$file, "unsigned":$line, "unsigned":$scopeLine, "DISubprogramFlags":$subprogramFlags, "DISubroutineTypeAttr":$type, "ArrayRef<DINodeAttr>":$retainedNodes ), [{ - return $_get($_ctxt, /*recId=*/nullptr, /*isRecSelf=*/false, id, compileUnit, - scope, name, linkageName, file, line, scopeLine, - subprogramFlags, type, retainedNodes); + MLIRContext *ctx = file.getContext(); + return $_get(ctx, id, compileUnit, scope, StringAttr::get(ctx, name), + StringAttr::get(ctx, linkageName), file, line, + scopeLine, subprogramFlags, type, retainedNodes); }]> ]; - let assemblyFormat = "`<` struct(params) `>`"; - let extraClassDeclaration = [{ - /// Requirements of DIRecursiveTypeAttrInterface. - /// @{ - - /// Get a copy of this type attr but with the recursive ID set to `recId`. - DIRecursiveTypeAttrInterface withRecId(DistinctAttr recId); - /// Build a rec-self instance using the provided `recId`. - static DIRecursiveTypeAttrInterface getRecSelf(DistinctAttr recId); - - /// @} - }]; + let assemblyFormat = "`<` struct(params) `>`"; } //===----------------------------------------------------------------------===// @@ -657,9 +627,13 @@ def LLVM_DINamespaceAttr : LLVM_Attr<"DINamespace", "di_namespace", def LLVM_DIImportedEntityAttr : LLVM_Attr<"DIImportedEntity", "di_imported_entity", /*traits=*/[], "DINodeAttr"> { + /// TODO: DIImportedEntity has a 'scope' field which represents the scope where + /// this entity is imported. Currently, we are not adding a 'scope' field in + /// DIImportedEntityAttr to avoid cyclic dependency. As DIImportedEntityAttr + /// entries will be contained inside a scope entity (e.g. DISubprogramAttr), + /// the scope can easily be inferred. let parameters = (ins LLVM_DITagParameter:$tag, - "DIScopeAttr":$scope, "DINodeAttr":$entity, OptionalParameter<"DIFileAttr">:$file, OptionalParameter<"unsigned">:$line, diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td index e2180410a8f04e..7085f81e203a1e 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td @@ -406,7 +406,7 @@ def LLVM_DIRecursiveTypeAttrInterface let methods = [ InterfaceMethod<[{ Get whether this attr describes a recursive self reference. - }], "bool", "getIsRecSelf", (ins)>, + }], "bool", "isRecSelf", (ins)>, InterfaceMethod<[{ Get the recursive ID used for matching "rec-decl" with "rec-self". If this attr instance is not recursive, return a null attribute. diff --git a/mlir/lib/CAPI/Dialect/LLVM.cpp b/mlir/lib/CAPI/Dialect/LLVM.cpp index 03b536d7aad98f..13341f0c4de881 100644 --- a/mlir/lib/CAPI/Dialect/LLVM.cpp +++ b/mlir/lib/CAPI/Dialect/LLVM.cpp @@ -159,14 +159,9 @@ MlirAttribute mlirLLVMDIBasicTypeAttrGet(MlirContext ctx, unsigned int tag, unwrap(ctx), tag, cast<StringAttr>(unwrap(name)), sizeInBits, encoding)); } -MlirAttribute mlirLLVMDICompositeTypeAttrGetRecSelf(MlirAttribute recId) { - return wrap( - DICompositeTypeAttr::getRecSelf(cast<DistinctAttr>(unwrap(recId)))); -} - MlirAttribute mlirLLVMDICompositeTypeAttrGet( - MlirContext ctx, MlirAttribute recId, bool isRecSelf, unsigned int tag, - MlirAttribute name, MlirAttribute file, uint32_t line, MlirAttribute scope, + MlirContext ctx, unsigned int tag, MlirAttribute recId, MlirAttribute name, + MlirAttribute file, uint32_t line, MlirAttribute scope, MlirAttribute baseType, int64_t flags, uint64_t sizeInBits, uint64_t alignInBits, intptr_t nElements, MlirAttribute const *elements, MlirAttribute dataLocation, MlirAttribute rank, MlirAttribute allocated, @@ -175,7 +170,7 @@ MlirAttribute mlirLLVMDICompositeTypeAttrGet( elementsStorage.reserve(nElements); return wrap(DICompositeTypeAttr::get( - unwrap(ctx), cast<DistinctAttr>(unwrap(recId)), isRecSelf, tag, + unwrap(ctx), tag, cast<DistinctAttr>(unwrap(recId)), cast<StringAttr>(unwrap(name)), cast<DIFileAttr>(unwrap(file)), line, cast<DIScopeAttr>(unwrap(scope)), cast<DITypeAttr>(unwrap(baseType)), DIFlags(flags), sizeInBits, alignInBits, @@ -294,21 +289,16 @@ MlirAttribute mlirLLVMDISubroutineTypeAttrGet(MlirContext ctx, [](Attribute a) { return cast<DITypeAttr>(a); }))); } -MlirAttribute mlirLLVMDISubprogramAttrGetRecSelf(MlirAttribute recId) { - return wrap(DISubprogramAttr::getRecSelf(cast<DistinctAttr>(unwrap(recId)))); -} - MlirAttribute mlirLLVMDISubprogramAttrGet( - MlirContext ctx, MlirAttribute recId, bool isRecSelf, MlirAttribute id, - MlirAttribute compileUnit, MlirAttribute scope, MlirAttribute name, - MlirAttribute linkageName, MlirAttribute file, unsigned int line, - unsigned int scopeLine, uint64_t subprogramFlags, MlirAttribute type, - intptr_t nRetainedNodes, MlirAttribute const *retainedNodes) { + MlirContext ctx, MlirAttribute id, MlirAttribute compileUnit, + MlirAttribute scope, MlirAttribute name, MlirAttribute linkageName, + MlirAttribute file, unsigned int line, unsigned int scopeLine, + uint64_t subprogramFlags, MlirAttribute type, intptr_t nRetainedNodes, + MlirAttribute const *retainedNodes) { SmallVector<Attribute> nodesStorage; nodesStorage.reserve(nRetainedNodes); return wrap(DISubprogramAttr::get( - unwrap(ctx), cast<DistinctAttr>(unwrap(recId)), isRecSelf, - cast<DistinctAttr>(unwrap(id)), + unwrap(ctx), cast<DistinctAttr>(unwrap(id)), cast<DICompileUnitAttr>(unwrap(compileUnit)), cast<DIScopeAttr>(unwrap(scope)), cast<StringAttr>(unwrap(name)), cast<StringAttr>(unwrap(linkageName)), cast<DIFileAttr>(unwrap(file)), @@ -363,15 +353,14 @@ MlirAttribute mlirLLVMDIModuleAttrGetScope(MlirAttribute diModule) { } MlirAttribute mlirLLVMDIImportedEntityAttrGet( - MlirContext ctx, unsigned int tag, MlirAttribute scope, - MlirAttribute entity, MlirAttribute file, unsigned int line, - MlirAttribute name, intptr_t nElements, MlirAttribute const *elements) { + MlirContext ctx, unsigned int tag, MlirAttribute entity, MlirAttribute file, + unsigned int line, MlirAttribute name, intptr_t nElements, + MlirAttribute const *elements) { SmallVector<Attribute> elementsStorage; elementsStorage.reserve(nElements); return wrap(DIImportedEntityAttr::get( - unwrap(ctx), tag, cast<DIScopeAttr>(unwrap(scope)), - cast<DINodeAttr>(unwrap(entity)), cast<DIFileAttr>(unwrap(file)), line, - cast<StringAttr>(unwrap(name)), + unwrap(ctx), tag, cast<DINodeAttr>(unwrap(entity)), + cast<DIFileAttr>(unwrap(file)), line, cast<StringAttr>(unwrap(name)), llvm::map_to_vector(unwrapList(nElements, elements, elementsStorage), [](Attribute a) { return cast<DINodeAttr>(a); }))); } diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp index 491dcc7f01e73d..98a9659735e7e6 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp @@ -203,33 +203,16 @@ void printExpressionArg(AsmPrinter &printer, uint64_t opcode, DIRecursiveTypeAttrInterface DICompositeTypeAttr::withRecId(DistinctAttr recId) { return DICompositeTypeAttr::get( - getContext(), recId, getIsRecSelf(), getTag(), getName(), getFile(), - getLine(), getScope(), getBaseType(), getFlags(), getSizeInBits(), - getAlignInBits(), getElements(), getDataLocation(), getRank(), - getAllocated(), getAssociated()); + getContext(), getTag(), recId, getName(), getFile(), getLine(), + getScope(), getBaseType(), getFlags(), getSizeInBits(), getAlignInBits(), + getElements(), getDataLocation(), getRank(), getAllocated(), + getAssociated()); } DIRecursiveTypeAttrInterface DICompositeTypeAttr::getRecSelf(DistinctAttr recId) { - return DICompositeTypeAttr::get(recId.getContext(), recId, /*isRecSelf=*/true, - 0, {}, {}, 0, {}, {}, DIFlags(), 0, 0, {}, {}, - {}, {}, {}); -} - -//===----------------------------------------------------------------------===// -// DISubprogramAttr -//===----------------------------------------------------------------------===// - -DIRecursiveTypeAttrInterface DISubprogramAttr::withRecId(DistinctAttr recId) { - return DISubprogramAttr::get( - getContext(), recId, getIsRecSelf(), getId(), getCompileUnit(), - getScope(), getName(), getLinkageName(), getFile(), getLine(), - getScopeLine(), getSubprogramFlags(), getType(), getRetainedNodes()); -} - -DIRecursiveTypeAttrInterface DISubprogramAttr::getRecSelf(DistinctAttr recId) { - return DISubprogramAttr::get(recId.getContext(), recId, /*isRecSelf=*/true, - {}, {}, {}, {}, {}, 0, 0, {}, {}, {}, {}); + return DICompositeTypeAttr::get(recId.getContext(), 0, recId, {}, {}, 0, {}, + {}, DIFlags(), 0, 0, {}, {}, {}, {}, {}); } //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp index 6e4a964f1fc93c..3870aab52f199d 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp @@ -3155,9 +3155,9 @@ struct LLVMOpAsmDialectInterface : public OpAsmDialectInterface { .Case<AccessGroupAttr, AliasScopeAttr, AliasScopeDomainAttr, DIBasicTypeAttr, DICompileUnitAttr, DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr, DIGlobalVariableAttr, - DIGlobalVariableExpressionAttr, DIImportedEntityAttr, DILabelAttr, - DILexicalBlockAttr, DILexicalBlockFileAttr, DILocalVariableAttr, - DIModuleAttr, DINamespaceAttr, DINullTypeAttr, DIStringTypeAttr, + DIGlobalVariableExpressionAttr, DILabelAttr, DILexicalBlockAttr, + DILexicalBlockFileAttr, DILocalVariableAttr, DIModuleAttr, + DINamespaceAttr, DINullTypeAttr, DIStringTypeAttr, DISubprogramAttr, DISubroutineTypeAttr, LoopAnnotationAttr, LoopVectorizeAttr, LoopInterleaveAttr, LoopUnrollAttr, LoopUnrollAndJamAttr, LoopLICMAttr, LoopDistributeAttr, diff --git a/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp b/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp index 2cfaffa7c8efce..c75f44bf3976a9 100644 --- a/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp +++ b/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp @@ -65,6 +65,7 @@ static void addScopeToFunction(LLVM::LLVMFuncOp llvmFunc, auto subroutineTypeAttr = LLVM::DISubroutineTypeAttr::get(context, llvm::dwarf::DW_CC_normal, {}); + StringAttr funcNameAttr = llvmFunc.getNameAttr(); // Only definitions need a distinct identifier and a compilation unit. DistinctAttr id; auto subprogramFlags = LLVM::DISubprogramFlags::Optimized; @@ -74,10 +75,11 @@ static void addScopeToFunction(LLVM::LLVMFuncOp llvmFunc, } else { compileUnitAttr = {}; } - auto funcName = StringAttr::get(context, llvmFunc.getName()); auto subprogramAttr = LLVM::DISubprogramAttr::get( - context, id, compileUnitAttr, fileAttr, funcName, funcName, fileAttr, - /*line=*/line, /*scopeline=*/col, subprogramFlags, subroutineTypeAttr, + context, id, compileUnitAttr, fileAttr, funcNameAttr, funcNameAttr, + fileAttr, + /*line=*/line, + /*scopeline=*/col, subprogramFlags, subroutineTypeAttr, /*retainedNodes=*/{}); llvmFunc->setLoc(FusedLoc::get(context, {loc}, subprogramAttr)); } diff --git a/mlir/lib/Target/LLVMIR/DebugImporter.cpp b/mlir/lib/Target/LLVMIR/DebugImporter.cpp index 8c6f32f6bb0cd0..ce3643f513d34a 100644 --- a/mlir/lib/Target/LLVMIR/DebugImporter.cpp +++ b/mlir/lib/Target/LLVMIR/DebugImporter.cpp @@ -89,9 +89,10 @@ DICompositeTypeAttr DebugImporter::translateImpl(llvm::DICompositeType *node) { if (node->getTag() == llvm::dwarf::DW_TAG_array_type && !baseType) return nullptr; return DICompositeTypeAttr::get( - context, node->getTag(), getStringAttrOrNull(node->getRawName()), - translate(node->getFile()), node->getLine(), translate(node->getScope()), - baseType, flags.value_or(DIFlags::Zero), node->getSizeInBits(), + context, node->getTag(), /*recId=*/{}, + getStringAttrOrNull(node->getRawName()), translate(node->getFile()), + node->getLine(), translate(node->getScope()), baseType, + flags.value_or(DIFlags::Zero), node->getSizeInBits(), node->getAlignInBits(), elements, translateExpression(node->getDataLocationExp()), translateExpression(node->getRankExp()), @@ -216,8 +217,8 @@ DebugImporter::translateImpl(llvm::DIImportedEntity *node) { } return DIImportedEntityAttr::get( - context, node->getTag(), translate(node->getScope()), - translate(node->getEntity()), translate(node->getFile()), node->getLine(), + context, node->getTag(), translate(node->getEntity()), + translate(node->getFile()), node->getLine(), getStringAttrOrNull(node->getRawName()), elements); } @@ -226,7 +227,6 @@ DISubprogramAttr DebugImporter::translateImpl(llvm::DISubprogram *node) { mlir::DistinctAttr id; if (node->isDistinct()) id = getOrCreateDistinctID(node); - // Return nullptr if the scope or type is invalid. DIScopeAttr scope = translate(node->getScope()); if (node->getScope() && !scope) @@ -238,12 +238,9 @@ DISubprogramAttr DebugImporter::translateImpl(llvm::DISubprogram *node) { if (node->getType() && !type) return nullptr; - // Convert the retained nodes but drop all of them if one of them is invalid. SmallVector<DINodeAttr> retainedNodes; for (llvm::DINode *retainedNode : node->getRetainedNodes()) retainedNodes.push_back(translate(retainedNode)); - if (llvm::is_contained(retainedNodes, nullptr)) - retainedNodes.clear(); return DISubprogramAttr::get(context, id, translate(node->getUnit()), scope, getStringAttrOrNull(node->getRawName()), @@ -377,9 +374,6 @@ getRecSelfConstructor(llvm::DINode *node) { .Case([&](llvm::DICompositeType *) { return CtorType(DICompositeTypeAttr::getRecSelf); }) - .Case([&](llvm::DISubprogram *) { - return CtorType(DISubprogramAttr::getRecSelf); - }) .Default(CtorType()); } diff --git a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp index 8ca3beca6b66f7..042e015f107fea 100644 --- a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp @@ -96,17 +96,6 @@ llvm::MDString *DebugTranslation::getMDStringOrNull(StringAttr stringAttr) { return llvm::MDString::get(llvmCtx, stringAttr); } -llvm::MDTuple * -DebugTranslation::getMDTupleOrNull(ArrayRef<DINodeAttr> elements) { - if (elements.empty()) - return nullptr; - SmallVector<llvm::Metadata *> llvmElements = llvm::to_vector( - llvm::map_range(elements, [&](DINodeAttr attr) -> llvm::Metadata * { - return translate(attr); - })); - return llvm::MDNode::get(llvmCtx, llvmElements); -} - llvm::DIBasicType *DebugTranslation::translateImpl(DIBasicTypeAttr attr) { return llvm::DIBasicType::get( llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()), @@ -149,17 +138,6 @@ DebugTranslation::translateTemporaryImpl(DICompositeTypeAttr attr) { /*VTableHolder=*/nullptr); } -llvm::TempDISubprogram -DebugTranslation::translateTemporaryImpl(DISubprogramAttr attr) { - return llvm::DISubprogram::getTemporary( - llvmCtx, /*Scope=*/nullptr, /*Name=*/{}, /*LinkageName=*/{}, - /*File=*/nullptr, attr.getLine(), /*Type=*/nullptr, - /*ScopeLine=*/0, /*ContainingType=*/nullptr, /*VirtualIndex=*/0, - /*ThisAdjustment=*/0, llvm::DINode::FlagZero, - static_cast<llvm::DISubprogram::DISPFlags>(attr.getSubprogramFlags()), - /*Unit=*/nullptr); -} - llvm::DICompositeType * DebugTranslation::translateImpl(DICompositeTypeAttr attr) { // TODO: Use distinct attributes to model this, once they have landed. @@ -173,6 +151,10 @@ DebugTranslation::translateImpl(DICompositeTypeAttr attr) { isDistinct = true; } + SmallVector<llvm::Metadata *> elements; + for (DINodeAttr member : attr.getElements()) + elements.push_back(translate(member)); + return getDistinctOrUnique<llvm::DICompositeType>( isDistinct, llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()), translate(attr.getFile()), attr.getLine(), translate(attr.getScope()), @@ -180,7 +162,7 @@ DebugTranslation::translateImpl(DICompositeTypeAttr attr) { attr.getAlignInBits(), /*OffsetInBits=*/0, /*Flags=*/static_cast<llvm::DINode::DIFlags>(attr.getFlags()), - getMDTupleOrNull(attr.getElements()), + llvm::MDNode::get(llvmCtx, elements), /*RuntimeLang=*/0, /*VTableHolder=*/nullptr, /*TemplateParams=*/nullptr, /*Identifier=*/nullptr, /*Discriminator=*/nullptr, @@ -260,21 +242,22 @@ DebugTranslation::translateImpl(DIGlobalVariableAttr attr) { attr.getIsDefined(), nullptr, nullptr, attr.getAlignInBits(), nullptr); } -llvm::DINode * +llvm::DIType * DebugTranslation::translateRecursive(DIRecursiveTypeAttrInterface attr) { DistinctAttr recursiveId = attr.getRecId(); - if (auto *iter = recursiveNodeMap.find(recursiveId); - iter != recursiveNodeMap.end()) { + if (auto *iter = recursiveTypeMap.find(recursiveId); + iter != recursiveTypeMap.end()) { return iter->second; + } else { + assert(!attr.isRecSelf() && "unbound DI recursive self type"); } - assert(!attr.getIsRecSelf() && "unbound DI recursive self reference"); - auto setRecursivePlaceholder = [&](llvm::DINode *placeholder) { - recursiveNodeMap.try_emplace(recursiveId, placeholder); + auto setRecursivePlaceholder = [&](llvm::DIType *placeholder) { + recursiveTypeMap.try_emplace(recursiveId, placeholder); }; - llvm::DINode *result = - TypeSwitch<DIRecursiveTypeAttrInterface, llvm::DINode *>(attr) + llvm::DIType *result = + TypeSwitch<DIRecursiveTypeAttrInterface, llvm::DIType *>(attr) .Case<DICompositeTypeAttr>([&](auto attr) { auto temporary = translateTemporaryImpl(attr); setRecursivePlaceholder(temporary.get()); @@ -283,20 +266,11 @@ DebugTranslation::translateRecursive(DIRecursiveTypeAttrInterface attr) { auto *concrete = translateImpl(attr); temporary->replaceAllUsesWith(concrete); return concrete; - }) - .Case<DISubprogramAttr>([&](auto attr) { - auto temporary = translateTemporaryImpl(attr); - setRecursivePlaceholder(temporary.get()); - // Must call `translateImpl` directly instead of `translate` to - // avoid handling the recursive interface again. - auto *concrete = translateImpl(attr); - temporary->replaceAllUsesWith(concrete); - return concrete; }); - assert(recursiveNodeMap.back().first == recursiveId && + assert(recursiveTypeMap.back().first == recursiveId && "internal inconsistency: unexpected recursive translation stack"); - recursiveNodeMap.pop_back(); + recursiveTypeMap.pop_back(); return result; } @@ -323,7 +297,6 @@ llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) { bool isDefinition = static_cast<bool>(attr.getSubprogramFlags() & LLVM::DISubprogramFlags::Definition); - llvm::DISubprogram *node = getDistinctOrUnique<llvm::DISubprogram>( isDefinition, llvmCtx, scope, getMDStringOrNull(attr.getName()), getMDStringOrNull(attr.getLinkageName()), file, attr.getLine(), type, @@ -331,8 +304,21 @@ llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) { /*ContainingType=*/nullptr, /*VirtualIndex=*/0, /*ThisAdjustment=*/0, llvm::DINode::FlagZero, static_cast<llvm::DISubprogram::DISPFlags>(attr.getSubprogramFlags()), - compileUnit, /*TemplateParams=*/nullptr, /*Declaration=*/nullptr, - getMDTupleOrNull(attr.getRetainedNodes())); + compileUnit); + + // DIImportedEntity requires scope information which DIImportedEntityAttr does + // not have. This is why we translate DIImportedEntityAttr after we have + // created DISubprogram as we can use it as the scope. + SmallVector<llvm::Metadata *> retainedNodes; + for (DINodeAttr nodeAttr : attr.getRetainedNodes()) { + if (auto importedAttr = dyn_cast<DIImportedEntityAttr>(nodeAttr)) { + llvm::DINode *dn = translate(importedAttr, node); + retainedNodes.push_back(dn); + } + } + if (!retainedNodes.empty()) + node->replaceRetainedNodes(llvm::MDTuple::get(llvmCtx, retainedNodes)); + if (attr.getId()) distinctAttrToNode.try_emplace(attr.getId(), node); return node; @@ -353,12 +339,16 @@ llvm::DINamespace *DebugTranslation::translateImpl(DINamespaceAttr attr) { attr.getExportSymbols()); } -llvm::DIImportedEntity * -DebugTranslation::translateImpl(DIImportedEntityAttr attr) { +llvm::DIImportedEntity *DebugTranslation::translate(DIImportedEntityAttr attr, + llvm::DIScope *scope) { + SmallVector<llvm::Metadata *> elements; + for (DINodeAttr member : attr.getElements()) + elements.push_back(translate(member)); + return llvm::DIImportedEntity::get( - llvmCtx, attr.getTag(), translate(attr.getScope()), - translate(attr.getEntity()), translate(attr.getFile()), attr.getLine(), - getMDStringOrNull(attr.getName()), getMDTupleOrNull(attr.getElements())); + llvmCtx, attr.getTag(), scope, translate(attr.getEntity()), + translate(attr.getFile()), attr.getLine(), + getMDStringOrNull(attr.getName()), llvm::MDNode::get(llvmCtx, elements)); } llvm::DISubrange *DebugTranslation::translateImpl(DISubrangeAttr attr) { @@ -423,10 +413,10 @@ llvm::DINode *DebugTranslation::translate(DINodeAttr attr) { node = TypeSwitch<DINodeAttr, llvm::DINode *>(attr) .Case<DIBasicTypeAttr, DICompileUnitAttr, DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr, DIGlobalVariableAttr, - DIImportedEntityAttr, DILabelAttr, DILexicalBlockAttr, - DILexicalBlockFileAttr, DILocalVariableAttr, DIModuleAttr, - DINamespaceAttr, DINullTypeAttr, DIStringTypeAttr, - DISubprogramAttr, DISubrangeAttr, DISubroutineTypeAttr>( + DILabelAttr, DILexicalBlockAttr, DILexicalBlockFileAttr, + DILocalVariableAttr, DIModuleAttr, DINamespaceAttr, + DINullTypeAttr, DIStringTypeAttr, DISubprogramAttr, + DISubrangeAttr, DISubroutineTypeAttr>( [&](auto attr) { return translateImpl(attr); }); if (node && !node->isTemporary()) diff --git a/mlir/lib/Target/LLVMIR/DebugTranslation.h b/mlir/lib/Target/LLVMIR/DebugTranslation.h index 422aa34e28f3c9..37b985acf8541e 100644 --- a/mlir/lib/Target/LLVMIR/DebugTranslation.h +++ b/mlir/lib/Target/LLVMIR/DebugTranslation.h @@ -75,7 +75,6 @@ class DebugTranslation { llvm::DIDerivedType *translateImpl(DIDerivedTypeAttr attr); llvm::DIStringType *translateImpl(DIStringTypeAttr attr); llvm::DIFile *translateImpl(DIFileAttr attr); - llvm::DIImportedEntity *translateImpl(DIImportedEntityAttr attr); llvm::DILabel *translateImpl(DILabelAttr attr); llvm::DILexicalBlock *translateImpl(DILexicalBlockAttr attr); llvm::DILexicalBlockFile *translateImpl(DILexicalBlockFileAttr attr); @@ -91,26 +90,27 @@ class DebugTranslation { llvm::DISubroutineType *translateImpl(DISubroutineTypeAttr attr); llvm::DIType *translateImpl(DITypeAttr attr); + /// Currently, DIImportedEntityAttr does not have a scope field to avoid a + /// cyclic dependency. The scope information is obtained from the entity + /// which holds the list of DIImportedEntityAttr. This requires that scope + /// information be passed to translate function. + llvm::DIImportedEntity *translate(DIImportedEntityAttr attr, llvm::DIScope *); + /// Attributes that support self recursion need to implement an additional /// method to hook into `translateRecursive`. /// - `<temp llvm type> translateTemporaryImpl(<mlir type>)`: /// Create a temporary translation of the DI attr without recursively /// translating any nested DI attrs. - llvm::DINode *translateRecursive(DIRecursiveTypeAttrInterface attr); + llvm::DIType *translateRecursive(DIRecursiveTypeAttrInterface attr); /// Translate the given attribute to a temporary llvm debug metadata of the /// corresponding type. llvm::TempDICompositeType translateTemporaryImpl(DICompositeTypeAttr attr); - llvm::TempDISubprogram translateTemporaryImpl(DISubprogramAttr attr); /// Constructs a string metadata node from the string attribute. Returns /// nullptr if `stringAttr` is null or contains and empty string. llvm::MDString *getMDStringOrNull(StringAttr stringAttr); - /// Constructs a tuple metadata node from the `elements`. Returns nullptr if - /// `elements` is empty. - llvm::MDTuple *getMDTupleOrNull(ArrayRef<DINodeAttr> elements); - /// Constructs a DIExpression metadata node from the DIExpressionAttr. Returns /// nullptr if `DIExpressionAttr` is null. llvm::DIExpression *getExpressionAttrOrNull(DIExpressionAttr attr); @@ -125,8 +125,8 @@ class DebugTranslation { /// metadata. DenseMap<Attribute, llvm::DINode *> attrToNode; - /// A mapping between recursive ID and the translated DINode. - llvm::MapVector<DistinctAttr, llvm::DINode *> recursiveNodeMap; + /// A mapping between recursive ID and the translated DIType. + llvm::MapVector<DistinctAttr, llvm::DIType *> recursiveTypeMap; /// A mapping between a distinct ID and the translated LLVM metadata node. /// This helps identify attrs that should translate into the same LLVM debug diff --git a/mlir/test/CAPI/llvm.c b/mlir/test/CAPI/llvm.c index 36277122801de4..da28a96f89691d 100644 --- a/mlir/test/CAPI/llvm.c +++ b/mlir/test/CAPI/llvm.c @@ -248,16 +248,12 @@ static void testDebugInfoAttributes(MlirContext ctx) { mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("foo")); MlirAttribute bar = mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("bar")); - - MlirAttribute none = mlirUnitAttrGet(ctx); - MlirAttribute id = mlirDisctinctAttrCreate(none); - MlirAttribute recId0 = mlirDisctinctAttrCreate(none); - MlirAttribute recId1 = mlirDisctinctAttrCreate(none); + MlirAttribute id = mlirDisctinctAttrCreate(foo); // CHECK: #llvm.di_null_type mlirAttributeDump(mlirLLVMDINullTypeAttrGet(ctx)); - // CHECK: #llvm.di_basic_type<name = "foo", sizeInBits = + // CHECK: #llvm.di_basic_type<tag = DW_TAG_null, name = "foo", sizeInBits = // CHECK-SAME: 64, encoding = DW_ATE_signed> MlirAttribute di_type = mlirLLVMDIBasicTypeAttrGet(ctx, 0, foo, 64, MlirLLVMTypeEncodingSigned); @@ -316,17 +312,15 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_subroutine_type<{{.*}}> mlirAttributeDump(subroutine_type); - MlirAttribute di_subprogram_self_rec = - mlirLLVMDISubprogramAttrGetRecSelf(recId0); MlirAttribute di_imported_entity = mlirLLVMDIImportedEntityAttrGet( - ctx, 0, di_subprogram_self_rec, di_module, file, 1, foo, 1, &local_var); + ctx, 0, di_module, file, 1, foo, 1, &local_var); mlirAttributeDump(di_imported_entity); // CHECK: #llvm.di_imported_entity<{{.*}}> MlirAttribute di_subprogram = mlirLLVMDISubprogramAttrGet( - ctx, recId0, false, id, compile_unit, compile_unit, foo, bar, file, 1, 2, - 0, subroutine_type, 1, &di_imported_entity); + ctx, id, compile_unit, compile_unit, foo, bar, file, 1, 2, 0, + subroutine_type, 1, &di_imported_entity); // CHECK: #llvm.di_subprogram<{{.*}}> mlirAttributeDump(di_subprogram); @@ -356,13 +350,10 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_string_type<{{.*}}> mlirAttributeDump(string_type); - // CHECK: #llvm.di_composite_type<recId = {{.*}}, isRecSelf = true> - mlirAttributeDump(mlirLLVMDICompositeTypeAttrGetRecSelf(recId1)); - // CHECK: #llvm.di_composite_type<{{.*}}> mlirAttributeDump(mlirLLVMDICompositeTypeAttrGet( - ctx, recId1, false, 0, foo, file, 1, compile_unit, di_type, 0, 64, 8, 1, - &di_type, expression, expression, expression, expression)); + ctx, 0, id, foo, file, 1, compile_unit, di_type, 0, 64, 8, 1, &di_type, + expression, expression, expression, expression)); } int main(void) { diff --git a/mlir/test/Target/LLVMIR/Import/debug-info.ll b/mlir/test/Target/LLVMIR/Import/debug-info.ll index 02e35ae7f0ee9d..bb03da37c0d097 100644 --- a/mlir/test/Target/LLVMIR/Import/debug-info.ll +++ b/mlir/test/Target/LLVMIR/Import/debug-info.ll @@ -307,13 +307,17 @@ define void @class_method() { ret void, !dbg !9 } -; Verify the cyclic subprogram is handled correctly. -; CHECK-DAG: #[[SP_SELF:.+]] = #llvm.di_subprogram<recId = [[REC_ID:.+]], isRecSelf = true> -; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type<tag = DW_TAG_class_type, name = "class_name", file = #{{.*}}, line = 42, flags = "TypePassByReference|NonTrivial", elements = #[[SP_SELF]]> -; CHECK-DAG: #[[COMP_PTR:.+]] = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #[[COMP]], sizeInBits = 64> +; Verify the cyclic composite type is identified, even though conversion begins from the subprogram type. +; CHECK-DAG: #[[COMP_SELF:.+]] = #llvm.di_composite_type<tag = DW_TAG_null, recId = [[REC_ID:.+]]> +; CHECK-DAG: #[[COMP_PTR:.+]] = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #[[COMP_SELF]], sizeInBits = 64> ; CHECK-DAG: #[[SP_TYPE:.+]] = #llvm.di_subroutine_type<types = #{{.*}}, #[[COMP_PTR]]> -; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram<recId = [[REC_ID]], id = [[SP_ID:.+]], compileUnit = #{{.*}}, scope = #[[COMP]], name = "class_method", file = #{{.*}}, subprogramFlags = Definition, type = #[[SP_TYPE]]> -; CHECK-DAG: #[[LOC]] = loc(fused<#[[SP]]> +; CHECK-DAG: #[[SP_INNER:.+]] = #llvm.di_subprogram<id = [[SP_ID:.+]], compileUnit = #{{.*}}, scope = #[[COMP_SELF]], name = "class_method", file = #{{.*}}, subprogramFlags = Definition, type = #[[SP_TYPE]]> +; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type<tag = DW_TAG_class_type, recId = [[REC_ID]], name = "class_name", file = #{{.*}}, line = 42, flags = "TypePassByReference|NonTrivial", elements = #[[SP_INNER]]> + +; CHECK-DAG: #[[COMP_PTR_OUTER:.+]] = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #[[COMP]], sizeInBits = 64> +; CHECK-DAG: #[[SP_TYPE_OUTER:.+]] = #llvm.di_subroutine_type<types = #{{.*}}, #[[COMP_PTR_OUTER]]> +; CHECK-DAG: #[[SP_OUTER:.+]] = #llvm.di_subprogram<id = [[SP_ID]], compileUnit = #{{.*}}, scope = #[[COMP]], name = "class_method", file = #{{.*}}, subprogramFlags = Definition, type = #[[SP_TYPE_OUTER]]> +; CHECK-DAG: #[[LOC]] = loc(fused<#[[SP_OUTER]]> !llvm.dbg.cu = !{!1} !llvm.module.flags = !{!0} @@ -331,10 +335,10 @@ define void @class_method() { ; // ----- ; Verify the cyclic composite type is handled correctly. -; CHECK-DAG: #[[COMP_SELF:.+]] = #llvm.di_composite_type<recId = [[REC_ID:.+]], isRecSelf = true> +; CHECK-DAG: #[[COMP_SELF:.+]] = #llvm.di_composite_type<tag = DW_TAG_null, recId = [[REC_ID:.+]]> ; CHECK-DAG: #[[COMP_PTR_INNER:.+]] = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #[[COMP_SELF]]> ; CHECK-DAG: #[[FIELD:.+]] = #llvm.di_derived_type<tag = DW_TAG_member, name = "call_field", baseType = #[[COMP_PTR_INNER]]> -; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type<recId = [[REC_ID]], tag = DW_TAG_class_type, name = "class_field", file = #{{.*}}, line = 42, flags = "TypePassByReference|NonTrivial", elements = #[[FIELD]]> +; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type<tag = DW_TAG_class_type, recId = [[REC_ID]], name = "class_field", file = #{{.*}}, line = 42, flags = "TypePassByReference|NonTrivial", elements = #[[FIELD]]> ; CHECK-DAG: #[[COMP_PTR_OUTER:.+]] = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #[[COMP]]> ; CHECK-DAG: #[[VAR0:.+]] = #llvm.di_local_variable<scope = #{{.*}}, name = "class_field", file = #{{.*}}, type = #[[COMP_PTR_OUTER]]> @@ -606,10 +610,9 @@ define void @distinct_cu_func1() !dbg !5 { ; CHECK-LABEL: @declaration declare !dbg !1 void @declaration() -; CHECK: #[[SP:.+]] = #llvm.di_subprogram< +; CHECK: #di_subprogram = #llvm.di_subprogram< ; CHECK-NOT: id = distinct ; CHECK-NOT: subprogramFlags = -; CHECK: loc(fused<#[[SP]]> !llvm.module.flags = !{!0} !0 = !{i32 2, !"Debug Info Version", i32 3} @@ -630,14 +633,14 @@ declare !dbg !1 void @declaration() ; CHECK-DAG: #[[B1_INNER:.+]] = #llvm.di_derived_type<{{.*}}name = "B:B1", baseType = #[[B_SELF:.+]]> ; CHECK-DAG: #[[B2_INNER:.+]] = #llvm.di_derived_type<{{.*}}name = "B:B2", baseType = #[[B_SELF]]> -; CHECK-DAG: #[[B_INNER:.+]] = #llvm.di_composite_type<recId = [[B_RECID:.+]], tag = DW_TAG_class_type, name = "B", {{.*}}elements = #[[B1_INNER]], #[[B2_INNER]] +; CHECK-DAG: #[[B_INNER:.+]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID:.+]], {{.*}}name = "B", {{.*}}elements = #[[B1_INNER]], #[[B2_INNER]] ; CHECK-DAG: #[[B1_OUTER:.+]] = #llvm.di_derived_type<{{.*}}name = "B:B1", baseType = #[[B_INNER]]> ; CHECK-DAG: #[[B2_OUTER:.+]] = #llvm.di_derived_type<{{.*}}name = "B:B2", baseType = #[[B_INNER]]> -; CHECK-DAG: #[[A_OUTER:.+]] = #llvm.di_composite_type<recId = [[A_RECID:.+]], tag = DW_TAG_class_type, name = "A", {{.*}}elements = #[[B1_OUTER]], #[[B2_OUTER]] +; CHECK-DAG: #[[A_OUTER:.+]] = #llvm.di_composite_type<{{.*}}recId = [[A_RECID:.+]], {{.*}}name = "A", {{.*}}elements = #[[B1_OUTER]], #[[B2_OUTER]] -; CHECK-DAG: #[[A_SELF:.+]] = #llvm.di_composite_type<recId = [[A_RECID]] -; CHECK-DAG: #[[B_SELF:.+]] = #llvm.di_composite_type<recId = [[B_RECID]] +; CHECK-DAG: #[[A_SELF:.+]] = #llvm.di_composite_type<{{.*}}recId = [[A_RECID]] +; CHECK-DAG: #[[B_SELF:.+]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID]] ; CHECK: #llvm.di_subprogram<{{.*}}scope = #[[A_OUTER]] @@ -675,11 +678,11 @@ define void @class_field(ptr %arg1) !dbg !18 { ; CHECK-DAG: #llvm.di_subprogram<{{.*}}scope = #[[A]], ; CHECK-DAG: #[[TO_B_OUTER]] = #llvm.di_derived_type<{{.*}}name = "->B", {{.*}}baseType = #[[B_OUTER:.+]]> -; CHECK-DAG: #[[B_OUTER]] = #llvm.di_composite_type<recId = [[B_RECID:.+]], tag = DW_TAG_class_type, name = "B", {{.*}}elements = #[[TO_C_INNER:.+]]> +; CHECK-DAG: #[[B_OUTER]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID:.+]], {{.*}}name = "B", {{.*}}elements = #[[TO_C_INNER:.+]]> ; CHECK-DAG: #[[TO_C_INNER]] = #llvm.di_derived_type<{{.*}}name = "->C", {{.*}}baseType = #[[C_INNER:.+]]> ; CHECK-DAG: #[[C_INNER]] = #llvm.di_composite_type<{{.*}}name = "C", {{.*}}elements = #[[TO_B_SELF:.+]]> ; CHECK-DAG: #[[TO_B_SELF]] = #llvm.di_derived_type<{{.*}}name = "->B", {{.*}}baseType = #[[B_SELF:.+]]> -; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type<recId = [[B_RECID]], isRecSelf = true> +; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID]]> ; CHECK-DAG: #[[TO_C_OUTER]] = #llvm.di_derived_type<{{.*}}name = "->C", {{.*}}baseType = #[[C_OUTER:.+]]> ; CHECK-DAG: #[[C_OUTER]] = #llvm.di_composite_type<{{.*}}name = "C", {{.*}}elements = #[[TO_B_OUTER]]> @@ -715,23 +718,23 @@ define void @class_field(ptr %arg1) !dbg !18 { ; ^ ^ ; +-------------+ -; CHECK-DAG: #[[A:.+]] = #llvm.di_composite_type<recId = [[A_RECID:.+]], tag = DW_TAG_class_type, name = "A", {{.*}}elements = #[[A_TO_B:.+]], #[[A_TO_C:.+]]> +; CHECK-DAG: #[[A:.+]] = #llvm.di_composite_type<{{.*}}recId = [[A_RECID:.+]], {{.*}}name = "A", {{.*}}elements = #[[A_TO_B:.+]], #[[A_TO_C:.+]]> ; CHECK-DAG: #llvm.di_subprogram<{{.*}}scope = #[[A]], ; CHECK-DAG: #[[A_TO_B]] = #llvm.di_derived_type<{{.*}}name = "->B", {{.*}}baseType = #[[B_FROM_A:.+]]> ; CHECK-DAG: #[[A_TO_C]] = #llvm.di_derived_type<{{.*}}name = "->C", {{.*}}baseType = #[[C_FROM_A:.+]]> -; CHECK-DAG: #[[B_FROM_A]] = #llvm.di_composite_type<recId = [[B_RECID:.+]], tag = DW_TAG_class_type, name = "B", {{.*}}elements = #[[B_TO_C:.+]]> +; CHECK-DAG: #[[B_FROM_A]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID:.+]], {{.*}}name = "B", {{.*}}elements = #[[B_TO_C:.+]]> ; CHECK-DAG: #[[B_TO_C]] = #llvm.di_derived_type<{{.*}}name = "->C", {{.*}}baseType = #[[C_FROM_B:.+]]> -; CHECK-DAG: #[[C_FROM_B]] = #llvm.di_composite_type<recId = [[C_RECID:.+]], tag = DW_TAG_class_type, name = "C", {{.*}}elements = #[[TO_A_SELF:.+]], #[[TO_B_SELF:.+]], #[[TO_C_SELF:.+]]> +; CHECK-DAG: #[[C_FROM_B]] = #llvm.di_composite_type<{{.*}}recId = [[C_RECID:.+]], {{.*}}name = "C", {{.*}}elements = #[[TO_A_SELF:.+]], #[[TO_B_SELF:.+]], #[[TO_C_SELF:.+]]> -; CHECK-DAG: #[[C_FROM_A]] = #llvm.di_composite_type<recId = [[C_RECID]], tag = DW_TAG_class_type, name = "C", {{.*}}elements = #[[TO_A_SELF]], #[[A_TO_B:.+]], #[[TO_C_SELF]] +; CHECK-DAG: #[[C_FROM_A]] = #llvm.di_composite_type<{{.*}}recId = [[C_RECID]], {{.*}}name = "C", {{.*}}elements = #[[TO_A_SELF]], #[[A_TO_B:.+]], #[[TO_C_SELF]] ; CHECK-DAG: #[[TO_A_SELF]] = #llvm.di_derived_type<{{.*}}name = "->A", {{.*}}baseType = #[[A_SELF:.+]]> ; CHECK-DAG: #[[TO_B_SELF]] = #llvm.di_derived_type<{{.*}}name = "->B", {{.*}}baseType = #[[B_SELF:.+]]> ; CHECK-DAG: #[[TO_C_SELF]] = #llvm.di_derived_type<{{.*}}name = "->C", {{.*}}baseType = #[[C_SELF:.+]]> -; CHECK-DAG: #[[A_SELF]] = #llvm.di_composite_type<recId = [[A_RECID]], isRecSelf = true> -; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type<recId = [[B_RECID]], isRecSelf = true> -; CHECK-DAG: #[[C_SELF]] = #llvm.di_composite_type<recId = [[C_RECID]], isRecSelf = true> +; CHECK-DAG: #[[A_SELF]] = #llvm.di_composite_type<{{.*}}recId = [[A_RECID]]> +; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID]]> +; CHECK-DAG: #[[C_SELF]] = #llvm.di_composite_type<{{.*}}recId = [[C_RECID]]> define void @class_field(ptr %arg1) !dbg !18 { ret void @@ -813,6 +816,4 @@ define void @imp_fn() !dbg !12 { !17 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !12, entity: !8, file: !3, line: 1, elements: !15) ; CHECK-DAG: #[[M:.+]] = #llvm.di_module<{{.*}}name = "mod1"{{.*}}> -; CHECK-DAG: #[[SP_REC:.+]] = #llvm.di_subprogram<recId = distinct{{.*}}<>, isRecSelf = true> -; CHECK-DAG: #[[IE:.+]] = #llvm.di_imported_entity<tag = DW_TAG_imported_module, scope = #[[SP_REC]], entity = #[[M]]{{.*}}> -; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram<{{.*}}name = "imp_fn"{{.*}}retainedNodes = #[[IE]]> +; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram<{{.*}}name = "imp_fn"{{.*}}retainedNodes = #llvm.di_imported_entity<tag = DW_TAG_imported_module, entity = #[[M]]{{.*}}>> diff --git a/mlir/test/Target/LLVMIR/llvmir-debug.mlir b/mlir/test/Target/LLVMIR/llvmir-debug.mlir index 01194df5047742..30b2ba5e9bad1f 100644 --- a/mlir/test/Target/LLVMIR/llvmir-debug.mlir +++ b/mlir/test/Target/LLVMIR/llvmir-debug.mlir @@ -372,28 +372,23 @@ llvm.func @fn_with_gl() { llvm.func @imp_fn() { llvm.return } loc(#loc2) - -#di_file = #llvm.di_file<"test.f90" in ""> -#di_subroutine_type = #llvm.di_subroutine_type<callingConvention = DW_CC_program> -#di_compile_unit = #llvm.di_compile_unit<id = distinct[0]<>, - sourceLanguage = DW_LANG_Fortran95, file = #di_file, isOptimized = false, +#file = #llvm.di_file<"test.f90" in ""> +#SP_TY = #llvm.di_subroutine_type<callingConvention = DW_CC_program> +#CU = #llvm.di_compile_unit<id = distinct[0]<>, + sourceLanguage = DW_LANG_Fortran95, file = #file, isOptimized = false, emissionKind = Full> -#di_module_1 = #llvm.di_module<file = #di_file, scope = #di_compile_unit, name = "mod1"> -#di_module_2 = #llvm.di_module<file = #di_file, scope = #di_compile_unit, name = "mod2"> -#di_subprogram_self_rec = #llvm.di_subprogram<recId = distinct[1]<>> -#di_imported_entity_1 = #llvm.di_imported_entity<tag = DW_TAG_imported_module, - scope = #di_subprogram_self_rec, entity = #di_module_1, file = #di_file, line = 1> -#di_imported_entity_2 = #llvm.di_imported_entity<tag = DW_TAG_imported_module, - scope = #di_subprogram_self_rec, entity = #di_module_2, file = #di_file, line = 1> -#di_subprogram = #llvm.di_subprogram<id = distinct[2]<>, recId = distinct[1]<>, - compileUnit = #di_compile_unit, scope = #di_file, name = "imp_fn", - file = #di_file, subprogramFlags = Definition, type = #di_subroutine_type, - retainedNodes = #di_imported_entity_1, #di_imported_entity_2> +#MOD = #llvm.di_module<file = #file, scope = #CU, name = "mod1"> +#MOD1 = #llvm.di_module<file = #file, scope = #CU, name = "mod2"> +#SP = #llvm.di_subprogram<id = distinct[1]<>, compileUnit = #CU, scope = #file, + name = "imp_fn", file = #file, subprogramFlags = Definition, type = #SP_TY, + retainedNodes = #llvm.di_imported_entity<tag = DW_TAG_imported_module, + entity = #MOD1, file = #file, line = 1>, #llvm.di_imported_entity<tag + = DW_TAG_imported_module, entity = #MOD, file = #file, line = 1>> #loc1 = loc("test.f90":12:14) -#loc2 = loc(fused<#di_subprogram>[#loc1]) +#loc2 = loc(fused<#SP>[#loc1]) // CHECK-DAG: ![[SP:[0-9]+]] = {{.*}}!DISubprogram(name: "imp_fn"{{.*}}retainedNodes: ![[NODES:[0-9]+]]) -// CHECK-DAG: ![[NODES]] = !{![[NODE1:[0-9]+]], ![[NODE2:[0-9]+]]} +// CHECK-DAG: ![[NODES]] = !{![[NODE2:[0-9]+]], ![[NODE1:[0-9]+]]} // CHECK-DAG: ![[NODE1]] = !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[SP]], entity: ![[MOD1:[0-9]+]]{{.*}}) // CHECK-DAG: ![[NODE2]] = !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[SP]], entity: ![[MOD2:[0-9]+]]{{.*}}) // CHECK-DAG: ![[MOD1]] = !DIModule({{.*}}name: "mod1"{{.*}}) @@ -448,7 +443,7 @@ llvm.func @func_debug_directives() { #di_compile_unit = #llvm.di_compile_unit<id = distinct[1]<>, sourceLanguage = DW_LANG_C, file = #di_file, isOptimized = false, emissionKind = None> // Recursive type itself. -#di_struct_self = #llvm.di_composite_type<recId = distinct[0]<>, isRecSelf = true> +#di_struct_self = #llvm.di_composite_type<tag = DW_TAG_null, recId = distinct[0]<>> #di_ptr_inner = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #di_struct_self, sizeInBits = 64> #di_subroutine_inner = #llvm.di_subroutine_type<types = #di_null_type, #di_ptr_inner> #di_subprogram_inner = #llvm.di_subprogram< @@ -502,7 +497,7 @@ llvm.func @class_method() { // Ensures composite types with a recursive scope work. -#di_composite_type_self = #llvm.di_composite_type<recId = distinct[0]<>, isRecSelf = true> +#di_composite_type_self = #llvm.di_composite_type<tag = DW_TAG_null, recId = distinct[0]<>> #di_file = #llvm.di_file<"test.mlir" in "/"> #di_subroutine_type = #llvm.di_subroutine_type<types = #di_composite_type_self> #di_subprogram = #llvm.di_subprogram<scope = #di_file, file = #di_file, subprogramFlags = Optimized, type = #di_subroutine_type> @@ -513,7 +508,7 @@ llvm.func @class_method() { llvm.mlir.global @global_variable() {dbg_expr = #di_global_variable_expression} : !llvm.struct<()> // CHECK: distinct !DIGlobalVariable({{.*}}type: ![[COMP:[0-9]+]], -// CHECK: ![[COMP]] = distinct !DICompositeType({{.*}}scope: ![[SCOPE:[0-9]+]] +// CHECK: ![[COMP]] = distinct !DICompositeType({{.*}}scope: ![[SCOPE:[0-9]+]], // CHECK: ![[SCOPE]] = !DISubprogram({{.*}}type: ![[SUBROUTINE:[0-9]+]], // CHECK: ![[SUBROUTINE]] = !DISubroutineType(types: ![[SR_TYPES:[0-9]+]]) // CHECK: ![[SR_TYPES]] = !{![[COMP]]} @@ -525,7 +520,7 @@ llvm.mlir.global @global_variable() {dbg_expr = #di_global_variable_expression} // replaced with the recursive self reference. #di_file = #llvm.di_file<"test.mlir" in "/"> -#di_composite_type_self = #llvm.di_composite_type<recId = distinct[0]<>, isRecSelf = true> +#di_composite_type_self = #llvm.di_composite_type<tag = DW_TAG_null, recId = distinct[0]<>> #di_subroutine_type_inner = #llvm.di_subroutine_type<types = #di_composite_type_self> #di_subprogram_inner = #llvm.di_subprogram<scope = #di_file, file = #di_file, subprogramFlags = Optimized, type = #di_subroutine_type_inner> @@ -545,7 +540,7 @@ llvm.mlir.global @global_variable() {dbg_expr = #di_global_variable_expression} // CHECK: distinct !DIGlobalVariable({{.*}}type: ![[VAR:[0-9]+]], // CHECK: ![[VAR]] = !DISubroutineType(types: ![[COMPS:[0-9]+]]) // CHECK: ![[COMPS]] = !{![[COMP:[0-9]+]], -// CHECK: ![[COMP]] = distinct !DICompositeType({{.*}}scope: ![[SCOPE:[0-9]+]] +// CHECK: ![[COMP]] = distinct !DICompositeType({{.*}}scope: ![[SCOPE:[0-9]+]], // CHECK: ![[SCOPE]] = !DISubprogram({{.*}}type: ![[SUBROUTINE:[0-9]+]], // CHECK: ![[SUBROUTINE]] = !DISubroutineType(types: ![[SR_TYPES:[0-9]+]]) // CHECK: ![[SR_TYPES]] = !{![[COMP]]} _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
