[mlir][llvm] Rename void debug type to null

[Dinistro]

Summary

This commit renames the "di_void_result_type" to "di_null_type" as LLVM
does use null not exclusively for void types. An added test demonstrates
this for variadic function declarations, whose DISubroutine indicates the
start of variadic types with null.

[gysit]

Thanks for the fix!

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

267–268

nit: maybe align with "DINullType" above.

mlir/lib/Target/LLVMIR/DebugImporter.cpp

153–154

nit: Let's maybe mention the variadic types.

"A nullptr entry may appear at the beginning or the end of the subroutine types list modeling either a void result type or the type of a variadic argument."

[Dinistro]

address review comments

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

def LLVM_DILanguageParameter : LLVM_DIParameter<
   "language", /*default=*/"", "Language"
 >;
 
 def LLVM_DITagParameter : LLVM_DIParameter<
   "tag", /*default=*/"", "Tag"
 >;
 
 //===----------------------------------------------------------------------===//
-// DIVoidResultTypeAttr
+// DINullTypeAttr
 //===----------------------------------------------------------------------===//
 
-def LLVM_DIVoidResultTypeAttr : LLVM_Attr<"DIVoidResultType", "di_void_result_type",
-                                          /*traits=*/[], "DITypeAttr"> {
+def LLVM_DINullTypeAttr : LLVM_Attr<"DINullType", "di_null_type",
   let parameters = (ins);
 }
 
 //===----------------------------------------------------------------------===//
 // DIBasicTypeAttr
 //===----------------------------------------------------------------------===//
 
 def LLVM_DIBasicTypeAttr : LLVM_Attr<"DIBasicType", "di_basic_type",

 
 //===----------------------------------------------------------------------===//
 // DISubprogramAttr
 //===----------------------------------------------------------------------===//
 
 def LLVM_DISubprogramAttr : LLVM_Attr<"DISubprogram", "di_subprogram",
                                       /*traits=*/[], "DIScopeAttr"> {
   let parameters = (ins
-    "DICompileUnitAttr":$compileUnit,
+    OptionalParameter<"DICompileUnitAttr">:$compileUnit,
     "DIScopeAttr":$scope,
     "StringAttr":$name,
     OptionalParameter<"StringAttr">:$linkageName,
     "DIFileAttr":$file,
     OptionalParameter<"unsigned">:$line,
     OptionalParameter<"unsigned">:$scopeLine,
     "DISubprogramFlags":$subprogramFlags,
     OptionalParameter<"DISubroutineTypeAttr">:$type
let parameters = (ins
     OptionalArrayRefParameter<"DITypeAttr">:$types
   );
   let builders = [
     TypeBuilder<(ins "ArrayRef<DITypeAttr>":$types), [{
       return $_get($_ctxt, /*callingConvention=*/0, types);
     }]>
   ];
   let assemblyFormat = "`<` struct(params) `>`";
-  let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // MemoryEffectsAttr
 //===----------------------------------------------------------------------===//
 
 def LLVM_MemoryEffectsAttr : LLVM_Attr<"MemoryEffects", "memory_effects"> {
   let parameters = (ins

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

#include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // DINodeAttr
 //===----------------------------------------------------------------------===//
 
 bool DINodeAttr::classof(Attribute attr) {
-  return llvm::isa<DIVoidResultTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
+  return llvm::isa<DINullTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
                    DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
                    DILexicalBlockAttr, DILexicalBlockFileAttr,
                    DILocalVariableAttr, DISubprogramAttr, DISubrangeAttr,
                    DISubroutineTypeAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // DIScopeAttr
bool DILocalScopeAttr::classof(Attribute attr) {
   return llvm::isa<DILexicalBlockAttr, DISubprogramAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // DITypeAttr
 //===----------------------------------------------------------------------===//
 
 bool DITypeAttr::classof(Attribute attr) {
-  return llvm::isa<DIVoidResultTypeAttr, DIBasicTypeAttr, DICompositeTypeAttr,
+  return llvm::isa<DINullTypeAttr, DIBasicTypeAttr, DICompositeTypeAttr,
                    DIDerivedTypeAttr, DISubroutineTypeAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
-// DISubroutineTypeAttr
-//===----------------------------------------------------------------------===//
-
-LogicalResult
-DISubroutineTypeAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                             unsigned int callingConventions,
-                             ArrayRef<DITypeAttr> types) {
-  ArrayRef<DITypeAttr> argumentTypes =
-      types.empty() ? types : types.drop_front();
-  if (llvm::any_of(argumentTypes, [](DITypeAttr type) {
-        return type.isa<DIVoidResultTypeAttr>();
-      }))
-    return emitError() << "expected subroutine to have non-void argument types";
-  return success();
-}
-
-//===----------------------------------------------------------------------===//
 // MemoryEffectsAttr
 //===----------------------------------------------------------------------===//
 
 MemoryEffectsAttr MemoryEffectsAttr::get(MLIRContext *context,
                                          ArrayRef<ModRefInfo> memInfoArgs) {
   if (memInfoArgs.empty())
     return MemoryEffectsAttr::get(context, ModRefInfo::ModRef,
                                   ModRefInfo::ModRef, ModRefInfo::ModRef);

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<DIVoidResultTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
+        .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();

mlir/lib/Target/LLVMIR/DebugImporter.cpp

return DISubrangeAttr::get(context, getIntegerAttrOrNull(node->getCount()),
                              getIntegerAttrOrNull(node->getUpperBound()),
                              getIntegerAttrOrNull(node->getStride()));
 }
 
 DISubroutineTypeAttr
 DebugImporter::translateImpl(llvm::DISubroutineType *node) {
   SmallVector<DITypeAttr> types;
   for (llvm::DIType *type : node->getTypeArray()) {
     if (!type) {
-      // A nullptr entry at the beginning of the subroutine types list models a
-      // void result type. Translate the nullptr to an explicit
-      // DIVoidResultTypeAttr since the attribute list cannot contain a nullptr
-      // entry.
-      types.push_back(DIVoidResultTypeAttr::get(context));
+      // A nullptr entry may appear at the beginning or the end of the
+      // subroutine types list modeling either a void result type or the type of
+      // a variadic argument. Translate the nullptr to an explicit
+      // DINullTypeAttr since the attribute list cannot contain a nullptr entry.
+      types.push_back(DINullTypeAttr::get(context));
       continue;
     }
     types.push_back(translate(type));
   }
   // Return nullptr if any of the types is a cyclic dependency.
   if (llvm::is_contained(types, nullptr))
     return nullptr;
   return DISubroutineTypeAttr::get(context, node->getCC(), types);

mlir/lib/Target/LLVMIR/DebugTranslation.h

private:
   /// scope and inlinedAt parameters.
   const llvm::DILocation *translateLoc(Location loc, llvm::DILocalScope *scope,
                                        const llvm::DILocation *inlinedAt);
 
   /// Create an llvm debug file for the given file path.
   llvm::DIFile *translateFile(StringRef fileName);
 
   /// Translate the given attribute to the corresponding llvm debug metadata.
-  llvm::DIType *translateImpl(DIVoidResultTypeAttr attr);
+  llvm::DIType *translateImpl(DINullTypeAttr attr);
   llvm::DIBasicType *translateImpl(DIBasicTypeAttr attr);
   llvm::DICompileUnit *translateImpl(DICompileUnitAttr attr);
   llvm::DICompositeType *translateImpl(DICompositeTypeAttr attr);
   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);

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

if (!spLoc)
     return;
   llvmFunc.setSubprogram(translate(spLoc.getMetadata()));
 }
 
 //===----------------------------------------------------------------------===//
 // Attributes
 //===----------------------------------------------------------------------===//
 
-llvm::DIType *DebugTranslation::translateImpl(DIVoidResultTypeAttr attr) {
-  // A DIVoidResultTypeAttr at the beginning of the subroutine types list models
-  // a void result type. Translate the explicit DIVoidResultTypeAttr to a
-  // nullptr since LLVM IR metadata does not have an explicit void result type
+llvm::DIType *DebugTranslation::translateImpl(DINullTypeAttr attr) {
+  // A DINullTypeAttr at the beginning of the subroutine types list models
+  // a void result type. If it is at the end, it models a variadic function.
+  // Translate the explicit DINullTypeAttr to a nullptr since LLVM IR metadata
+  // does not have an explicit void result type nor a variadic type
   // representation.
   return nullptr;
 }
 
 llvm::DIBasicType *DebugTranslation::translateImpl(DIBasicTypeAttr attr) {
   return llvm::DIBasicType::get(
       llvmCtx, attr.getTag(), attr.getName(), attr.getSizeInBits(),
       /*AlignInBits=*/0, attr.getEncoding(), llvm::DINode::FlagZero);
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<DIVoidResultTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
+          .Case<DINullTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
                 DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
                 DILexicalBlockAttr, DILexicalBlockFileAttr, DILocalVariableAttr,
                 DISubprogramAttr, DISubrangeAttr, DISubroutineTypeAttr>(
               [&](auto attr) { return translateImpl(attr); });
   attrToNode.insert({attr, node});
   return node;
 }
 

mlir/test/Dialect/LLVMIR/debuginfo.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 // CHECK-DAG: #[[FILE:.*]] = #llvm.di_file<"debuginfo.mlir" in "/test/">
 #file = #llvm.di_file<"debuginfo.mlir" in "/test/">
 
 // CHECK-DAG: #[[CU:.*]] = #llvm.di_compile_unit<sourceLanguage = DW_LANG_C, file = #[[FILE]], producer = "MLIR", isOptimized = true, emissionKind = Full>
 #cu = #llvm.di_compile_unit<
   sourceLanguage = DW_LANG_C, file = #file, producer = "MLIR",
   isOptimized = true, emissionKind = Full
 >
 
-// CHECK-DAG: #[[VOID:.*]] = #llvm.di_void_result_type
-#void = #llvm.di_void_result_type
+// CHECK-DAG: #[[NULL:.*]] = #llvm.di_null_type
+#null = #llvm.di_null_type
 
 // CHECK-DAG: #[[INT0:.*]] = #llvm.di_basic_type<tag = DW_TAG_base_type, name = "int0">
 #int0 = #llvm.di_basic_type<
   // Omit the optional sizeInBits and encoding parameters.
   tag = DW_TAG_base_type, name = "int0"
 >
 
 // CHECK-DAG: #[[INT1:.*]] = #llvm.di_basic_type<tag = DW_TAG_base_type, name = "int1", sizeInBits = 32, encoding = DW_ATE_signed>

 >
 
 // CHECK-DAG: #[[COMP2:.*]] = #llvm.di_composite_type<tag = DW_TAG_class_type, name = "class_name", file = #[[FILE]], scope = #[[FILE]], flags = "TypePassByReference|NonTrivial">
 #comp2 = #llvm.di_composite_type<
   tag = DW_TAG_class_type, name = "class_name", file = #file, scope = #file,
   flags = "TypePassByReference|NonTrivial"
 >
 
-// CHECK-DAG: #[[SPTYPE0:.*]] = #llvm.di_subroutine_type<callingConvention = DW_CC_normal, types = #[[VOID]], #[[INT0]], #[[PTR0]], #[[PTR1]], #[[COMP0:.*]], #[[COMP1:.*]], #[[COMP2:.*]]>
+// 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 = #void, #int0, #ptr0, #ptr1, #comp0, #comp1, #comp2
+  callingConvention = DW_CC_normal, types = #null, #int0, #ptr0, #ptr1, #comp0, #comp1, #comp2
 >
 
 // CHECK-DAG: #[[SPTYPE1:.*]] = #llvm.di_subroutine_type<types = #[[INT1]], #[[INT1]]>
 #spType1 = #llvm.di_subroutine_type<
   // Omit the optional callingConvention parameter.
   types = #int1, #int1
 >
 

mlir/test/Dialect/LLVMIR/invalid.mlir

 
 func.func @extract_scalable_from_fixed_length_vector(%arg0 : vector<16xf32>) {
   // expected-error@+1 {{op failed to verify that it is not extracting scalable from fixed-length vectors.}}
   %0 = llvm.intr.vector.extract %arg0[0] : vector<[8]xf32> from vector<16xf32>
 }
 
 // -----
 
-#void = #llvm.di_void_result_type
-// expected-error@below {{expected subroutine to have non-void argument types}}
-#void_argument_type = #llvm.di_subroutine_type<types = #void, #void>
-
-// -----
-
 func.func @invalid_bitcast_ptr_to_i64(%arg : !llvm.ptr) {
   // expected-error@+1 {{can only cast pointers from and to pointers}}
   %1 = llvm.bitcast %arg : !llvm.ptr to i64
 }
 
 // -----
 
 func.func @invalid_bitcast_i64_to_ptr() {

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

 !3 = distinct !DISubprogram(name: "lexical_block_file", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
 !4 = !DILexicalBlockFile(scope: !3, discriminator: 0)
 !5 = !DILexicalBlockFile(scope: !3, file: !2, discriminator: 0)
 !6 = !DILocation(line: 1, column: 2, scope: !4)
 !7 = !DILocation(line: 2, column: 2, scope: !5)
 
 ; // -----
 
-; CHECK-DAG: #[[VOID:.+]] = #llvm.di_void_result_type
+; CHECK-DAG: #[[NULL:.+]] = #llvm.di_null_type
 ; CHECK-DAG: #[[INT1:.+]] = #llvm.di_basic_type<tag = DW_TAG_base_type, name = "int1">
 ; CHECK-DAG: #[[INT2:.+]] = #llvm.di_basic_type<tag = DW_TAG_base_type, name = "int2", sizeInBits = 32, encoding = DW_ATE_signed>
-; CHECK-DAG: #llvm.di_subroutine_type<types = #[[VOID]], #[[INT1]], #[[INT2]]>
+; CHECK-DAG: #llvm.di_subroutine_type<types = #[[NULL]], #[[INT1]], #[[INT2]]>
 
 define void @basic_type() !dbg !3 {
   ret void
 }
 
 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}

 !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: "class_field", file: !2, type: !5);
 !8 = distinct !DISubprogram(name: "class_field", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
 !9 = !DILocation(line: 1, column: 2, scope: !8)
+
+; // -----
+
+; CHECK-DAG: #[[NULL:.+]] = #llvm.di_null_type
+; CHECK-DAG: #llvm.di_subroutine_type<types = #[[NULL]], #[[NULL]]>
+
+declare !dbg !3 void @variadic_func()
+
+!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: "/")
+!3 = !DISubprogram(name: "variadic_func", scope: !2, file: !2, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, type: !4)
+!4 = !DISubroutineType(types: !5)
+!5 = !{null, null}

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

#composite = #llvm.di_composite_type<
   line = 42, sizeInBits = 64, alignInBits = 32,
   elements = #llvm.di_subrange<count = 4>
 >
 #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>
 >
-#void = #llvm.di_void_result_type
-#spType0 = #llvm.di_subroutine_type<callingConvention = DW_CC_normal, types = #void, #si64, #ptr, #named, #composite, #vector>
+#null = #llvm.di_null_type
+#spType0 = #llvm.di_subroutine_type<callingConvention = DW_CC_normal, types = #null, #si64, #ptr, #named, #composite, #vector>
 #sp0 = #llvm.di_subprogram<
   compileUnit = #cu, scope = #file, 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<