[XCOFF][DWARF] XCOFF64 should be able to select the dwarf format in intergrated-as mode.

[Esme]

Summary

DWARF32 is not supported for XCOFF64 under non integrated-as mode, because system assembler will fill the debug section lengths according to DWARF64 format.
While in intergrated-as mode, XCOFF64 should be able to select the DWARF version.

[shchenz]

I think this is correct. DWARF spec indicates that DWARF64 should not be set as default. So it is right to change to DWARF32 by default for integrated-as mode for XCOFF64.

LGTM with one nit.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

412

Nit: Maybe we can use a variable to contain the value for TT.isOSBinFormatXCOFF().

[Esme]

Update test cases.

clang/lib/Driver/ToolChains/Clang.cpp

static void renderDwarfFormat(const Driver &D, const llvm::Triple &T,
 
   if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
     if (DwarfVersion < 3)
       D.Diag(diag::err_drv_argument_only_allowed_with)
           << DwarfFormatArg->getAsString(Args) << "DWARFv3 or greater";
     else if (!T.isArch64Bit())
       D.Diag(diag::err_drv_argument_only_allowed_with)
           << DwarfFormatArg->getAsString(Args) << "64 bit architecture";
-    else if (!T.isOSBinFormatELF())
+    else if (!(T.isOSBinFormatELF() || T.isOSBinFormatXCOFF()))
       D.Diag(diag::err_drv_argument_only_allowed_with)
-          << DwarfFormatArg->getAsString(Args) << "ELF platforms";
+          << DwarfFormatArg->getAsString(Args) << "ELF/XCOFF platforms";
   }
 
   DwarfFormatArg->render(Args, CmdArgs);
 }
 
 static void
 renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
                    const ArgList &Args, bool EmitCodeView, bool IRInput,

clang/test/Driver/debug-options-as.c

 // RUN:   | FileCheck -check-prefix=GDWARF64_VER %s
 // RUN: %clang -### -c -gdwarf64 -gdwarf-4 -target i386-linux-gnu %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=GDWARF64_32ARCH %s
 // RUN: %clang -### -c -gdwarf64 -gdwarf-4 -target x86_64-apple-darwin %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=GDWARF64_ELF %s
 //
 // GDWARF64_VER:  error: invalid argument '-gdwarf64' only allowed with 'DWARFv3 or greater'
 // GDWARF64_32ARCH: error: invalid argument '-gdwarf64' only allowed with '64 bit architecture'
-// GDWARF64_ELF: error: invalid argument '-gdwarf64' only allowed with 'ELF platforms'
+// GDWARF64_ELF: error: invalid argument '-gdwarf64' only allowed with 'ELF/XCOFF platforms'
 
 // Check that -gdwarf-N can be placed before other options of the "-g" group.
 // RUN: %clang -### -c -g -gdwarf-3 -target %itanium_abi_triple -fintegrated-as -x assembler %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=DWARF3 %s
 // RUN: %clang -### -c -gdwarf-3 -g -target %itanium_abi_triple -fintegrated-as -x assembler %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=DWARF3 %s
 // RUN: %clang -### -c -g -gdwarf-5 -target %itanium_abi_triple -fintegrated-as -x assembler %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=DWARF5 %s
 // RUN: %clang -### -c -gdwarf-5 -g -target %itanium_abi_triple -fintegrated-as -x assembler %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=DWARF5 %s
 
 // DWARF3: "-cc1as"
 // DWARF3: "-dwarf-version=3"
 // DWARF5: "-cc1as"
 // DWARF5: "-dwarf-version=5"

clang/test/Driver/debug-options.c

 // RUN: %clang -### -c -gdwarf-4 -gdwarf64 -target i386-linux-gnu %s 2>&1 \
 // RUN:       | FileCheck -check-prefix=GDWARF64_32ARCH %s
 // RUN: %clang -### -c -gdwarf-4 -gdwarf64 -target x86_64-apple-darwin %s 2>&1 \
 // RUN:       | FileCheck -check-prefix=GDWARF64_ELF %s
 //
 // GDWARF64_ON:  "-gdwarf64"
 // GDWARF64_VER:  error: invalid argument '-gdwarf64' only allowed with 'DWARFv3 or greater'
 // GDWARF64_32ARCH: error: invalid argument '-gdwarf64' only allowed with '64 bit architecture'
-// GDWARF64_ELF: error: invalid argument '-gdwarf64' only allowed with 'ELF platforms'
+// GDWARF64_ELF: error: invalid argument '-gdwarf64' only allowed with 'ELF/XCOFF platforms'
 
 /// Default to -fno-dwarf-directory-asm for -fno-integrated-as before DWARF v5.
 // RUN: %clang -### -target x86_64 -c -gdwarf-2 %s 2>&1 | FileCheck --check-prefix=DIRECTORY %s
 // RUN: %clang -### -target x86_64 -c -gdwarf-5 %s 2>&1 | FileCheck --check-prefix=DIRECTORY %s
 // RUN: %clang -### -target x86_64 -c -gdwarf-4 -fno-integrated-as %s 2>&1 | FileCheck --check-prefix=NODIRECTORY %s
 // RUN: %clang -### -target x86_64 -c -gdwarf-5 -fno-integrated-as %s 2>&1 | FileCheck --check-prefix=DIRECTORY %s
 
 // RUN: %clang -### -target x86_64 -c -gdwarf-4 -fno-dwarf-directory-asm %s 2>&1 | FileCheck --check-prefix=NODIRECTORY %s

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfDebug::DwarfDebug(AsmPrinter *A)
 
   bool Dwarf64 = DwarfVersion >= 3 && // DWARF64 was introduced in DWARFv3.
                  TT.isArch64Bit();    // DWARF64 requires 64-bit relocations.
 
   // Support DWARF64
   // 1: For ELF when requested.
   // 2: For XCOFF64: the AIX assembler will fill in debug section lengths
   //    according to the DWARF64 format for 64-bit assembly, so we must use
-  //    DWARF64 in the compiler too for 64-bit mode.
+  //    DWARF64 in the compiler for 64-bit mode on non-integrated-as mode.
+  bool IsXcoff = TT.isOSBinFormatXCOFF();
+  bool UseIntegratedAs = Asm->OutStreamer->isIntegratedAssemblerRequired();
   Dwarf64 &=
-      ((Asm->TM.Options.MCOptions.Dwarf64 || MMI->getModule()->isDwarf64()) &&
-       TT.isOSBinFormatELF()) ||
-      TT.isOSBinFormatXCOFF();
-
-  if (!Dwarf64 && TT.isArch64Bit() && TT.isOSBinFormatXCOFF())
-    report_fatal_error("XCOFF requires DWARF64 for 64-bit mode!");
+      ((TT.isOSBinFormatELF() || (IsXcoff && UseIntegratedAs)) &&
+       (Asm->TM.Options.MCOptions.Dwarf64 || MMI->getModule()->isDwarf64())) ||
+      (IsXcoff && !UseIntegratedAs);
+
+  if (!Dwarf64 && TT.isArch64Bit() && IsXcoff && !UseIntegratedAs)
+    report_fatal_error(
+        "XCOFF requires DWARF64 for 64-bit mode on non-integrated-as mode!");
 
   UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
 
   // Use sections as references. Force for NVPTX.
   if (DwarfSectionsAsReferences == Default)
     UseSectionsAsReferences = TT.isNVPTX();
   else
     UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
 
   // Don't generate type units for unsupported object file formats.

llvm/test/CodeGen/PowerPC/aix-dwarf.ll

 ; SEC-NEXT:      Name: .data
 ; SEC-NEXT:      PhysicalAddress: 0x28
 ; SEC-NEXT:      VirtualAddress: 0x28
 ; SEC32-NEXT:    Size: 0xC
 ; SEC32-NEXT:    RawDataOffset: 0x104
 ; SEC32-NEXT:    RelocationPointer: 0x1F4
 ; SEC64-NEXT:    Size: 0x18
 ; SEC64-NEXT:    RawDataOffset: 0x1A8
-; SEC64-NEXT:    RelocationPointer: 0x2C8
+; SEC64-NEXT:    RelocationPointer: 0x29C
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 2
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DATA (0x40)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 3
 ; SEC-NEXT:      Name: .dwabrev

 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 4
 ; SEC-NEXT:      Name: .dwinfo
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC32-NEXT:    Size: 0x57
 ; SEC32-NEXT:    RawDataOffset: 0x15C
 ; SEC32-NEXT:    RelocationPointer: 0x208
-; SEC64-NEXT:    Size: 0x6F
+; SEC64-NEXT:    Size: 0x5F
 ; SEC64-NEXT:    RawDataOffset: 0x200
-; SEC64-NEXT:    RelocationPointer: 0x2E4
+; SEC64-NEXT:    RelocationPointer: 0x2B8
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 4
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 5
 ; SEC-NEXT:      Name: .dwline
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC32-NEXT:    Size: 0x36
 ; SEC32-NEXT:    RawDataOffset: 0x1BC
 ; SEC32-NEXT:    RelocationPointer: 0x230
-; SEC64-NEXT:    Size: 0x46
-; SEC64-NEXT:    RawDataOffset: 0x280
-; SEC64-NEXT:    RelocationPointer: 0x31C
+; SEC64-NEXT:    Size: 0x3A
+; SEC64-NEXT:    RawDataOffset: 0x260
+; SEC64-NEXT:    RelocationPointer: 0x2F0
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 1
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:  ]
 
 ; RELO:      RELOCATION RECORDS FOR [.dwinfo]:
 ; RELO-NEXT:  OFFSET   TYPE                     VALUE
 ; RELO-NEXT:  00000006 R_POS                    .dwabrev
 ; RELO-NEXT:  00000027 R_POS                    .dwline
 ; RELO-NEXT:  00000009 R_POS                    .text
 ; RELO-NEXT:  0000003a R_POS                    .text
 ; RELO:       RELOCATION RECORDS FOR [.dwline]:
 ; RELO-NEXT:  OFFSET   TYPE                     VALUE
 ; RELO-NEXT:  00000000 R_POS                    .text
 
 ; RELO64:      RELOCATION RECORDS FOR [.dwinfo]:
 ; RELO64-NEXT: OFFSET           TYPE                     VALUE
-; RELO64-NEXT: 000000000000000e R_POS                    .dwabrev
-; RELO64-NEXT: 000000000000000b R_POS                    .dwline
-; RELO64-NEXT: 0000000000000041 R_POS                    .text
-; RELO64-NEXT: 000000000000004e R_POS                    .text
+; RELO64-NEXT: 0000000000000006 R_POS                    .dwabrev
+; RELO64-NEXT: 0000000000000027 R_POS                    .dwline
+; RELO64-NEXT: 0000000000000009 R_POS                    .text
+; RELO64-NEXT: 0000000000000016 R_POS                    .text
 ; RELO64:      RELOCATION RECORDS FOR [.dwline]:
 ; RELO64-NEXT: OFFSET           TYPE                     VALUE
-; RELO64-NEXT: 000000000000000c R_POS                    .text
+; RELO64-NEXT: 0000000000000000 R_POS                    .text

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section-debug.ll

 ; This file contains exception section testing for when debug information is present.
 ; The 32-bit test should not print exception auxilliary entries because they are a 64-bit only feature.
 ; Exception auxilliary entries are present in the 64-bit tests because 64-bit && debug enabled are the requirements.
 ; RUN: llc -mtriple=powerpc-ibm-aix-xcoff -filetype=obj -o %t_32.o < %s
 ; RUN: llvm-readobj --syms %t_32.o | FileCheck %s --check-prefix=SYMS32
-; RUN: llc -mtriple=powerpc64-unknown-aix -filetype=obj -o %t_32.o < %s
-; RUN: llvm-readobj --syms %t_32.o | FileCheck %s --check-prefix=SYMS64
+; RUN: llc -mtriple=powerpc64-unknown-aix -filetype=obj -o %t_64.o < %s
+; RUN: llvm-readobj --syms %t_64.o | FileCheck %s --check-prefix=SYMS64
 
 ; If any debug information is included in a module and is XCOFF64, exception auxilliary entries are emitted
 
 !llvm.module.flags = !{!0, !1}
 !llvm.dbg.cu = !{!2}
 
 !0 = !{i32 2, !"Dwarf Version", i32 3}
 !1 = !{i32 2, !"Debug Info Version", i32 3}

 ; SYMS64:           Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .sub_test
 ; SYMS64-NEXT:      Value (RelocatableAddress): 0x0
 ; SYMS64-NEXT:      Section: .text
 ; SYMS64-NEXT:      Type: 0x0
 ; SYMS64-NEXT:      StorageClass: C_EXT (0x2)
 ; SYMS64-NEXT:      NumberOfAuxEntries: 3
 ; SYMS64-NEXT:      Exception Auxiliary Entry {
 ; SYMS64-NEXT:        Index: [[#IND+1]]
-; SYMS64-NEXT:        OffsetToExceptionTable: 0x398
+; SYMS64-NEXT:        OffsetToExceptionTable: 0x38C
 ; SYMS64-NEXT:        SizeOfFunction: 0x18
 ; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+4]]
 ; SYMS64-NEXT:        Auxiliary Type: AUX_EXCEPT (0xFF)
 ; SYMS64-NEXT:      }
 ; SYMS64-NEXT:      Function Auxiliary Entry {
 ; SYMS64-NEXT:        Index: [[#IND+2]]
 ; SYMS64-NEXT:        SizeOfFunction: 0x18
 ; SYMS64-NEXT:        PointerToLineNum: 0x0

 ; SYMS64-NEXT:      Name: .test__trap_annotation_debug
 ; SYMS64-NEXT:      Value (RelocatableAddress): 0x28
 ; SYMS64-NEXT:      Section: .text
 ; SYMS64-NEXT:      Type: 0x0
 ; SYMS64-NEXT:      StorageClass: C_EXT (0x2)
 ; SYMS64-NEXT:      NumberOfAuxEntries: 3
 ; SYMS64-NEXT:      Exception Auxiliary Entry {
 ; SYMS64-NEXT:        Index: [[#IND+5]]
-; SYMS64-NEXT:        OffsetToExceptionTable: 0x3AC
+; SYMS64-NEXT:        OffsetToExceptionTable: 0x3A0
 ; SYMS64-NEXT:        SizeOfFunction: 0x68
 ; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+8]]
 ; SYMS64-NEXT:        Auxiliary Type: AUX_EXCEPT (0xFF)
 ; SYMS64-NEXT:      }
 ; SYMS64-NEXT:      Function Auxiliary Entry {
 ; SYMS64-NEXT:        Index: [[#IND+6]]
 ; SYMS64-NEXT:        SizeOfFunction: 0x68
 ; SYMS64-NEXT:        PointerToLineNum: 0x0

llvm/test/DebugInfo/XCOFF/dwarf-format.ll

+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj %s -o - \
+; RUN:   | llvm-dwarfdump -debug-line - | FileCheck %s --check-prefixes=CHECK
+
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -dwarf64 %s -o - \
+; RUN:   | llvm-dwarfdump -debug-line - | FileCheck %s --check-prefixes=CHECK64
+
+; CHECK: file format aix5coff64-rs6000
+; CHECK: format: DWARF32
+
+; CHECK64: file format aix5coff64-rs6000
+; CHECK64: format: DWARF64
+
+source_filename = "1.c"
+target datalayout = "E-m:a-p:32:32-Fi32-i64:64-n32"
+
+@foo = global i32 0, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!6, !7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", scope: !2, file: !3, line: 1, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 17.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "1.c", directory: "llvm-project")
+!4 = !{!0}
+!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!6 = !{i32 7, !"Dwarf Version", i32 3}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{i32 1, !"wchar_size", i32 2}
+!9 = !{i32 8, !"PIC Level", i32 2}
+!10 = !{i32 7, !"frame-pointer", i32 2}
+!11 = !{!"clang version 17.0.0"}