From c6ed8b2d9f215c6c65f81e145f68dbaa3a5f2c24 Mon Sep 17 00:00:00 2001 From: Tobias Gysi Date: Thu, 29 Aug 2024 15:29:10 +0000 Subject: [PATCH 1/3] [MLIR][LLVM] Make DISubprogramAttr cyclic This commit implements LLVM_DIRecursiveTypeAttrInterface for the DISubprogramAttr to ensure cyclic subprograms can be imported properly. In the process multiple shortcuts around the recently introduced DIImportedEntityAttr can be removed. --- mlir/include/mlir-c/Dialect/LLVM.h | 22 +++-- .../mlir/Dialect/LLVMIR/LLVMAttrDefs.td | 33 +++++-- mlir/lib/CAPI/Dialect/LLVM.cpp | 31 ++++-- mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp | 16 +++ mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp | 6 +- .../Transforms/DIScopeForLLVMFuncOp.cpp | 4 +- mlir/lib/Target/LLVMIR/DebugImporter.cpp | 23 +++-- mlir/lib/Target/LLVMIR/DebugTranslation.cpp | 98 ++++++++++--------- mlir/lib/Target/LLVMIR/DebugTranslation.h | 18 ++-- mlir/test/CAPI/llvm.c | 19 +++- mlir/test/Target/LLVMIR/Import/debug-info.ll | 20 ++-- mlir/test/Target/LLVMIR/llvmir-debug.mlir | 35 ++++--- 12 files changed, 200 insertions(+), 125 deletions(-) diff --git a/mlir/include/mlir-c/Dialect/LLVM.h b/mlir/include/mlir-c/Dialect/LLVM.h index 5eb96a86e472d..561d698f722af 100644 --- a/mlir/include/mlir-c/Dialect/LLVM.h +++ b/mlir/include/mlir-c/Dialect/LLVM.h @@ -234,6 +234,9 @@ 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 mlirLLVMDICompositeTypeAttrGetSelfRec(MlirAttribute recId); + /// Creates a LLVM DICompositeType attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDICompositeTypeAttrGet( MlirContext ctx, unsigned int tag, MlirAttribute recId, MlirAttribute name, @@ -311,13 +314,16 @@ 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 mlirLLVMDISubprogramAttrGetSelfRec(MlirAttribute recId); + /// Creates a LLVM DISubprogramAttr attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDISubprogramAttrGet( - 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); + MlirContext ctx, MlirAttribute id, MlirAttribute recId, + 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 @@ -356,9 +362,9 @@ MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDIModuleAttrGet( /// Creates a LLVM DIImportedEntityAttr attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDIImportedEntityAttrGet( - MlirContext ctx, unsigned int tag, MlirAttribute entity, MlirAttribute file, - unsigned int line, MlirAttribute name, intptr_t nElements, - MlirAttribute const *elements); + MlirContext ctx, unsigned int tag, MlirAttribute scope, + 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 e57be7f760d38..224e58f3216ab 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td @@ -554,14 +554,16 @@ def LLVM_DILocalVariableAttr : LLVM_Attr<"DILocalVariable", "di_local_variable", //===----------------------------------------------------------------------===// def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", - /*traits=*/[], "DIScopeAttr"> { + [LLVM_DIRecursiveTypeAttrInterface], + "DIScopeAttr"> { let parameters = (ins OptionalParameter<"DistinctAttr">:$id, + OptionalParameter<"DistinctAttr">:$recId, OptionalParameter<"DICompileUnitAttr">:$compileUnit, - "DIScopeAttr":$scope, + OptionalParameter<"DIScopeAttr">:$scope, OptionalParameter<"StringAttr">:$name, OptionalParameter<"StringAttr">:$linkageName, - "DIFileAttr":$file, + OptionalParameter<"DIFileAttr">:$file, OptionalParameter<"unsigned">:$line, OptionalParameter<"unsigned">:$scopeLine, OptionalParameter<"DISubprogramFlags">:$subprogramFlags, @@ -577,13 +579,28 @@ def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", "ArrayRef":$retainedNodes ), [{ MLIRContext *ctx = file.getContext(); - return $_get(ctx, id, compileUnit, scope, StringAttr::get(ctx, name), + return $_get(ctx, id, /*recId=*/nullptr, 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 whether this attr describes a recursive self reference. + bool isRecSelf() { return !getScope(); } + + /// 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); + + /// @} + }]; } //===----------------------------------------------------------------------===// @@ -627,13 +644,9 @@ 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/lib/CAPI/Dialect/LLVM.cpp b/mlir/lib/CAPI/Dialect/LLVM.cpp index 13341f0c4de88..ed4d028e192f5 100644 --- a/mlir/lib/CAPI/Dialect/LLVM.cpp +++ b/mlir/lib/CAPI/Dialect/LLVM.cpp @@ -159,6 +159,11 @@ MlirAttribute mlirLLVMDIBasicTypeAttrGet(MlirContext ctx, unsigned int tag, unwrap(ctx), tag, cast(unwrap(name)), sizeInBits, encoding)); } +MlirAttribute mlirLLVMDICompositeTypeAttrGetSelfRec(MlirAttribute recId) { + return wrap( + DICompositeTypeAttr::getRecSelf(cast(unwrap(recId)))); +} + MlirAttribute mlirLLVMDICompositeTypeAttrGet( MlirContext ctx, unsigned int tag, MlirAttribute recId, MlirAttribute name, MlirAttribute file, uint32_t line, MlirAttribute scope, @@ -289,16 +294,21 @@ MlirAttribute mlirLLVMDISubroutineTypeAttrGet(MlirContext ctx, [](Attribute a) { return cast(a); }))); } +MlirAttribute mlirLLVMDISubprogramAttrGetSelfRec(MlirAttribute recId) { + return wrap(DISubprogramAttr::getRecSelf(cast(unwrap(recId)))); +} + MlirAttribute mlirLLVMDISubprogramAttrGet( - 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) { + MlirContext ctx, MlirAttribute id, MlirAttribute recId, + 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 nodesStorage; nodesStorage.reserve(nRetainedNodes); return wrap(DISubprogramAttr::get( unwrap(ctx), cast(unwrap(id)), + cast(unwrap(recId)), cast(unwrap(compileUnit)), cast(unwrap(scope)), cast(unwrap(name)), cast(unwrap(linkageName)), cast(unwrap(file)), @@ -353,14 +363,15 @@ MlirAttribute mlirLLVMDIModuleAttrGetScope(MlirAttribute diModule) { } MlirAttribute mlirLLVMDIImportedEntityAttrGet( - MlirContext ctx, unsigned int tag, MlirAttribute entity, MlirAttribute file, - unsigned int line, MlirAttribute name, intptr_t nElements, - MlirAttribute const *elements) { + MlirContext ctx, unsigned int tag, MlirAttribute scope, + MlirAttribute entity, MlirAttribute file, unsigned int line, + MlirAttribute name, intptr_t nElements, MlirAttribute const *elements) { SmallVector elementsStorage; elementsStorage.reserve(nElements); return wrap(DIImportedEntityAttr::get( - unwrap(ctx), tag, cast(unwrap(entity)), - cast(unwrap(file)), line, cast(unwrap(name)), + unwrap(ctx), tag, cast(unwrap(scope)), + cast(unwrap(entity)), cast(unwrap(file)), line, + cast(unwrap(name)), llvm::map_to_vector(unwrapList(nElements, elements, elementsStorage), [](Attribute a) { return cast(a); }))); } diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp index 98a9659735e7e..0ce719b9a750c 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp @@ -215,6 +215,22 @@ DICompositeTypeAttr::getRecSelf(DistinctAttr recId) { {}, DIFlags(), 0, 0, {}, {}, {}, {}, {}); } +//===----------------------------------------------------------------------===// +// DISubprogramAttr +//===----------------------------------------------------------------------===// + +DIRecursiveTypeAttrInterface DISubprogramAttr::withRecId(DistinctAttr recId) { + return DISubprogramAttr::get( + getContext(), getId(), recId, getCompileUnit(), getScope(), getName(), + getLinkageName(), getFile(), getLine(), getScopeLine(), + getSubprogramFlags(), getType(), getRetainedNodes()); +} + +DIRecursiveTypeAttrInterface DISubprogramAttr::getRecSelf(DistinctAttr recId) { + return DISubprogramAttr::get(recId.getContext(), {}, recId, {}, {}, {}, {}, 0, + 0, {}, {}, {}, {}); +} + //===----------------------------------------------------------------------===// // TargetFeaturesAttr //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp index 3870aab52f199..6e4a964f1fc93 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 { .CasegetTag(), translate(node->getEntity()), - translate(node->getFile()), node->getLine(), + context, node->getTag(), translate(node->getScope()), + translate(node->getEntity()), translate(node->getFile()), node->getLine(), getStringAttrOrNull(node->getRawName()), elements); } @@ -227,6 +227,7 @@ 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,16 +239,19 @@ 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 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()), - getStringAttrOrNull(node->getRawLinkageName()), - translate(node->getFile()), node->getLine(), - node->getScopeLine(), *subprogramFlags, type, - retainedNodes); + return DISubprogramAttr::get( + context, id, /*recId=*/{}, translate(node->getUnit()), scope, + getStringAttrOrNull(node->getRawName()), + getStringAttrOrNull(node->getRawLinkageName()), + translate(node->getFile()), node->getLine(), node->getScopeLine(), + *subprogramFlags, type, retainedNodes); } DISubrangeAttr DebugImporter::translateImpl(llvm::DISubrange *node) { @@ -374,6 +378,9 @@ 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 042e015f107fe..55060659dd356 100644 --- a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp @@ -96,6 +96,17 @@ llvm::MDString *DebugTranslation::getMDStringOrNull(StringAttr stringAttr) { return llvm::MDString::get(llvmCtx, stringAttr); } +llvm::MDTuple * +DebugTranslation::getMDTupleOrNull(ArrayRef elements) { + if (elements.empty()) + return nullptr; + SmallVector 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()), @@ -138,6 +149,17 @@ 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(attr.getSubprogramFlags()), + /*Unit=*/nullptr); +} + llvm::DICompositeType * DebugTranslation::translateImpl(DICompositeTypeAttr attr) { // TODO: Use distinct attributes to model this, once they have landed. @@ -151,10 +173,6 @@ DebugTranslation::translateImpl(DICompositeTypeAttr attr) { isDistinct = true; } - SmallVector elements; - for (DINodeAttr member : attr.getElements()) - elements.push_back(translate(member)); - return getDistinctOrUnique( isDistinct, llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()), translate(attr.getFile()), attr.getLine(), translate(attr.getScope()), @@ -162,7 +180,7 @@ DebugTranslation::translateImpl(DICompositeTypeAttr attr) { attr.getAlignInBits(), /*OffsetInBits=*/0, /*Flags=*/static_cast(attr.getFlags()), - llvm::MDNode::get(llvmCtx, elements), + getMDTupleOrNull(attr.getElements()), /*RuntimeLang=*/0, /*VTableHolder=*/nullptr, /*TemplateParams=*/nullptr, /*Identifier=*/nullptr, /*Discriminator=*/nullptr, @@ -242,22 +260,21 @@ DebugTranslation::translateImpl(DIGlobalVariableAttr attr) { attr.getIsDefined(), nullptr, nullptr, attr.getAlignInBits(), nullptr); } -llvm::DIType * +llvm::DINode * DebugTranslation::translateRecursive(DIRecursiveTypeAttrInterface attr) { DistinctAttr recursiveId = attr.getRecId(); - if (auto *iter = recursiveTypeMap.find(recursiveId); - iter != recursiveTypeMap.end()) { + if (auto *iter = recursiveNodeMap.find(recursiveId); + iter != recursiveNodeMap.end()) { return iter->second; - } else { - assert(!attr.isRecSelf() && "unbound DI recursive self type"); } + assert(!attr.isRecSelf() && "unbound DI recursive self reference"); - auto setRecursivePlaceholder = [&](llvm::DIType *placeholder) { - recursiveTypeMap.try_emplace(recursiveId, placeholder); + auto setRecursivePlaceholder = [&](llvm::DINode *placeholder) { + recursiveNodeMap.try_emplace(recursiveId, placeholder); }; - llvm::DIType *result = - TypeSwitch(attr) + llvm::DINode *result = + TypeSwitch(attr) .Case([&](auto attr) { auto temporary = translateTemporaryImpl(attr); setRecursivePlaceholder(temporary.get()); @@ -266,11 +283,20 @@ DebugTranslation::translateRecursive(DIRecursiveTypeAttrInterface attr) { auto *concrete = translateImpl(attr); temporary->replaceAllUsesWith(concrete); return concrete; + }) + .Case([&](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(recursiveTypeMap.back().first == recursiveId && + assert(recursiveNodeMap.back().first == recursiveId && "internal inconsistency: unexpected recursive translation stack"); - recursiveTypeMap.pop_back(); + recursiveNodeMap.pop_back(); return result; } @@ -297,6 +323,7 @@ llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) { bool isDefinition = static_cast(attr.getSubprogramFlags() & LLVM::DISubprogramFlags::Definition); + llvm::DISubprogram *node = getDistinctOrUnique( isDefinition, llvmCtx, scope, getMDStringOrNull(attr.getName()), getMDStringOrNull(attr.getLinkageName()), file, attr.getLine(), type, @@ -304,21 +331,8 @@ llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) { /*ContainingType=*/nullptr, /*VirtualIndex=*/0, /*ThisAdjustment=*/0, llvm::DINode::FlagZero, static_cast(attr.getSubprogramFlags()), - 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 retainedNodes; - for (DINodeAttr nodeAttr : attr.getRetainedNodes()) { - if (auto importedAttr = dyn_cast(nodeAttr)) { - llvm::DINode *dn = translate(importedAttr, node); - retainedNodes.push_back(dn); - } - } - if (!retainedNodes.empty()) - node->replaceRetainedNodes(llvm::MDTuple::get(llvmCtx, retainedNodes)); - + compileUnit, /*TemplateParams=*/nullptr, /*Declaration=*/nullptr, + getMDTupleOrNull(attr.getRetainedNodes())); if (attr.getId()) distinctAttrToNode.try_emplace(attr.getId(), node); return node; @@ -339,16 +353,12 @@ llvm::DINamespace *DebugTranslation::translateImpl(DINamespaceAttr attr) { attr.getExportSymbols()); } -llvm::DIImportedEntity *DebugTranslation::translate(DIImportedEntityAttr attr, - llvm::DIScope *scope) { - SmallVector elements; - for (DINodeAttr member : attr.getElements()) - elements.push_back(translate(member)); - +llvm::DIImportedEntity * +DebugTranslation::translateImpl(DIImportedEntityAttr attr) { return llvm::DIImportedEntity::get( - llvmCtx, attr.getTag(), scope, translate(attr.getEntity()), - translate(attr.getFile()), attr.getLine(), - getMDStringOrNull(attr.getName()), llvm::MDNode::get(llvmCtx, elements)); + llvmCtx, attr.getTag(), translate(attr.getScope()), + translate(attr.getEntity()), translate(attr.getFile()), attr.getLine(), + getMDStringOrNull(attr.getName()), getMDTupleOrNull(attr.getElements())); } llvm::DISubrange *DebugTranslation::translateImpl(DISubrangeAttr attr) { @@ -413,10 +423,10 @@ llvm::DINode *DebugTranslation::translate(DINodeAttr attr) { node = TypeSwitch(attr) .Case( + DIImportedEntityAttr, 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 37b985acf8541..422aa34e28f3c 100644 --- a/mlir/lib/Target/LLVMIR/DebugTranslation.h +++ b/mlir/lib/Target/LLVMIR/DebugTranslation.h @@ -75,6 +75,7 @@ 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); @@ -90,27 +91,26 @@ 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`. /// - ` translateTemporaryImpl()`: /// Create a temporary translation of the DI attr without recursively /// translating any nested DI attrs. - llvm::DIType *translateRecursive(DIRecursiveTypeAttrInterface attr); + llvm::DINode *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 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 attrToNode; - /// A mapping between recursive ID and the translated DIType. - llvm::MapVector recursiveTypeMap; + /// A mapping between recursive ID and the translated DINode. + llvm::MapVector recursiveNodeMap; /// 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 da28a96f89691..a4fa2d7a5c9e9 100644 --- a/mlir/test/CAPI/llvm.c +++ b/mlir/test/CAPI/llvm.c @@ -248,7 +248,11 @@ static void testDebugInfoAttributes(MlirContext ctx) { mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("foo")); MlirAttribute bar = mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("bar")); - MlirAttribute id = mlirDisctinctAttrCreate(foo); + + MlirAttribute none = mlirUnitAttrGet(ctx); + MlirAttribute id = mlirDisctinctAttrCreate(none); + MlirAttribute recId0 = mlirDisctinctAttrCreate(none); + MlirAttribute recId1 = mlirDisctinctAttrCreate(none); // CHECK: #llvm.di_null_type mlirAttributeDump(mlirLLVMDINullTypeAttrGet(ctx)); @@ -312,14 +316,16 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_subroutine_type<{{.*}}> mlirAttributeDump(subroutine_type); + MlirAttribute di_subprogram_self_rec = + mlirLLVMDISubprogramAttrGetSelfRec(recId0); MlirAttribute di_imported_entity = mlirLLVMDIImportedEntityAttrGet( - ctx, 0, di_module, file, 1, foo, 1, &local_var); + ctx, 0, di_subprogram_self_rec, di_module, file, 1, foo, 1, &local_var); mlirAttributeDump(di_imported_entity); // CHECK: #llvm.di_imported_entity<{{.*}}> MlirAttribute di_subprogram = mlirLLVMDISubprogramAttrGet( - ctx, id, compile_unit, compile_unit, foo, bar, file, 1, 2, 0, + ctx, id, recId0, compile_unit, compile_unit, foo, bar, file, 1, 2, 0, subroutine_type, 1, &di_imported_entity); // CHECK: #llvm.di_subprogram<{{.*}}> mlirAttributeDump(di_subprogram); @@ -350,10 +356,13 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_string_type<{{.*}}> mlirAttributeDump(string_type); + // CHECK: #llvm.di_composite_type + mlirAttributeDump(mlirLLVMDICompositeTypeAttrGetSelfRec(recId1)); + // CHECK: #llvm.di_composite_type<{{.*}}> mlirAttributeDump(mlirLLVMDICompositeTypeAttrGet( - ctx, 0, id, foo, file, 1, compile_unit, di_type, 0, 64, 8, 1, &di_type, - expression, expression, expression, expression)); + ctx, 0, recId1, 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 bb03da37c0d09..59b87d08730f6 100644 --- a/mlir/test/Target/LLVMIR/Import/debug-info.ll +++ b/mlir/test/Target/LLVMIR/Import/debug-info.ll @@ -307,17 +307,13 @@ define void @class_method() { ret void, !dbg !9 } -; Verify the cyclic composite type is identified, even though conversion begins from the subprogram type. -; CHECK-DAG: #[[COMP_SELF:.+]] = #llvm.di_composite_type -; CHECK-DAG: #[[COMP_PTR:.+]] = #llvm.di_derived_type +; Verify the cyclic subprogram is handled correctly. +; CHECK-DAG: #[[SP_SELF:.+]] = #llvm.di_subprogram +; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type +; CHECK-DAG: #[[COMP_PTR:.+]] = #llvm.di_derived_type ; CHECK-DAG: #[[SP_TYPE:.+]] = #llvm.di_subroutine_type -; CHECK-DAG: #[[SP_INNER:.+]] = #llvm.di_subprogram -; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type - -; CHECK-DAG: #[[COMP_PTR_OUTER:.+]] = #llvm.di_derived_type -; CHECK-DAG: #[[SP_TYPE_OUTER:.+]] = #llvm.di_subroutine_type -; CHECK-DAG: #[[SP_OUTER:.+]] = #llvm.di_subprogram -; CHECK-DAG: #[[LOC]] = loc(fused<#[[SP_OUTER]]> +; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram +; CHECK-DAG: #[[LOC]] = loc(fused<#[[SP]]> !llvm.dbg.cu = !{!1} !llvm.module.flags = !{!0} @@ -816,4 +812,6 @@ 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:.+]] = #llvm.di_subprogram<{{.*}}name = "imp_fn"{{.*}}retainedNodes = #llvm.di_imported_entity> +; CHECK-DAG: #[[SP_REC:.+]] = #llvm.di_subprogram> +; CHECK-DAG: #[[IE:.+]] = #llvm.di_imported_entity +; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram<{{.*}}name = "imp_fn"{{.*}}retainedNodes = #[[IE]]> diff --git a/mlir/test/Target/LLVMIR/llvmir-debug.mlir b/mlir/test/Target/LLVMIR/llvmir-debug.mlir index 30b2ba5e9bad1..f1d7f2a50e974 100644 --- a/mlir/test/Target/LLVMIR/llvmir-debug.mlir +++ b/mlir/test/Target/LLVMIR/llvmir-debug.mlir @@ -372,23 +372,28 @@ llvm.func @fn_with_gl() { llvm.func @imp_fn() { llvm.return } loc(#loc2) -#file = #llvm.di_file<"test.f90" in ""> -#SP_TY = #llvm.di_subroutine_type -#CU = #llvm.di_compile_unit, - sourceLanguage = DW_LANG_Fortran95, file = #file, isOptimized = false, + +#di_file = #llvm.di_file<"test.f90" in ""> +#di_subroutine_type = #llvm.di_subroutine_type +#di_compile_unit = #llvm.di_compile_unit, + sourceLanguage = DW_LANG_Fortran95, file = #di_file, isOptimized = false, emissionKind = Full> -#MOD = #llvm.di_module -#MOD1 = #llvm.di_module -#SP = #llvm.di_subprogram, compileUnit = #CU, scope = #file, - name = "imp_fn", file = #file, subprogramFlags = Definition, type = #SP_TY, - retainedNodes = #llvm.di_imported_entity, #llvm.di_imported_entity> +#di_module_1 = #llvm.di_module +#di_module_2 = #llvm.di_module +#di_subprogram_self_rec = #llvm.di_subprogram> +#di_imported_entity_1 = #llvm.di_imported_entity +#di_imported_entity_2 = #llvm.di_imported_entity +#di_subprogram = #llvm.di_subprogram, 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> #loc1 = loc("test.f90":12:14) -#loc2 = loc(fused<#SP>[#loc1]) +#loc2 = loc(fused<#di_subprogram>[#loc1]) // CHECK-DAG: ![[SP:[0-9]+]] = {{.*}}!DISubprogram(name: "imp_fn"{{.*}}retainedNodes: ![[NODES:[0-9]+]]) -// CHECK-DAG: ![[NODES]] = !{![[NODE2:[0-9]+]], ![[NODE1:[0-9]+]]} +// CHECK-DAG: ![[NODES]] = !{![[NODE1:[0-9]+]], ![[NODE2:[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"{{.*}}) @@ -508,7 +513,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]]} @@ -540,7 +545,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]]} From 988d78eee2ddb98a08a98688272c881c4a873085 Mon Sep 17 00:00:00 2001 From: Tobias Gysi Date: Thu, 29 Aug 2024 19:05:52 +0000 Subject: [PATCH 2/3] Address comments. --- .../Transforms/DebugTypeGenerator.cpp | 10 ++-- mlir/include/mlir-c/Dialect/LLVM.h | 10 ++-- .../mlir/Dialect/LLVMIR/LLVMAttrDefs.td | 47 ++++++++++++------- .../mlir/Dialect/LLVMIR/LLVMInterfaces.td | 2 +- mlir/lib/CAPI/Dialect/LLVM.cpp | 16 +++---- mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp | 23 ++++----- .../Transforms/DIScopeForLLVMFuncOp.cpp | 8 ++-- mlir/lib/Target/LLVMIR/DebugImporter.cpp | 19 ++++---- mlir/lib/Target/LLVMIR/DebugTranslation.cpp | 2 +- mlir/test/CAPI/llvm.c | 14 +++--- mlir/test/Target/LLVMIR/Import/debug-info.ll | 39 +++++++-------- mlir/test/Target/LLVMIR/llvmir-debug.mlir | 6 +-- 12 files changed, 104 insertions(+), 92 deletions(-) diff --git a/flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp b/flang/lib/Optimizer/Transforms/DebugTypeGenerator.cpp index 54f2a12d80008..029d3776bcc0b 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, /*recursive_id=*/{}, - /*name=*/nullptr, /*file=*/nullptr, /*line=*/0, /*scope=*/nullptr, elemTy, + context, llvm::dwarf::DW_TAG_array_type, /*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, /*recursive_id=*/{}, + context, llvm::dwarf::DW_TAG_structure_type, 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, /*recursive_id=*/{}, - /*name=*/nullptr, /*file=*/nullptr, /*line=*/0, /*scope=*/nullptr, elemTy, + context, llvm::dwarf::DW_TAG_array_type, /*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 561d698f722af..38bd4d2f3587b 100644 --- a/mlir/include/mlir-c/Dialect/LLVM.h +++ b/mlir/include/mlir-c/Dialect/LLVM.h @@ -235,12 +235,12 @@ MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDIBasicTypeAttrGet( MlirLLVMTypeEncoding encoding); /// Creates a self-referencing LLVM DICompositeType attribute. -MlirAttribute mlirLLVMDICompositeTypeAttrGetSelfRec(MlirAttribute recId); +MlirAttribute mlirLLVMDICompositeTypeAttrGetRecSelf(MlirAttribute recId); /// Creates a LLVM DICompositeType attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDICompositeTypeAttrGet( - MlirContext ctx, unsigned int tag, MlirAttribute recId, MlirAttribute name, - MlirAttribute file, uint32_t line, MlirAttribute scope, + MlirContext ctx, MlirAttribute recId, bool isRecSelf, unsigned int tag, + 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, @@ -315,11 +315,11 @@ MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDILocalVariableAttrGet( unsigned int alignInBits, MlirAttribute diType, int64_t flags); /// Creates a self-referencing LLVM DISubprogramAttr attribute. -MlirAttribute mlirLLVMDISubprogramAttrGetSelfRec(MlirAttribute recId); +MlirAttribute mlirLLVMDISubprogramAttrGetRecSelf(MlirAttribute recId); /// Creates a LLVM DISubprogramAttr attribute. MLIR_CAPI_EXPORTED MlirAttribute mlirLLVMDISubprogramAttrGet( - MlirContext ctx, MlirAttribute id, MlirAttribute recId, + 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, diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td index 224e58f3216ab..49e54df3436ff 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=*/"", "Tag", /*errorCase=*/"llvm::dwarf::DW_TAG_invalid" + "tag", /*default=*/"0", "Tag", /*errorCase=*/"llvm::dwarf::DW_TAG_invalid" >; def LLVM_DIOperationEncodingParameter : LLVM_DIParameter< @@ -375,14 +375,17 @@ def LLVM_DICompositeTypeAttr : LLVM_Attr<"DICompositeType", "di_composite_type", [LLVM_DIRecursiveTypeAttrInterface], "DITypeAttr"> { let parameters = (ins - LLVM_DITagParameter:$tag, + // DIRecursiveTypeAttrInterface specific parameters. OptionalParameter<"DistinctAttr">:$recId, + OptionalParameter<"bool">:$isRecSelf, + // DICompositeType specific parameters. + LLVM_DITagParameter:$tag, OptionalParameter<"StringAttr">:$name, OptionalParameter<"DIFileAttr">:$file, OptionalParameter<"uint32_t">:$line, OptionalParameter<"DIScopeAttr">:$scope, OptionalParameter<"DITypeAttr">:$baseType, - OptionalParameter<"DIFlags", "DIFlags::Zero">:$flags, + OptionalParameter<"DIFlags">:$flags, OptionalParameter<"uint64_t">:$sizeInBits, OptionalParameter<"uint64_t">:$alignInBits, OptionalArrayRefParameter<"DINodeAttr">:$elements, @@ -391,14 +394,26 @@ 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":$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); @@ -557,8 +572,11 @@ def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", [LLVM_DIRecursiveTypeAttrInterface], "DIScopeAttr"> { let parameters = (ins - OptionalParameter<"DistinctAttr">:$id, + // DIRecursiveTypeAttrInterface specific parameters. OptionalParameter<"DistinctAttr">:$recId, + OptionalParameter<"bool">:$isRecSelf, + // DISubprogramAttr specific parameters. + OptionalParameter<"DistinctAttr">:$id, OptionalParameter<"DICompileUnitAttr">:$compileUnit, OptionalParameter<"DIScopeAttr">:$scope, OptionalParameter<"StringAttr">:$name, @@ -571,18 +589,16 @@ def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", OptionalArrayRefParameter<"DINodeAttr">:$retainedNodes ); let builders = [ - AttrBuilderWithInferredContext<(ins + AttrBuilder<(ins "DistinctAttr":$id, "DICompileUnitAttr":$compileUnit, - "DIScopeAttr":$scope, "StringRef":$name, "StringRef":$linkageName, + "DIScopeAttr":$scope, "StringAttr":$name, "StringAttr":$linkageName, "DIFileAttr":$file, "unsigned":$line, "unsigned":$scopeLine, "DISubprogramFlags":$subprogramFlags, "DISubroutineTypeAttr":$type, "ArrayRef":$retainedNodes ), [{ - MLIRContext *ctx = file.getContext(); - return $_get(ctx, id, /*recId=*/nullptr, compileUnit, scope, - StringAttr::get(ctx, name), - StringAttr::get(ctx, linkageName), file, line, - scopeLine, subprogramFlags, type, retainedNodes); + return $_get($_ctxt, /*recId=*/nullptr, /*isRecSelf=*/false, id, compileUnit, + scope, name, linkageName, file, line, scopeLine, + subprogramFlags, type, retainedNodes); }]> ]; let assemblyFormat = "`<` struct(params) `>`"; @@ -590,9 +606,6 @@ def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram", /// Requirements of DIRecursiveTypeAttrInterface. /// @{ - /// Get whether this attr describes a recursive self reference. - bool isRecSelf() { return !getScope(); } - /// Get a copy of this type attr but with the recursive ID set to `recId`. DIRecursiveTypeAttrInterface withRecId(DistinctAttr recId); diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMInterfaces.td index 7085f81e203a1..e2180410a8f04 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", "isRecSelf", (ins)>, + }], "bool", "getIsRecSelf", (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 ed4d028e192f5..03b536d7aad98 100644 --- a/mlir/lib/CAPI/Dialect/LLVM.cpp +++ b/mlir/lib/CAPI/Dialect/LLVM.cpp @@ -159,14 +159,14 @@ MlirAttribute mlirLLVMDIBasicTypeAttrGet(MlirContext ctx, unsigned int tag, unwrap(ctx), tag, cast(unwrap(name)), sizeInBits, encoding)); } -MlirAttribute mlirLLVMDICompositeTypeAttrGetSelfRec(MlirAttribute recId) { +MlirAttribute mlirLLVMDICompositeTypeAttrGetRecSelf(MlirAttribute recId) { return wrap( DICompositeTypeAttr::getRecSelf(cast(unwrap(recId)))); } MlirAttribute mlirLLVMDICompositeTypeAttrGet( - MlirContext ctx, unsigned int tag, MlirAttribute recId, MlirAttribute name, - MlirAttribute file, uint32_t line, MlirAttribute scope, + MlirContext ctx, MlirAttribute recId, bool isRecSelf, unsigned int tag, + 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 +175,7 @@ MlirAttribute mlirLLVMDICompositeTypeAttrGet( elementsStorage.reserve(nElements); return wrap(DICompositeTypeAttr::get( - unwrap(ctx), tag, cast(unwrap(recId)), + unwrap(ctx), cast(unwrap(recId)), isRecSelf, tag, cast(unwrap(name)), cast(unwrap(file)), line, cast(unwrap(scope)), cast(unwrap(baseType)), DIFlags(flags), sizeInBits, alignInBits, @@ -294,12 +294,12 @@ MlirAttribute mlirLLVMDISubroutineTypeAttrGet(MlirContext ctx, [](Attribute a) { return cast(a); }))); } -MlirAttribute mlirLLVMDISubprogramAttrGetSelfRec(MlirAttribute recId) { +MlirAttribute mlirLLVMDISubprogramAttrGetRecSelf(MlirAttribute recId) { return wrap(DISubprogramAttr::getRecSelf(cast(unwrap(recId)))); } MlirAttribute mlirLLVMDISubprogramAttrGet( - MlirContext ctx, MlirAttribute id, MlirAttribute recId, + 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, @@ -307,8 +307,8 @@ MlirAttribute mlirLLVMDISubprogramAttrGet( SmallVector nodesStorage; nodesStorage.reserve(nRetainedNodes); return wrap(DISubprogramAttr::get( - unwrap(ctx), cast(unwrap(id)), - cast(unwrap(recId)), + unwrap(ctx), cast(unwrap(recId)), isRecSelf, + cast(unwrap(id)), cast(unwrap(compileUnit)), cast(unwrap(scope)), cast(unwrap(name)), cast(unwrap(linkageName)), cast(unwrap(file)), diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp index 0ce719b9a750c..4fb2590ce11a7 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp @@ -203,16 +203,17 @@ void printExpressionArg(AsmPrinter &printer, uint64_t opcode, DIRecursiveTypeAttrInterface DICompositeTypeAttr::withRecId(DistinctAttr recId) { return DICompositeTypeAttr::get( - getContext(), getTag(), recId, getName(), getFile(), getLine(), - getScope(), getBaseType(), getFlags(), getSizeInBits(), getAlignInBits(), - getElements(), getDataLocation(), getRank(), getAllocated(), - getAssociated()); + getContext(), recId, /*isRecSelf=*/false, getTag(), getName(), getFile(), + getLine(), getScope(), getBaseType(), getFlags(), getSizeInBits(), + getAlignInBits(), getElements(), getDataLocation(), getRank(), + getAllocated(), getAssociated()); } DIRecursiveTypeAttrInterface DICompositeTypeAttr::getRecSelf(DistinctAttr recId) { - return DICompositeTypeAttr::get(recId.getContext(), 0, recId, {}, {}, 0, {}, - {}, DIFlags(), 0, 0, {}, {}, {}, {}, {}); + return DICompositeTypeAttr::get(recId.getContext(), recId, /*isRecSelf=*/true, + 0, {}, {}, 0, {}, {}, DIFlags(), 0, 0, {}, {}, + {}, {}, {}); } //===----------------------------------------------------------------------===// @@ -221,14 +222,14 @@ DICompositeTypeAttr::getRecSelf(DistinctAttr recId) { DIRecursiveTypeAttrInterface DISubprogramAttr::withRecId(DistinctAttr recId) { return DISubprogramAttr::get( - getContext(), getId(), recId, getCompileUnit(), getScope(), getName(), - getLinkageName(), getFile(), getLine(), getScopeLine(), - getSubprogramFlags(), getType(), getRetainedNodes()); + getContext(), recId, /*isRecSelf=*/false, getId(), getCompileUnit(), + getScope(), getName(), getLinkageName(), getFile(), getLine(), + getScopeLine(), getSubprogramFlags(), getType(), getRetainedNodes()); } DIRecursiveTypeAttrInterface DISubprogramAttr::getRecSelf(DistinctAttr recId) { - return DISubprogramAttr::get(recId.getContext(), {}, recId, {}, {}, {}, {}, 0, - 0, {}, {}, {}, {}); + return DISubprogramAttr::get(recId.getContext(), recId, /*isRecSelf=*/true, + {}, {}, {}, {}, {}, 0, 0, {}, {}, {}, {}); } //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp b/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp index ad9aa7ac80caf..2cfaffa7c8efc 100644 --- a/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp +++ b/mlir/lib/Dialect/LLVMIR/Transforms/DIScopeForLLVMFuncOp.cpp @@ -65,7 +65,6 @@ 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; @@ -75,11 +74,10 @@ static void addScopeToFunction(LLVM::LLVMFuncOp llvmFunc, } else { compileUnitAttr = {}; } + auto funcName = StringAttr::get(context, llvmFunc.getName()); auto subprogramAttr = LLVM::DISubprogramAttr::get( - context, id, /*recId=*/{}, compileUnitAttr, fileAttr, funcNameAttr, - funcNameAttr, fileAttr, - /*line=*/line, - /*scopeline=*/col, subprogramFlags, subroutineTypeAttr, + context, id, compileUnitAttr, fileAttr, funcName, funcName, 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 509451057dd73..8c6f32f6bb0cd 100644 --- a/mlir/lib/Target/LLVMIR/DebugImporter.cpp +++ b/mlir/lib/Target/LLVMIR/DebugImporter.cpp @@ -89,10 +89,9 @@ DICompositeTypeAttr DebugImporter::translateImpl(llvm::DICompositeType *node) { if (node->getTag() == llvm::dwarf::DW_TAG_array_type && !baseType) return nullptr; return DICompositeTypeAttr::get( - context, node->getTag(), /*recId=*/{}, - getStringAttrOrNull(node->getRawName()), translate(node->getFile()), - node->getLine(), translate(node->getScope()), baseType, - flags.value_or(DIFlags::Zero), node->getSizeInBits(), + context, node->getTag(), 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()), @@ -246,12 +245,12 @@ DISubprogramAttr DebugImporter::translateImpl(llvm::DISubprogram *node) { if (llvm::is_contained(retainedNodes, nullptr)) retainedNodes.clear(); - return DISubprogramAttr::get( - context, id, /*recId=*/{}, translate(node->getUnit()), scope, - getStringAttrOrNull(node->getRawName()), - getStringAttrOrNull(node->getRawLinkageName()), - translate(node->getFile()), node->getLine(), node->getScopeLine(), - *subprogramFlags, type, retainedNodes); + return DISubprogramAttr::get(context, id, translate(node->getUnit()), scope, + getStringAttrOrNull(node->getRawName()), + getStringAttrOrNull(node->getRawLinkageName()), + translate(node->getFile()), node->getLine(), + node->getScopeLine(), *subprogramFlags, type, + retainedNodes); } DISubrangeAttr DebugImporter::translateImpl(llvm::DISubrange *node) { diff --git a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp index 55060659dd356..8ca3beca6b66f 100644 --- a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp @@ -267,7 +267,7 @@ DebugTranslation::translateRecursive(DIRecursiveTypeAttrInterface attr) { iter != recursiveNodeMap.end()) { return iter->second; } - assert(!attr.isRecSelf() && "unbound DI recursive self reference"); + assert(!attr.getIsRecSelf() && "unbound DI recursive self reference"); auto setRecursivePlaceholder = [&](llvm::DINode *placeholder) { recursiveNodeMap.try_emplace(recursiveId, placeholder); diff --git a/mlir/test/CAPI/llvm.c b/mlir/test/CAPI/llvm.c index a4fa2d7a5c9e9..36277122801de 100644 --- a/mlir/test/CAPI/llvm.c +++ b/mlir/test/CAPI/llvm.c @@ -257,7 +257,7 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_null_type mlirAttributeDump(mlirLLVMDINullTypeAttrGet(ctx)); - // CHECK: #llvm.di_basic_type MlirAttribute di_type = mlirLLVMDIBasicTypeAttrGet(ctx, 0, foo, 64, MlirLLVMTypeEncodingSigned); @@ -317,7 +317,7 @@ static void testDebugInfoAttributes(MlirContext ctx) { mlirAttributeDump(subroutine_type); MlirAttribute di_subprogram_self_rec = - mlirLLVMDISubprogramAttrGetSelfRec(recId0); + mlirLLVMDISubprogramAttrGetRecSelf(recId0); MlirAttribute di_imported_entity = mlirLLVMDIImportedEntityAttrGet( ctx, 0, di_subprogram_self_rec, di_module, file, 1, foo, 1, &local_var); @@ -325,8 +325,8 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_imported_entity<{{.*}}> MlirAttribute di_subprogram = mlirLLVMDISubprogramAttrGet( - ctx, id, recId0, compile_unit, compile_unit, foo, bar, file, 1, 2, 0, - subroutine_type, 1, &di_imported_entity); + ctx, recId0, false, 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,12 +356,12 @@ static void testDebugInfoAttributes(MlirContext ctx) { // CHECK: #llvm.di_string_type<{{.*}}> mlirAttributeDump(string_type); - // CHECK: #llvm.di_composite_type - mlirAttributeDump(mlirLLVMDICompositeTypeAttrGetSelfRec(recId1)); + // CHECK: #llvm.di_composite_type + mlirAttributeDump(mlirLLVMDICompositeTypeAttrGetRecSelf(recId1)); // CHECK: #llvm.di_composite_type<{{.*}}> mlirAttributeDump(mlirLLVMDICompositeTypeAttrGet( - ctx, 0, recId1, foo, file, 1, compile_unit, di_type, 0, 64, 8, 1, + ctx, recId1, false, 0, foo, file, 1, compile_unit, di_type, 0, 64, 8, 1, &di_type, expression, expression, expression, expression)); } diff --git a/mlir/test/Target/LLVMIR/Import/debug-info.ll b/mlir/test/Target/LLVMIR/Import/debug-info.ll index 59b87d08730f6..02e35ae7f0ee9 100644 --- a/mlir/test/Target/LLVMIR/Import/debug-info.ll +++ b/mlir/test/Target/LLVMIR/Import/debug-info.ll @@ -308,11 +308,11 @@ define void @class_method() { } ; Verify the cyclic subprogram is handled correctly. -; CHECK-DAG: #[[SP_SELF:.+]] = #llvm.di_subprogram +; CHECK-DAG: #[[SP_SELF:.+]] = #llvm.di_subprogram ; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type ; CHECK-DAG: #[[COMP_PTR:.+]] = #llvm.di_derived_type ; CHECK-DAG: #[[SP_TYPE:.+]] = #llvm.di_subroutine_type -; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram +; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram ; CHECK-DAG: #[[LOC]] = loc(fused<#[[SP]]> !llvm.dbg.cu = !{!1} @@ -331,10 +331,10 @@ define void @class_method() { ; // ----- ; Verify the cyclic composite type is handled correctly. -; CHECK-DAG: #[[COMP_SELF:.+]] = #llvm.di_composite_type +; CHECK-DAG: #[[COMP_SELF:.+]] = #llvm.di_composite_type ; CHECK-DAG: #[[COMP_PTR_INNER:.+]] = #llvm.di_derived_type ; CHECK-DAG: #[[FIELD:.+]] = #llvm.di_derived_type -; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type +; CHECK-DAG: #[[COMP:.+]] = #llvm.di_composite_type ; CHECK-DAG: #[[COMP_PTR_OUTER:.+]] = #llvm.di_derived_type ; CHECK-DAG: #[[VAR0:.+]] = #llvm.di_local_variable @@ -606,9 +606,10 @@ define void @distinct_cu_func1() !dbg !5 { ; CHECK-LABEL: @declaration declare !dbg !1 void @declaration() -; CHECK: #di_subprogram = #llvm.di_subprogram< +; CHECK: #[[SP:.+]] = #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} @@ -629,14 +630,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:.+]], {{.*}}name = "B", {{.*}}elements = #[[B1_INNER]], #[[B2_INNER]] +; CHECK-DAG: #[[B_INNER:.+]] = #llvm.di_composite_type ; 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:.+]], {{.*}}name = "A", {{.*}}elements = #[[B1_OUTER]], #[[B2_OUTER]] +; CHECK-DAG: #[[A_OUTER:.+]] = #llvm.di_composite_typeB", {{.*}}baseType = #[[B_OUTER:.+]]> -; CHECK-DAG: #[[B_OUTER]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID:.+]], {{.*}}name = "B", {{.*}}elements = #[[TO_C_INNER:.+]]> +; CHECK-DAG: #[[B_OUTER]] = #llvm.di_composite_type ; 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]]> +; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type ; 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]]> @@ -714,23 +715,23 @@ define void @class_field(ptr %arg1) !dbg !18 { ; ^ ^ ; +-------------+ -; CHECK-DAG: #[[A:.+]] = #llvm.di_composite_type<{{.*}}recId = [[A_RECID:.+]], {{.*}}name = "A", {{.*}}elements = #[[A_TO_B:.+]], #[[A_TO_C:.+]]> +; CHECK-DAG: #[[A:.+]] = #llvm.di_composite_type ; 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:.+]], {{.*}}name = "B", {{.*}}elements = #[[B_TO_C:.+]]> +; CHECK-DAG: #[[B_FROM_A]] = #llvm.di_composite_type ; 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:.+]], {{.*}}name = "C", {{.*}}elements = #[[TO_A_SELF:.+]], #[[TO_B_SELF:.+]], #[[TO_C_SELF:.+]]> +; CHECK-DAG: #[[C_FROM_B]] = #llvm.di_composite_type -; 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: #[[C_FROM_A]] = #llvm.di_composite_typeA", {{.*}}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]]> -; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type<{{.*}}recId = [[B_RECID]]> -; CHECK-DAG: #[[C_SELF]] = #llvm.di_composite_type<{{.*}}recId = [[C_RECID]]> +; CHECK-DAG: #[[A_SELF]] = #llvm.di_composite_type +; CHECK-DAG: #[[B_SELF]] = #llvm.di_composite_type +; CHECK-DAG: #[[C_SELF]] = #llvm.di_composite_type define void @class_field(ptr %arg1) !dbg !18 { ret void @@ -812,6 +813,6 @@ 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> +; CHECK-DAG: #[[SP_REC:.+]] = #llvm.di_subprogram, isRecSelf = true> ; CHECK-DAG: #[[IE:.+]] = #llvm.di_imported_entity ; CHECK-DAG: #[[SP:.+]] = #llvm.di_subprogram<{{.*}}name = "imp_fn"{{.*}}retainedNodes = #[[IE]]> diff --git a/mlir/test/Target/LLVMIR/llvmir-debug.mlir b/mlir/test/Target/LLVMIR/llvmir-debug.mlir index f1d7f2a50e974..5eec0afa020fa 100644 --- a/mlir/test/Target/LLVMIR/llvmir-debug.mlir +++ b/mlir/test/Target/LLVMIR/llvmir-debug.mlir @@ -448,7 +448,7 @@ llvm.func @func_debug_directives() { #di_compile_unit = #llvm.di_compile_unit, sourceLanguage = DW_LANG_C, file = #di_file, isOptimized = false, emissionKind = None> // Recursive type itself. -#di_struct_self = #llvm.di_composite_type> +#di_struct_self = #llvm.di_composite_type, isRecSelf = false> #di_ptr_inner = #llvm.di_derived_type #di_subroutine_inner = #llvm.di_subroutine_type #di_subprogram_inner = #llvm.di_subprogram< @@ -502,7 +502,7 @@ llvm.func @class_method() { // Ensures composite types with a recursive scope work. -#di_composite_type_self = #llvm.di_composite_type> +#di_composite_type_self = #llvm.di_composite_type, isRecSelf = false> #di_file = #llvm.di_file<"test.mlir" in "/"> #di_subroutine_type = #llvm.di_subroutine_type #di_subprogram = #llvm.di_subprogram @@ -525,7 +525,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> +#di_composite_type_self = #llvm.di_composite_type, isRecSelf = false> #di_subroutine_type_inner = #llvm.di_subroutine_type #di_subprogram_inner = #llvm.di_subprogram From d22b24dc785b3d70ee08d3f61a284a968cb5f8da Mon Sep 17 00:00:00 2001 From: Tobias Gysi Date: Fri, 30 Aug 2024 19:51:56 +0000 Subject: [PATCH 3/3] Address more comments. --- mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp | 4 ++-- mlir/test/Target/LLVMIR/llvmir-debug.mlir | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp index 4fb2590ce11a7..491dcc7f01e73 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp @@ -203,7 +203,7 @@ void printExpressionArg(AsmPrinter &printer, uint64_t opcode, DIRecursiveTypeAttrInterface DICompositeTypeAttr::withRecId(DistinctAttr recId) { return DICompositeTypeAttr::get( - getContext(), recId, /*isRecSelf=*/false, getTag(), getName(), getFile(), + getContext(), recId, getIsRecSelf(), getTag(), getName(), getFile(), getLine(), getScope(), getBaseType(), getFlags(), getSizeInBits(), getAlignInBits(), getElements(), getDataLocation(), getRank(), getAllocated(), getAssociated()); @@ -222,7 +222,7 @@ DICompositeTypeAttr::getRecSelf(DistinctAttr recId) { DIRecursiveTypeAttrInterface DISubprogramAttr::withRecId(DistinctAttr recId) { return DISubprogramAttr::get( - getContext(), recId, /*isRecSelf=*/false, getId(), getCompileUnit(), + getContext(), recId, getIsRecSelf(), getId(), getCompileUnit(), getScope(), getName(), getLinkageName(), getFile(), getLine(), getScopeLine(), getSubprogramFlags(), getType(), getRetainedNodes()); } diff --git a/mlir/test/Target/LLVMIR/llvmir-debug.mlir b/mlir/test/Target/LLVMIR/llvmir-debug.mlir index 5eec0afa020fa..01194df504774 100644 --- a/mlir/test/Target/LLVMIR/llvmir-debug.mlir +++ b/mlir/test/Target/LLVMIR/llvmir-debug.mlir @@ -448,7 +448,7 @@ llvm.func @func_debug_directives() { #di_compile_unit = #llvm.di_compile_unit, sourceLanguage = DW_LANG_C, file = #di_file, isOptimized = false, emissionKind = None> // Recursive type itself. -#di_struct_self = #llvm.di_composite_type, isRecSelf = false> +#di_struct_self = #llvm.di_composite_type, isRecSelf = true> #di_ptr_inner = #llvm.di_derived_type #di_subroutine_inner = #llvm.di_subroutine_type #di_subprogram_inner = #llvm.di_subprogram< @@ -502,7 +502,7 @@ llvm.func @class_method() { // Ensures composite types with a recursive scope work. -#di_composite_type_self = #llvm.di_composite_type, isRecSelf = false> +#di_composite_type_self = #llvm.di_composite_type, isRecSelf = true> #di_file = #llvm.di_file<"test.mlir" in "/"> #di_subroutine_type = #llvm.di_subroutine_type #di_subprogram = #llvm.di_subprogram @@ -525,7 +525,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, isRecSelf = false> +#di_composite_type_self = #llvm.di_composite_type, isRecSelf = true> #di_subroutine_type_inner = #llvm.di_subroutine_type #di_subprogram_inner = #llvm.di_subprogram