[mlir][LLVM] Export DICompositeType as distinct MD when necessary

[Dinistro]

Summary

This commit ensures that DICompositeTypes are exported as distinct
metadata nodes for structures, classes, unions, and enumerations.
Not emitting these as distinct metadata can potentially cause linking
issues involving debug sections.

[gysit]

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

122

nit: Returns

125

getDIType is a bit confusing since at least in MLIR DISuprogram is not a DITypeAttr. Should we call it:

template <typename NodeT, typename... Args>
static NodeT *getDistinctOrUnique(...)

or similar?

[Dinistro]

address reviewer comments

[Dinistro]

Rename templated function to reflect actual purpose better.

[gysit]

LGTM!

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

llvm::DICompileUnit *DebugTranslation::translateImpl(DICompileUnitAttr attr) {
   llvm::DIBuilder builder(llvmModule);
   return builder.createCompileUnit(
       attr.getSourceLanguage(), translate(attr.getFile()),
       attr.getProducer() ? attr.getProducer().getValue() : "",
       attr.getIsOptimized(),
       /*Flags=*/"", /*RV=*/0);
 }
 
+/// Returns a new `DINodeT` that is either distinct or not, depending on
+/// `isDistinct`.
+template <class DINodeT, class... Ts>
+static DINodeT *getDistinctOrUnique(bool isDistinct, Ts &&...args) {
+  if (isDistinct)
+    return DINodeT::getDistinct(std::forward<Ts>(args)...);
+  return DINodeT::get(std::forward<Ts>(args)...);
+}
+
 llvm::DICompositeType *
 DebugTranslation::translateImpl(DICompositeTypeAttr attr) {
   SmallVector<llvm::Metadata *> elements;
   for (auto member : attr.getElements())
     elements.push_back(translate(member));
-  return llvm::DICompositeType::get(
-      llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
+
+  // TODO: Use distinct attributes to model this, once they have landed.
+  // Depending on the tag, composite types must be distinct.
+  bool isDistinct = false;
+  switch (attr.getTag()) {
+  case llvm::dwarf::DW_TAG_class_type:
+  case llvm::dwarf::DW_TAG_enumeration_type:
+  case llvm::dwarf::DW_TAG_structure_type:
+  case llvm::dwarf::DW_TAG_union_type:
+    isDistinct = true;
+  }
+
+  return getDistinctOrUnique<llvm::DICompositeType>(
+      isDistinct, llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
       translate(attr.getFile()), attr.getLine(), translate(attr.getScope()),
       translate(attr.getBaseType()), attr.getSizeInBits(),
       attr.getAlignInBits(),
       /*OffsetInBits=*/0,
       /*Flags=*/static_cast<llvm::DINode::DIFlags>(attr.getFlags()),
       llvm::MDNode::get(llvmCtx, elements),
       /*RuntimeLang=*/0, /*VTableHolder=*/nullptr);
 }
return llvm::DILocalVariable::get(
       /*Flags=*/llvm::DINode::FlagZero, attr.getAlignInBits(),
       /*Annotations=*/nullptr);
 }
 
 llvm::DIScope *DebugTranslation::translateImpl(DIScopeAttr attr) {
   return cast<llvm::DIScope>(translate(DINodeAttr(attr)));
 }
 
-/// Return a new subprogram that is either distinct or not, depending on
-/// `isDistinct`.
-template <class... Ts>
-static llvm::DISubprogram *getSubprogram(bool isDistinct, Ts &&...args) {
-  if (isDistinct)
-    return llvm::DISubprogram::getDistinct(std::forward<Ts>(args)...);
-  return llvm::DISubprogram::get(std::forward<Ts>(args)...);
-}
-
 llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) {
   bool isDefinition = static_cast<bool>(attr.getSubprogramFlags() &
                                         LLVM::DISubprogramFlags::Definition);
-  return getSubprogram(
+  return getDistinctOrUnique<llvm::DISubprogram>(
       isDefinition, llvmCtx, translate(attr.getScope()),
       getMDStringOrNull(attr.getName()),
       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()));

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

 // 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_TYPE]] = distinct !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:.*]]}
 // CHECK: ![[COMPOSITE_ELEMENT]] = !DISubrange(count: 4)
 // CHECK: ![[VECTOR_TYPE]] = !DICompositeType(tag: DW_TAG_array_type, name: "array", file: ![[CU_FILE_LOC]], baseType: ![[ARG_TYPE]], flags: DIFlagVector, elements: ![[VECTOR_ELEMENTS:.*]])
 // CHECK: ![[VECTOR_ELEMENTS]] = !{![[VECTOR_ELEMENT:.*]]}
 // CHECK: ![[VECTOR_ELEMENT]] = !DISubrange(lowerBound: 0, upperBound: 4, stride: 1)
 
 // CHECK: ![[VAR_LOC]] = !DILocalVariable(name: "arg", arg: 1, scope: ![[VAR_SCOPE:.*]], file: ![[CU_FILE_LOC]], line: 6, type: ![[ARG_TYPE]], align: 32)
 // CHECK: ![[VAR_SCOPE]] = distinct !DILexicalBlockFile(scope: ![[FUNC_LOC]], file: ![[CU_FILE_LOC]], discriminator: 0)