[DebugInfo] Emit DW_TAG_namelist and DW_TAG_namelist_item for fortran namelist variable

[bhuvanendrakumarn]

Summary

This patch emits DW_TAG_namelist and DW_TAG_namelist_item for fortran namelist variables. Namelist in fortran is basically group of variables. Already Metadata is created for each of the namelist items or variables, we just need to create MDList of these items and use the DICompositeType (with TAG: DW_TAG_namelist). Gfortran supports this fortran feature already. Flang is enhanced to support this feature and GDB also enhanced to support this. Both flang and GDB changes will up streamed soon.

Sample fortran program, IR, dwarf info are shared below.

Sample program :

program main

integer :: a, b
namelist /nml/ a, b
 
a = 10
b = 20
Write(*,nml)

end program main

LLVM IR:

!20 = !DILocalVariable(scope: !15, name: "a", file: !3, line: 6, type: !19)
. . .
!22 = !DILocalVariable(scope: !15, name: "b", file: !3, line: 7, type: !19)
. . .
!24 = !{ !20, !22 }
!25 = !DICompositeType(tag: DW_TAG_namelist, file: !3, scope: !15, name: "nml", elements: !24)

dwarfdump :

. . .
0x000000b4: DW_TAG_variable [10]

DW_AT_name [DW_FORM_string]   ("a")
DW_AT_decl_file [DW_FORM_data1]       ("/dir/namelist.f90")
DW_AT_decl_line [DW_FORM_data1]       (20)
DW_AT_type [DW_FORM_ref4]     (cu + 0x006d => {0x0000006d} "integer(kind=4)")
DW_AT_declaration [DW_FORM_flag_present]      (true)
DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg -20)

0x000000c0: DW_TAG_variable [10]

DW_AT_name [DW_FORM_string]   ("b")
DW_AT_decl_file [DW_FORM_data1]       ("/dir/namelist.f90")
DW_AT_decl_line [DW_FORM_data1]       (20)
DW_AT_type [DW_FORM_ref4]     (cu + 0x006d => {0x0000006d} "integer(kind=4)")
DW_AT_declaration [DW_FORM_flag_present]      (true)
DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg -24)

. . .
0x000000dd: DW_TAG_namelist [12] *

DW_AT_name [DW_FORM_string]   ("nml")

0x000000e2: DW_TAG_namelist_item [9]

DW_AT_namelist_item [DW_FORM_ref4]  (cu + 0x00b4 => {0x000000b4})

0x000000e7: DW_TAG_namelist_item [9]

DW_AT_namelist_item [DW_FORM_ref4]  (cu + 0x00c0 => {0x000000c0})

0x000000ec: NULL

[bhuvanendrakumarn]

updated the test cases

[aprantl]

Looks reasonable.

[quinnp]

Hi, this patch is breaking some of our PowerPC bots. For example: clang-ppc64le-linux-lnt.

[nemanjai]

In D108553#2972921, @quinnp wrote:

Hi, this patch is breaking some of our PowerPC bots. For example: clang-ppc64le-linux-lnt.

@quinnp Please revert the patch since the author has neglected to respond to your ping or the build bot notifications. We need to get the bots back to green.

@bhuvanendrakumarn It would appear that the failing test case should have -O0 to prevent variable b from being optimized out. However, since I am not sure that is the desired fix, we'll revert the patch and you can feel free to fix it that way or whatever way is more appropriate.

[bhuvanendrakumarn]

@nemanjai @quinnp will update the tests accordingly and resubmit

[bhuvanendrakumarn]

@nemanjai @quinnp

could you please review the testcase (namelist1.ll) once, i have added -O0 now.

[quinnp]

Hey @bhuvanendrakumarn, thanks so much for providing the fix! I tested the patch, looks good to me. When you recommit the patch keep an eye on the buildbots but I don't think there will be any issues.

[bhuvanendrakumarn]

In D108553#2977729, @quinnp wrote:

Hey @bhuvanendrakumarn, thanks so much for providing the fix! I tested the patch, looks good to me. When you recommit the patch keep an eye on the buildbots but I don't think there will be any issues.

@nemanjai @quinnp

thanks for the confirmation, i have recommitted the same fix now, with the required test case changes

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

case dwarf::DW_TAG_array_type:
     constructArrayTypeDIE(Buffer, CTy);
     break;
   case dwarf::DW_TAG_enumeration_type:
     constructEnumTypeDIE(Buffer, CTy);
     break;
   case dwarf::DW_TAG_variant_part:
   case dwarf::DW_TAG_structure_type:
   case dwarf::DW_TAG_union_type:
-  case dwarf::DW_TAG_class_type: {
+  case dwarf::DW_TAG_class_type:
+  case dwarf::DW_TAG_namelist: {
     // Emit the discriminator for a variant part.
     DIDerivedType *Discriminator = nullptr;
     if (Tag == dwarf::DW_TAG_variant_part) {
       Discriminator = CTy->getDiscriminator();
       if (Discriminator) {
         // DWARF says:
         //    If the variant part has a discriminant, the discriminant is
         //    represented by a separate debugging information entry which is
for (const auto *Element : Elements) {
         if (unsigned PropertyAttributes = Property->getAttributes())
           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
                   PropertyAttributes);
       } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
         if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
           DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
           constructTypeDIE(VariantPart, Composite);
         }
+      } else if (Tag == dwarf::DW_TAG_namelist) {
+        auto *Var = dyn_cast<DINode>(Element);
+        auto *VarDIE = getDIE(Var);
+        if (VarDIE) {
+          DIE &ItemDie = createAndAddDIE(dwarf::DW_TAG_namelist_item, Buffer);
+          addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
+        }
       }
     }
 
     if (CTy->isAppleBlockExtension())
       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 
     if (CTy->getExportSymbols())
       addFlag(Buffer, dwarf::DW_AT_export_symbols);

llvm/lib/IR/Verifier.cpp

void Verifier::visitDICompositeType(const DICompositeType &N) {
   // Common scope checks.
   visitDIScope(N);
 
   AssertDI(N.getTag() == dwarf::DW_TAG_array_type ||
                N.getTag() == dwarf::DW_TAG_structure_type ||
                N.getTag() == dwarf::DW_TAG_union_type ||
                N.getTag() == dwarf::DW_TAG_enumeration_type ||
                N.getTag() == dwarf::DW_TAG_class_type ||
-               N.getTag() == dwarf::DW_TAG_variant_part,
+               N.getTag() == dwarf::DW_TAG_variant_part ||
+               N.getTag() == dwarf::DW_TAG_namelist,
            "invalid tag", &N);
 
   AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
   AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,
            N.getRawBaseType());
 
   AssertDI(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
            "invalid composite elements", &N, N.getRawElements());

llvm/test/DebugInfo/X86/namelist1.ll

+; Namelist is a fortran feature, this test checks whether DW_TAG_namelist and
+; DW_TAG_namelist_item attributes are emitted correctly.
+;
+; RUN: llc %s -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump %t.o | FileCheck %s
+;
+; CHECK: [[ITEM1:0x.+]]:       DW_TAG_variable
+; CHECK:                          DW_AT_name  ("a")
+; CHECK: [[ITEM2:0x.+]]:       DW_TAG_variable
+; CHECK:                          DW_AT_name  ("b")
+; CHECK: DW_TAG_namelist
+; CHECK:    DW_AT_name  ("nml")
+; CHECK: DW_TAG_namelist_item
+; CHECK:    DW_AT_namelist_item ([[ITEM1]])
+; CHECK: DW_TAG_namelist_item
+; CHECK:    DW_AT_namelist_item ([[ITEM2]])
+;
+; generated from
+;
+; program main
+;
+;  integer :: a=1, b
+;  namelist /nml/ a, b
+;
+;  a = 10
+;  b = 20
+;  Write(*,nml)
+;
+; end program main
+
+source_filename = "namelist.ll"
+
+define void @MAIN_() !dbg !2 {
+L.entry:
+  %b_350 = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i32* %b_350, metadata !12, metadata !DIExpression()), !dbg !13
+  call void @llvm.dbg.value(metadata i32 1, metadata !14, metadata !DIExpression()), !dbg !13
+  ret void, !dbg !17
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.module.flags = !{!10, !11}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression(DW_OP_plus_uconst, 120))
+!1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 3, type: !9, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 1, type: !7, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!3 = !DIFile(filename: "namelist.f90", directory: "/dir")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g namelist.f90 -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5, nameTableKind: None)
+!5 = !{}
+!6 = !{!0}
+!7 = !DISubroutineType(cc: DW_CC_program, types: !8)
+!8 = !{null}
+!9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !{i32 2, !"Dwarf Version", i32 4}
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = !DILocalVariable(name: "b", scope: !2, file: !3, line: 3, type: !9)
+!13 = !DILocation(line: 0, scope: !2)
+!14 = distinct !DILocalVariable(scope: !2, file: !3, line: 2, type: !15, flags: DIFlagArtificial)
+!15 = !DICompositeType(tag: DW_TAG_namelist, name: "nml", scope: !2, file: !3, elements: !16)
+!16 = !{!1, !12}
+!17 = !DILocation(line: 10, column: 1, scope: !2)

llvm/test/DebugInfo/X86/namelist2.ll

+; Namelist is a fortran feature, this test checks whether DW_TAG_namelist and
+; DW_TAG_namelist_item attributes are emitted correctly, when declared inside
+; a module.
+;
+; RUN: llc %s -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump %t.o | FileCheck %s
+;
+; CHECK: [[ITEM1:0x.+]]:       DW_TAG_variable
+; CHECK:                          DW_AT_name  ("aa")
+; CHECK: [[ITEM2:0x.+]]:       DW_TAG_variable
+; CHECK:                          DW_AT_name  ("bb")
+; CHECK: DW_TAG_namelist
+; CHECK:    DW_AT_name  ("nml")
+; CHECK: DW_TAG_namelist_item
+; CHECK:    DW_AT_namelist_item ([[ITEM1]])
+; CHECK: DW_TAG_namelist_item
+; CHECK:    DW_AT_namelist_item ([[ITEM2]])
+;
+; generated from
+;
+; module mm
+;    integer :: aa=10, bb=20
+;    namelist /nml/ aa, bb
+; end module mm
+;
+; subroutine test()
+;    use mm
+;    write(*,nml)
+; end subroutine test
+;
+; Program namelist
+;       Call test()
+; End Program
+
+source_filename = "namelist2.ll"
+
+!llvm.module.flags = !{!19, !20}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "aa", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "mm", file: !3, line: 1)
+!3 = !DIFile(filename: "namelist2.f90", directory: "/dir")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g namelist2.f90 -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !14, nameTableKind: None)
+!5 = !{}
+!6 = !{!0, !7, !10}
+!7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
+!8 = distinct !DIGlobalVariable(name: "bb", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
+!9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "nml", scope: !2, file: !3, line: 2, type: !12, isLocal: false, isDefinition: true)
+!12 = !DICompositeType(tag: DW_TAG_namelist, name: "nml", file: !3, elements: !13)
+!13 = !{!1, !8}
+!14 = !{!15}
+!15 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !16, entity: !2, file: !3, line: 6)
+!16 = distinct !DISubprogram(name: "test", scope: !4, file: !3, line: 6, type: !17, scopeLine: 6, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition, unit: !4)
+!17 = !DISubroutineType(types: !18)
+!18 = !{null}
+!19 = !{i32 2, !"Dwarf Version", i32 4}
+!20 = !{i32 2, !"Debug Info Version", i32 3}
+!21 = distinct !DISubprogram(name: "namelist", scope: !4, file: !3, line: 11, type: !22, scopeLine: 11, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!22 = !DISubroutineType(cc: DW_CC_program, types: !18)