[XCOFF] write the real source file name in C_FILE symbol.

[shchenz]

llvm/lib/MC/XCOFFObjectWriter.cpp

499

What if we are compiling a .s file and there are more than one .file in the file?

[Esme]

Considered the scenario of multiple source files.

[MaskRay]

llvm/lib/MC/XCOFFObjectWriter.cpp

981

llvm coding standard uses pre-increments.

[Esme]

Addressed comments and added a test for this patch.

[jhenderson]

llvm/test/MC/PowerPC/aix-symtbl-order.s

4 ↗

(On Diff #435420)

Do you mean "when support is added to llvm-mc"? "when llvm-mc is supported" implies the application isn't yet supported, but you are actively using it in this test.

[Esme]

Addressed James's comments.

[jhenderson]

No further comments from me at this time, but I'm not knowledgeable enough about this area to be able to LGTM it.

[Esme]

The AIX assembler doesn't really support multiple .file statements and its output symbol table starts with all the .file symbols.
This update drops the symbol order logic from the previous version in favor of a behavior consistent with the AIX assembly.

[shchenz]

llvm/test/MC/PowerPC/aix-symtbl-order.s

7 ↗

(On Diff #437443)

We are over design here? Like what we discussed offline, AIX assembler does not have the functionality to guarantee that the local/global symbols are associated with their precedent .file directive. I think it is better for us to do as AIX assembler does, just generate the C_FILE symbols for each .file and don't do any symbol scope related handling.

8 ↗

(On Diff #437443)

Nit: for function entry, we need to make it like .foo.

[shchenz]

oops, my last comment is for previous change, don't aware the patch is already updated when I posted that comment.

llvm/lib/MC/XCOFFObjectWriter.cpp

499

Seems all the .file symbols are all changed to <stdin>? Can we add a new case for this branch?

862

Nits: Write C_FILE symbols?

965–966

C_FILE?

[Esme]

Addressed @shchenz's comments. Thanks!

[shchenz]

LGTM with nits. Thanks for fixing this.

llvm/test/MC/PowerPC/aix-file-symbols-empty.s

7

nit: var1 and var2 are both function entries by default. We need to name them as .var1 and .var2.

llvm/test/MC/PowerPC/aix-file-symbols.s

11

Ditto.

[Esme]

Addressed comments.

llvm/lib/MC/XCOFFObjectWriter.cpp

 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint64_t RelocationEntryOffset = 0;
   StringRef SourceFileName = ".file";
+  std::vector<std::pair<std::string, size_t>> FileNames;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   const uint64_t MaxRawDataSize =
       TargetObjectWriter->is64Bit() ? UINT64_MAX : UINT32_MAX;
 
for (const MCSymbol &S : Asm.symbols()) {
     Csect->Syms.emplace_back(XSym);
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(XSym->getSymbolTableName()))
       Strings.add(XSym->getSymbolTableName());
   }
 
-  // The first symbol entry is for the source file's name.
-  if (nameShouldBeInStringTable(SourceFileName))
-    Strings.add(SourceFileName);
+  FileNames = Asm.getFileNames();
+  // Emit ".file" as the source file name when there is no file name.
+  if (FileNames.empty())
+    FileNames.emplace_back(".file", 0);
+  for (const std::pair<std::string, size_t> &F : FileNames) {
+    if (nameShouldBeInStringTable(F.first))
+      Strings.add(F.first);
+  }
 
   Strings.finalize();
   assignAddressesAndIndices(Layout);
 }
 
 void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
                                          const MCAsmLayout &Layout,
                                          const MCFragment *Fragment,
void XCOFFObjectWriter::writeRelocations() {
   }
 
   for (const auto &DwarfSection : DwarfSections)
     for (const auto &Reloc : DwarfSection.DwarfSect->Relocations)
       writeRelocation(Reloc, *DwarfSection.DwarfSect);
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
-  // Write symbol 0 as C_FILE.
+  // Write C_FILE symbols.
   // The n_name of a C_FILE symbol is the source file's name when no auxiliary
-  // entries are present. The source file's name is alternatively provided by an
-  // auxiliary entry, in which case the n_name of the C_FILE symbol is `.file`.
-  // FIXME: add the real source file's name.
-  writeSymbolEntry(SourceFileName, /*Value=*/0,
-                   XCOFF::ReservedSectionNum::N_DEBUG,
+  // entries are present.
+  for (const std::pair<std::string, size_t> &F : FileNames) {
+    writeSymbolEntry(F.first, /*Value=*/0, XCOFF::ReservedSectionNum::N_DEBUG,
                      /*SymbolType=*/0, XCOFF::C_FILE,
                      /*NumberOfAuxEntries=*/0);
+  }
 
   for (const auto &Csect : UndefinedCsects) {
     writeSymbolEntryForControlSection(Csect, XCOFF::ReservedSectionNum::N_UNDEF,
                                       Csect.MCSec->getStorageClass());
   }
 
   for (const auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
void XCOFFObjectWriter::finalizeSectionInfo() {
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
-  // The first symbol table entry (at index 0) is for the file name.
-  uint32_t SymbolTableIndex = 1;
+  // The symbol table starts with all the C_FILE symbols.
+  uint32_t SymbolTableIndex = FileNames.size();
 
   // Calculate indices for undefined symbols.
   for (auto &Csect : UndefinedCsects) {
     Csect.Size = 0;
     Csect.Address = 0;
     Csect.SymbolTableIndex = SymbolTableIndex;
     SymbolIndexMap[Csect.MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
     // 1 main and 1 auxiliary symbol table entry for each contained symbol.
     SymbolTableIndex += 2;
   }
 
   // The address corrresponds to the address of sections and symbols in the
   // object file. We place the shared address 0 immediately after the
   // section header table.
   uint64_t Address = 0;
   // Section indices are 1-based in XCOFF.
   int32_t SectionIndex = 1;
   bool HasTDataSection = false;
 
   for (auto *Section : Sections) {
     const bool IsEmpty =
         llvm::all_of(Section->Groups,
                      [](const CsectGroup *Group) { return Group->empty(); });

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

 ; COMMON-NEXT: L..C0:
 ; COMMON-NEXT:    .tc foo_ext_weak_p[TC],foo_ext_weak_p
 ; COMMON-NEXT: L..C1:
 ; COMMON-NEXT:    .tc b_w[TC],b_w[UA]
 
 ; CHECKSYM:      Symbols [
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: 0
-; CHECKSYM-NEXT:     Name: .file
+; CHECKSYM-NEXT:     Name: <stdin>
 ; CHECKSYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; CHECKSYM-NEXT:     Section: N_DEBUG
 ; CHECKSYM-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECKSYM-NEXT:     CPU Version ID: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 0
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

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

 ; COMMON-NEXT: L..C0:
 ; COMMON-NEXT:      .tc b_e[TC],b_e[UA]
 ; COMMON-NEXT: L..C1:
 ; COMMON-NEXT:      .tc bar_p[TC],bar_p
 
 ; CHECKSYM:       Symbols [
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: 0
-; CHECKSYM-NEXT:     Name: .file
+; CHECKSYM-NEXT:     Name: <stdin>
 ; CHECKSYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; CHECKSYM-NEXT:     Section: N_DEBUG
 ; CHECKSYM-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECKSYM-NEXT:     CPU Version ID: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 0
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

llvm/test/CodeGen/PowerPC/aix-func-dsc-gen.ll

 ; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj  --symbols %t.o | FileCheck %s
 
 define void @foo() {
 entry:
   ret void
 }
 
 ; CHECK:      File: {{.*}}aix-func-dsc-gen.ll.tmp.o
 ; CHECK-NEXT: Format: aixcoff-rs6000
 ; CHECK-NEXT: Arch: powerpc
 ; CHECK-NEXT: AddressSize: 32bit
 ; CHECK:        Symbol {
 ; CHECK-NEXT:     Index: 0
-; CHECK-NEXT:     Name: .file
+; CHECK-NEXT:     Name: <stdin>
 ; CHECK-NEXT:     Value (SymbolTableIndex): 0x0
 ; CHECK-NEXT:     Section: N_DEBUG
 ; CHECK-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECK-NEXT:     CPU Version ID: 0x0
 ; CHECK-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECK-NEXT:     NumberOfAuxEntries: 0
 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {

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

 ; CHECK-NEXT:         mflr 0
 
 ; CHECK:              bl .memset
 
 ; CHECK:              .extern .memset
 
 ; CHECKSYM:        Symbol {
 ; CHECKSYM-NEXT:     Index: 0
-; CHECKSYM-NEXT:     Name: .file
+; CHECKSYM-NEXT:     Name: <stdin>
 ; CHECKSYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; CHECKSYM-NEXT:     Section: N_DEBUG
 ; CHECKSYM-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECKSYM-NEXT:     CPU Version ID: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 0
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-reloc-large.ll

 
 ; SYM:      File: {{.*}}aix-tls-xcoff-reloc-large.ll.tmp.o
 ; SYM-NEXT: Format: aixcoff-rs6000
 ; SYM-NEXT: Arch: powerpc
 ; SYM-NEXT: AddressSize: 32bit
 ; SYM-NEXT: Symbols [
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 0
-; SYM-NEXT:     Name: .file
+; SYM-NEXT:     Name: <stdin>
 ; SYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYM-NEXT:     Section: N_DEBUG
 ; SYM-NEXT:     Source Language ID: TB_C (0x0)
 ; SYM-NEXT:     CPU Version ID: 0x0
 ; SYM-NEXT:     StorageClass: C_FILE (0x67)
 ; SYM-NEXT:     NumberOfAuxEntries: 0
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-reloc.ll

 
 ; SYM:      File: {{.*}}aix-tls-xcoff-reloc.ll.tmp.o
 ; SYM-NEXT: Format: aixcoff-rs6000
 ; SYM-NEXT: Arch: powerpc
 ; SYM-NEXT: AddressSize: 32bit
 ; SYM-NEXT: Symbols [
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 0
-; SYM-NEXT:     Name: .file
+; SYM-NEXT:     Name: <stdin>
 ; SYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYM-NEXT:     Section: N_DEBUG
 ; SYM-NEXT:     Source Language ID: TB_C (0x0)
 ; SYM-NEXT:     CPU Version ID: 0x0
 ; SYM-NEXT:     StorageClass: C_FILE (0x67)
 ; SYM-NEXT:     NumberOfAuxEntries: 0
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-variables.ll

 
 ; SYMS:      File: {{.*}}aix-tls-xcoff-variables.ll.tmp.o
 ; SYMS-NEXT: Format: aixcoff-rs6000
 ; SYMS-NEXT: Arch: powerpc
 ; SYMS-NEXT: AddressSize: 32bit
 ; SYMS-NEXT: Symbols [
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: 0
-; SYMS-NEXT:     Name: .file
+; SYMS-NEXT:     Name: <stdin>
 ; SYMS-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYMS-NEXT:     Section: N_DEBUG
 ; SYMS-NEXT:     Source Language ID: TB_C (0x0)
 ; SYMS-NEXT:     CPU Version ID: 0x0
 ; SYMS-NEXT:     StorageClass: C_FILE (0x67)
 ; SYMS-NEXT:     NumberOfAuxEntries: 0
 ; SYMS-NEXT:   }
 ; SYMS-NEXT:   Symbol {

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

 ; COMMON-NEXT:          .tc foo_weak_p[TC],foo_weak_p
 ; COMMON-NEXT:  L..C1:
 ; COMMON-NEXT:          .tc b[TC],b
 
 
 ; CHECKSYM:      Symbols [
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: 0
-; CHECKSYM-NEXT:     Name: .file
+; CHECKSYM-NEXT:     Name: <stdin>
 ; CHECKSYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; CHECKSYM-NEXT:     Section: N_DEBUG
 ; CHECKSYM-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECKSYM-NEXT:     CPU Version ID: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 0
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

llvm/test/CodeGen/PowerPC/aix-xcoff-data.ll

 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_BSS (0x80)
 ; OBJ-NEXT:   }
 ; OBJ:      ]
 
 ; SYMS:      Symbols [
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: 0
-; SYMS-NEXT:     Name: .file
+; SYMS-NEXT:     Name: <stdin>
 ; SYMS-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYMS-NEXT:     Section: N_DEBUG
 ; SYMS-NEXT:     Source Language ID: TB_C (0x0)
 ; SYMS-NEXT:     CPU Version ID: 0x0
 ; SYMS-NEXT:     StorageClass: C_FILE (0x67)
 ; SYMS-NEXT:     NumberOfAuxEntries: 0
 ; SYMS-NEXT:   }
 ; SYMS-NEXT:   Symbol {

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc.ll

 ; RELOC-NEXT:       Type: R_POS (0x0)
 ; RELOC-NEXT:     }
 ; RELOC-NEXT:   }
 ; RELOC-NEXT: ]
 
 ; SYM:      Symbols [
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 0
-; SYM-NEXT:     Name: .file
+; SYM-NEXT:     Name: <stdin>
 ; SYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYM-NEXT:     Section: N_DEBUG
 ; SYM-NEXT:     Source Language ID: TB_C (0x0)
 ; SYM-NEXT:     CPU Version ID: 0x0
 ; SYM-NEXT:     StorageClass: C_FILE (0x67)
 ; SYM-NEXT:     NumberOfAuxEntries: 0
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {

llvm/test/MC/PowerPC/aix-file-symbols-empty.s

+## Emit ".file" as the source file name when there is no file name.
+# RUN: llvm-mc -triple powerpc-ibm-aix-xcoff %s -filetype=obj -o - | \
+# RUN:    llvm-objdump --syms - | FileCheck %s
+
+      .globl .var1
+.var1:
+      .globl .var2
+.var2:
+
+# CHECK:      SYMBOL TABLE:
+# CHECK-NEXT: 00000000      df *DEBUG*  00000000 .file
+# CHECK-NEXT: 00000000 l       .text  00000000 .text
+# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var1
+# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var2

llvm/test/MC/PowerPC/aix-file-symbols.s

+## Check mutiple C_FILE symbols are emitted.
+# RUN: llvm-mc -triple powerpc-ibm-aix-xcoff %s -filetype=obj -o - | \
+# RUN:    llvm-objdump --syms - | FileCheck %s
+
+      .file   "1.c"
+      .globl .var1
+.var1:
+      .file   "2.c"
+      .globl .var2
+.var2:
+      .file   "3.c"
+
+# CHECK:      SYMBOL TABLE:
+# CHECK-NEXT: 00000000      df *DEBUG*  00000000 1.c
+# CHECK-NEXT: 00000000      df *DEBUG*  00000000 2.c
+# CHECK-NEXT: 00000000      df *DEBUG*  00000000 3.c
+# CHECK-NEXT: 00000000 l       .text  00000000 .text
+# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var1
+# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var2

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

 define void @foo()  {
 entry:
   %0 = load i8*, i8** @con, align 4
   %call = call i32 @bar(i8* %0)
   ret void
 }
 
 ; SYM:      SYMBOL TABLE:
-; SYM-NEXT: 00000000      df *DEBUG*    00000000 .file
+; SYM-NEXT: 00000000      df *DEBUG*    00000000 <stdin>
 ; SYM-NEXT: 00000000         *UND*      00000000 ei
 ; SYM-NEXT: 00000000 l       .text      00000091 .text
 ; SYM-NEXT: 00000000 g     F .text (csect: .text)       00000000 .bar
 ; SYM-NEXT: 00000050 g     F .text (csect: .text)       00000000 .foo
 ; SYM-NEXT: 00000094 l       .text      00000013 .rodata.str1.1L...str
 ; SYM-NEXT: 000000a8 g     O .data      00000004 con
 ; SYM-NEXT: 000000ac  w    O .data      00000004 wi
 ; SYM-NEXT: 000000b0 g     O .data      00000004 i
 ; SYM-NEXT: 000000b4 g     O .data      00000001 c
 ; SYM-NEXT: 000000b8 g     O .data      00000004 ap
 ; SYM-NEXT: 000000bc g     O .data      00000004 f
 ; SYM-NEXT: 000000c0 g     O .data      00000008 ll
 ; SYM-NEXT: 000000c8 g     O .data      0000000c bar
 ; SYM-NEXT: 000000d4 g     O .data      0000000c foo
 ; SYM-NEXT: 000000e0 l       .data      00000000 TOC
 ; SYM-NEXT: 000000e0 l     O .data      00000004 si
 ; SYM-NEXT: 000000e4 l     O .data      00000004 ei
 ; SYM-NEXT: 000000e8 l     O .data      00000004 con
 ; SYM-NEXT: 000000ec l     O *COM*      00000004 si
 
 ; SYM-DES:      SYMBOL TABLE:
-; SYM-DES-NEXT: 00000000      df *DEBUG*    00000000 (idx: 0) .file
+; SYM-DES-NEXT: 00000000      df *DEBUG*    00000000 (idx: 0) <stdin>
 ; SYM-DES-NEXT: 00000000         *UND*      00000000 (idx: 1) ei[UA]
 ; SYM-DES-NEXT: 00000000 l       .text      00000091 (idx: 3) .text[PR]
 ; SYM-DES-NEXT: 00000000 g     F .text (csect: (idx: 3) .text[PR])  00000000 (idx: 5) .bar
 ; SYM-DES-NEXT: 00000050 g     F .text (csect: (idx: 3) .text[PR])  00000000 (idx: 7) .foo
 ; SYM-DES-NEXT: 00000094 l       .text      00000013 (idx: 9) .rodata.str1.1L...str[RO]
 ; SYM-DES-NEXT: 000000a8 g     O .data      00000004 (idx: 11) con[RW]
 ; SYM-DES-NEXT: 000000ac  w    O .data      00000004 (idx: 13) wi[RW]
 ; SYM-DES-NEXT: 000000b0 g     O .data      00000004 (idx: 15) i[RW]