[mlir][llvm] Add DINamespace attribute

[Dinistro]

Summary

This commit introduces the DINamespaceAttr to model LLVM's DINamespace metadata.

[gysit]

mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp

49

nit: let's try to order this alphabetical? I think null type and namespace are now not in alphabetical order.

66

nit: same here.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

2804

nit: same here.

mlir/lib/Target/LLVMIR/DebugImporter.cpp

110–112

Can this happen after adding the namespace metadata?

120

Since the scope of the namespace is optional I would probably just return a namespace with the scope set to null in this case to stop the error propagation.

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

244

nit: let's also reorder to make it alphabetical again.

[Dinistro]

Address review comments

[Dinistro]

mlir/lib/Target/LLVMIR/DebugImporter.cpp

110–112

This is not entirely clear. The downstream testing application with 60k lines of LLVM IR does not reach this case, so I'll revert this part.

[gysit]

Thanks, LGTM!

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td

), [{
                    scopeLine, subprogramFlags, type);
     }]>
   ];
 
   let assemblyFormat = "`<` struct(params) `>`";
 }
 
 //===----------------------------------------------------------------------===//
+// DINamespaceAttr
+//===----------------------------------------------------------------------===//
+
+def LLVM_DINamespaceAttr : LLVM_Attr<"DINamespace", "di_namespace",
+                                      /*traits=*/[], "DIScopeAttr"> {
+  let parameters = (ins
+    "StringAttr":$name,
+    OptionalParameter<"DIScopeAttr">:$scope,
+    "bool":$exportSymbols
+  );
+
+  let assemblyFormat = "`<` struct(params) `>`";
+}
+
+//===----------------------------------------------------------------------===//
 // DISubrangeAttr
 //===----------------------------------------------------------------------===//
 
 def LLVM_DISubrangeAttr : LLVM_Attr<"DISubrange", "di_subrange", /*traits=*/[],
                                     "DINodeAttr"> {
   let parameters = (ins
     OptionalParameter<"IntegerAttr">:$count,
     OptionalParameter<"IntegerAttr">:$lowerBound,

mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp

#include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // DINodeAttr
 //===----------------------------------------------------------------------===//
 
 bool DINodeAttr::classof(Attribute attr) {
-  return llvm::isa<DINullTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
-                   DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
-                   DILexicalBlockAttr, DILexicalBlockFileAttr,
-                   DILocalVariableAttr, DISubprogramAttr, DISubrangeAttr,
+  return llvm::isa<DIBasicTypeAttr, DICompileUnitAttr, DICompositeTypeAttr,
+                   DIDerivedTypeAttr, DIFileAttr, DILexicalBlockAttr,
+                   DILexicalBlockFileAttr, DILocalVariableAttr, DINamespaceAttr,
+                   DINullTypeAttr, DISubprogramAttr, DISubrangeAttr,
                    DISubroutineTypeAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // DIScopeAttr
 //===----------------------------------------------------------------------===//
 
 bool DIScopeAttr::classof(Attribute attr) {
   return llvm::isa<DICompileUnitAttr, DICompositeTypeAttr, DIFileAttr,
                    DILexicalBlockFileAttr, DILocalScopeAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // DILocalScopeAttr
 //===----------------------------------------------------------------------===//
 
 bool DILocalScopeAttr::classof(Attribute attr) {
-  return llvm::isa<DILexicalBlockAttr, DISubprogramAttr>(attr);
+  return llvm::isa<DILexicalBlockAttr, DINamespaceAttr, DISubprogramAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // DITypeAttr
 //===----------------------------------------------------------------------===//
 
 bool DITypeAttr::classof(Attribute attr) {
   return llvm::isa<DINullTypeAttr, DIBasicTypeAttr, DICompositeTypeAttr,

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 struct LLVMOpAsmDialectInterface : public OpAsmDialectInterface {
   using OpAsmDialectInterface::OpAsmDialectInterface;
 
   AliasResult getAlias(Attribute attr, raw_ostream &os) const override {
     return TypeSwitch<Attribute, AliasResult>(attr)
-        .Case<DINullTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
-              DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
-              DILexicalBlockAttr, DILexicalBlockFileAttr, DILocalVariableAttr,
-              DISubprogramAttr, DISubroutineTypeAttr, LoopAnnotationAttr,
-              LoopVectorizeAttr, LoopInterleaveAttr, LoopUnrollAttr,
-              LoopUnrollAndJamAttr, LoopLICMAttr, LoopDistributeAttr,
-              LoopPipelineAttr, LoopPeeledAttr, LoopUnswitchAttr>(
-            [&](auto attr) {
-              os << decltype(attr)::getMnemonic();
-              return AliasResult::OverridableAlias;
-            })
+        .Case<DIBasicTypeAttr, DICompileUnitAttr, DICompositeTypeAttr,
+              DIDerivedTypeAttr, DIFileAttr, DILexicalBlockAttr,
+              DILexicalBlockFileAttr, DILocalVariableAttr, DINamespaceAttr,
+              DINullTypeAttr, DISubprogramAttr, DISubroutineTypeAttr,
+              LoopAnnotationAttr, LoopVectorizeAttr, LoopInterleaveAttr,
+              LoopUnrollAttr, LoopUnrollAndJamAttr, LoopLICMAttr,
+              LoopDistributeAttr, LoopPipelineAttr, LoopPeeledAttr,
+              LoopUnswitchAttr>([&](auto attr) {
         .Default([](Attribute) { return AliasResult::NoAlias; });
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // DialectInlinerInterface
 //===----------------------------------------------------------------------===//

mlir/lib/Target/LLVMIR/DebugImporter.h

private:
   DICompositeTypeAttr translateImpl(llvm::DICompositeType *node);
   DIDerivedTypeAttr translateImpl(llvm::DIDerivedType *node);
   DIFileAttr translateImpl(llvm::DIFile *node);
   DILexicalBlockAttr translateImpl(llvm::DILexicalBlock *node);
   DILexicalBlockFileAttr translateImpl(llvm::DILexicalBlockFile *node);
   DILocalVariableAttr translateImpl(llvm::DILocalVariable *node);
   DIScopeAttr translateImpl(llvm::DIScope *node);
   DISubprogramAttr translateImpl(llvm::DISubprogram *node);
+  DINamespaceAttr translateImpl(llvm::DINamespace *node);
   DISubrangeAttr translateImpl(llvm::DISubrange *node);
   DISubroutineTypeAttr translateImpl(llvm::DISubroutineType *node);
   DITypeAttr translateImpl(llvm::DIType *node);
 
   /// A mapping between LLVM debug metadata and the corresponding attribute.
   DenseMap<llvm::DINode *, DINodeAttr> nodeToAttr;
 
   /// A stack that stores the metadata nodes that are being traversed. The stack

mlir/lib/Target/LLVMIR/DebugImporter.cpp

 }
 
 DILocalVariableAttr DebugImporter::translateImpl(llvm::DILocalVariable *node) {
   return DILocalVariableAttr::get(context, translate(node->getScope()),
                                   StringAttr::get(context, node->getName()),
                                   translate(node->getFile()), node->getLine(),
                                   node->getArg(), node->getAlignInBits(),
                                   translate(node->getType()));
 }
 
 DIScopeAttr DebugImporter::translateImpl(llvm::DIScope *node) {
   return cast<DIScopeAttr>(translate(static_cast<llvm::DINode *>(node)));
 }
 
+DINamespaceAttr DebugImporter::translateImpl(llvm::DINamespace *node) {
+  return DINamespaceAttr::get(
+      context, StringAttr::get(context, node->getName()),
+      translate(node->getScope()), node->getExportSymbols());
+}
+
 DISubprogramAttr DebugImporter::translateImpl(llvm::DISubprogram *node) {
   std::optional<DISubprogramFlags> subprogramFlags =
       symbolizeDISubprogramFlags(node->getSubprogram()->getSPFlags());
   // Return nullptr if the scope or type is a cyclic dependency.
   DIScopeAttr scope = translate(node->getScope());
   if (node->getScope() && !scope)
     return nullptr;
   DISubroutineTypeAttr type = translate(node->getType());
auto translateNode = [this](llvm::DINode *node) -> DINodeAttr {
     if (auto *casted = dyn_cast<llvm::DILexicalBlock>(node))
       return translateImpl(casted);
     if (auto *casted = dyn_cast<llvm::DILexicalBlockFile>(node))
       return translateImpl(casted);
     if (auto *casted = dyn_cast<llvm::DILocalVariable>(node))
       return translateImpl(casted);
     if (auto *casted = dyn_cast<llvm::DISubprogram>(node))
       return translateImpl(casted);
+    if (auto *casted = dyn_cast<llvm::DINamespace>(node))
+      return translateImpl(casted);
     if (auto *casted = dyn_cast<llvm::DISubrange>(node))
       return translateImpl(casted);
     if (auto *casted = dyn_cast<llvm::DISubroutineType>(node))
       return translateImpl(casted);
     return nullptr;
   };
   if (DINodeAttr attr = translateNode(node)) {
     nodeToAttr.insert({node, attr});

mlir/lib/Target/LLVMIR/DebugTranslation.h

private:
   llvm::DIDerivedType *translateImpl(DIDerivedTypeAttr attr);
   llvm::DIFile *translateImpl(DIFileAttr attr);
   llvm::DILexicalBlock *translateImpl(DILexicalBlockAttr attr);
   llvm::DILexicalBlockFile *translateImpl(DILexicalBlockFileAttr attr);
   llvm::DILocalScope *translateImpl(DILocalScopeAttr attr);
   llvm::DILocalVariable *translateImpl(DILocalVariableAttr attr);
   llvm::DIScope *translateImpl(DIScopeAttr attr);
   llvm::DISubprogram *translateImpl(DISubprogramAttr attr);
+  llvm::DINamespace *translateImpl(DINamespaceAttr attr);
   llvm::DISubrange *translateImpl(DISubrangeAttr attr);
   llvm::DISubroutineType *translateImpl(DISubroutineTypeAttr attr);
   llvm::DIType *translateImpl(DITypeAttr attr);
 
   /// A mapping between mlir location+scope and the corresponding llvm debug
   /// metadata.
   DenseMap<std::tuple<Location, llvm::DILocalScope *, const llvm::DILocation *>,
            const llvm::DILocation *>

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

return getSubprogram(
       getMDStringOrNull(attr.getLinkageName()), translate(attr.getFile()),
       attr.getLine(), translate(attr.getType()), attr.getScopeLine(),
       /*ContainingType=*/nullptr, /*VirtualIndex=*/0,
       /*ThisAdjustment=*/0, llvm::DINode::FlagZero,
       static_cast<llvm::DISubprogram::DISPFlags>(attr.getSubprogramFlags()),
       translate(attr.getCompileUnit()));
 }
 
+llvm::DINamespace *DebugTranslation::translateImpl(DINamespaceAttr attr) {
+  return llvm::DINamespace::get(llvmCtx, translate(attr.getScope()),
+                                attr.getName(), attr.getExportSymbols());
+}
+
 llvm::DISubrange *DebugTranslation::translateImpl(DISubrangeAttr attr) {
   auto getMetadataOrNull = [&](IntegerAttr attr) -> llvm::Metadata * {
     if (!attr)
       return nullptr;
     return llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
         llvm::Type::getInt64Ty(llvmCtx), attr.getInt()));
   };
   return llvm::DISubrange::get(llvmCtx, getMetadataOrNull(attr.getCount()),
llvm::DINode *DebugTranslation::translate(DINodeAttr attr) {
   if (!attr)
     return nullptr;
   // Check for a cached instance.
   if (llvm::DINode *node = attrToNode.lookup(attr))
     return node;
 
   llvm::DINode *node =
       TypeSwitch<DINodeAttr, llvm::DINode *>(attr)
-          .Case<DINullTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
-                DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
-                DILexicalBlockAttr, DILexicalBlockFileAttr, DILocalVariableAttr,
-                DISubprogramAttr, DISubrangeAttr, DISubroutineTypeAttr>(
+          .Case<DIBasicTypeAttr, DICompileUnitAttr, DICompositeTypeAttr,
+                DIDerivedTypeAttr, DIFileAttr, DILexicalBlockAttr,
+                DILexicalBlockFileAttr, DILocalVariableAttr, DINamespaceAttr,
+                DINullTypeAttr, DISubprogramAttr, DISubrangeAttr,
+                DISubroutineTypeAttr>(
               [&](auto attr) { return translateImpl(attr); });
   attrToNode.insert({attr, node});
   return node;
 }
 
 //===----------------------------------------------------------------------===//
 // Locations
 //===----------------------------------------------------------------------===//

mlir/test/Dialect/LLVMIR/debuginfo.mlir

 // CHECK-DAG: #[[COMP1:.*]] = #llvm.di_composite_type<tag = DW_TAG_array_type, name = "array1", file = #[[FILE]], scope = #[[FILE]], baseType = #[[INT0]], elements = #llvm.di_subrange<count = 4 : i64>>
 #comp1 = #llvm.di_composite_type<
   tag = DW_TAG_array_type, name = "array1", file = #file,
   scope = #file, baseType = #int0,
   // Specify the subrange count.
   elements = #llvm.di_subrange<count = 4>
 >
 
-// CHECK-DAG: #[[COMP2:.*]] = #llvm.di_composite_type<tag = DW_TAG_class_type, name = "class_name", file = #[[FILE]], scope = #[[FILE]], flags = "TypePassByReference|NonTrivial">
+// CHECK-DAG: #[[TOPLEVEL:.*]] = #llvm.di_namespace<name = "toplevel", exportSymbols = true>
+#toplevel_namespace = #llvm.di_namespace<
+  name = "toplevel", exportSymbols = true
+>
+
+// CHECK-DAG: #[[NESTED:.*]] = #llvm.di_namespace<name = "nested", scope = #[[TOPLEVEL]], exportSymbols = false>
+#nested_namespace = #llvm.di_namespace<
+  name = "nested", scope = #toplevel_namespace, exportSymbols = false
+>
+
+// CHECK-DAG: #[[COMP2:.*]] = #llvm.di_composite_type<tag = DW_TAG_class_type, name = "class_name", file = #[[FILE]], scope = #[[NESTED]], flags = "TypePassByReference|NonTrivial">
 #comp2 = #llvm.di_composite_type<
-  tag = DW_TAG_class_type, name = "class_name", file = #file, scope = #file,
+  tag = DW_TAG_class_type, name = "class_name", file = #file, scope = #nested_namespace,
   flags = "TypePassByReference|NonTrivial"
 >
 
 // CHECK-DAG: #[[SPTYPE0:.*]] = #llvm.di_subroutine_type<callingConvention = DW_CC_normal, types = #[[NULL]], #[[INT0]], #[[PTR0]], #[[PTR1]], #[[COMP0:.*]], #[[COMP1:.*]], #[[COMP2:.*]]>
 #spType0 = #llvm.di_subroutine_type<
   callingConvention = DW_CC_normal, types = #null, #int0, #ptr0, #ptr1, #comp0, #comp1, #comp2
 >
 

mlir/test/Target/LLVMIR/Import/debug-info.ll

 !2 = !DIFile(filename: "debug-info.ll", directory: "/")
 !3 = !DICompositeType(tag: DW_TAG_class_type, name: "class_field", file: !2, line: 42, flags: DIFlagTypePassByReference | DIFlagNonTrivial, elements: !4)
 !4 = !{!6}
 !5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !3, flags: DIFlagArtificial | DIFlagObjectPointer)
 !6 = !DIDerivedType(tag: DW_TAG_member, name: "call_field", file: !2, baseType: !5)
 !7 = !DILocalVariable(scope: !8, name: "var", file: !2, type: !5);
 !8 = distinct !DISubprogram(name: "dbg_use_before_def", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
 !9 = !DILocation(line: 1, column: 2, scope: !8)
+
+; // -----
+
+; CHECK-DAG: #[[NAMESPACE:.+]] = #llvm.di_namespace<name = "std", exportSymbols = false>
+; CHECK-DAG: #[[SUBPROGRAM:.+]] =  #llvm.di_subprogram<compileUnit = #{{.*}}, scope = #[[NAMESPACE]], name = "namespace"
+
+define void @namespace(ptr %arg) {
+  call void @llvm.dbg.value(metadata ptr %arg, metadata !7, metadata !DIExpression()), !dbg !9
+  ret void
+}
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!0}
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2)
+!2 = !DIFile(filename: "debug-info.ll", directory: "/")
+!7 = !DILocalVariable(scope: !8, name: "var")
+!8 = distinct !DISubprogram(name: "namespace", scope: !10, file: !2, unit: !1);
+!9 = !DILocation(line: 1, column: 2, scope: !8)
+!10 = !DINamespace(name: "std", scope: null)

mlir/test/Target/LLVMIR/llvmir-debug.mlir

 >
 #vector = #llvm.di_composite_type<
   tag = DW_TAG_array_type, name = "array", file = #file,
   baseType = #si64, flags = Vector,
   elements = #llvm.di_subrange<lowerBound = 0, upperBound = 4, stride = 1>
 >
 #null = #llvm.di_null_type
 #spType0 = #llvm.di_subroutine_type<callingConvention = DW_CC_normal, types = #null, #si64, #ptr, #named, #composite, #vector>
+#toplevel_namespace = #llvm.di_namespace<
+  name = "toplevel", exportSymbols = true
+>
+#nested_namespace = #llvm.di_namespace<
+  name = "nested", scope = #toplevel_namespace, exportSymbols = false
+>
 #sp0 = #llvm.di_subprogram<
-  compileUnit = #cu, scope = #file, name = "func_with_debug", linkageName = "func_with_debug",
+  compileUnit = #cu, scope = #nested_namespace, name = "func_with_debug", linkageName = "func_with_debug",
   file = #file, line = 3, scopeLine = 3, subprogramFlags = "Definition|Optimized", type = #spType0
 >
 #calleeType = #llvm.di_subroutine_type<
   // Omit the optional callingConvention parameter.
   types = #si64, #si64>
 #callee = #llvm.di_subprogram<
   // Omit the optional linkageName, line, and scopeLine parameters.
   compileUnit = #cu, scope = #composite, name = "callee",

 // CHECK: define void @empty_types() !dbg ![[EMPTY_TYPES_LOC:[0-9]+]]
 llvm.func @empty_types() {
   llvm.return
 } loc(fused<#sp1>["foo.mlir":2:1])
 
 // CHECK: ![[CU_LOC:.*]] = distinct !DICompileUnit(language: DW_LANG_C, file: ![[CU_FILE_LOC:.*]], producer: "MLIR", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
 // CHECK: ![[CU_FILE_LOC]] = !DIFile(filename: "foo.mlir", directory: "/test/")
 
-// CHECK: ![[FUNC_LOC]] = distinct !DISubprogram(name: "func_with_debug", linkageName: "func_with_debug", scope: ![[CU_FILE_LOC]], file: ![[CU_FILE_LOC]], line: 3, type: ![[FUNC_TYPE:.*]], scopeLine: 3, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: ![[CU_LOC]])
+// CHECK: ![[FUNC_LOC]] = distinct !DISubprogram(name: "func_with_debug", linkageName: "func_with_debug", scope: ![[NESTED_NAMESPACE:.*]], file: ![[CU_FILE_LOC]], line: 3, type: ![[FUNC_TYPE:.*]], scopeLine: 3, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: ![[CU_LOC]])
+// CHECK: ![[NESTED_NAMESPACE]] = !DINamespace(name: "nested", scope: ![[TOPLEVEL_NAMESPACE:.*]])
+// CHECK: ![[TOPLEVEL_NAMESPACE]] = !DINamespace(name: "toplevel", scope: null, exportSymbols: true)
 // CHECK: ![[FUNC_TYPE]] = !DISubroutineType(cc: DW_CC_normal, types: ![[FUNC_ARGS:.*]])
 // CHECK: ![[FUNC_ARGS]] = !{null, ![[ARG_TYPE:.*]], ![[PTR_TYPE:.*]], ![[NAMED_TYPE:.*]], ![[COMPOSITE_TYPE:.*]], ![[VECTOR_TYPE:.*]]}
 // CHECK: ![[ARG_TYPE]] = !DIBasicType(name: "si64")
 // CHECK: ![[PTR_TYPE]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: ![[BASE_TYPE:.*]], size: 64, align: 32, offset: 8)
 // CHECK: ![[BASE_TYPE]] = !DIBasicType(name: "si32", size: 32, encoding: DW_ATE_signed)
 // CHECK: ![[NAMED_TYPE]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "named", baseType: ![[BASE_TYPE:.*]])
 // CHECK: ![[COMPOSITE_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "composite", file: ![[CU_FILE_LOC]], line: 42, size: 64, align: 32, elements: ![[COMPOSITE_ELEMENTS:.*]])
 // CHECK: ![[COMPOSITE_ELEMENTS]] = !{![[COMPOSITE_ELEMENT:.*]]}