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

[shchenz]

llvm/lib/MC/XCOFFObjectWriter.cpp

502

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

987

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

502

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

863–864

Nits: Write C_FILE symbols?

980–981

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

6 ↗

(On Diff #438320)

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

10 ↗

(On Diff #438320)

Ditto.

[Esme]

Addressed comments.

llvm/lib/MC/XCOFFObjectWriter.cpp

 
 // Wrapper for an MCSectionXCOFF.
 // It can be a Csect or debug section or DWARF section and so on.
 struct XCOFFSection {
   const MCSectionXCOFF *const MCSec;
   uint32_t SymbolTableIndex;
   uint64_t Address;
   uint64_t Size;
+  uint32_t Order;
 
   SmallVector<Symbol, 1> Syms;
   SmallVector<XCOFFRelocation, 1> Relocations;
   StringRef getSymbolTableName() const { return MCSec->getSymbolTableName(); }
   XCOFF::VisibilityType getVisibilityType() const {
     return MCSec->getVisibilityType();
   }
   XCOFFSection(const MCSectionXCOFF *MCSec)
-      : MCSec(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
+      : MCSec(MCSec), SymbolTableIndex(-1), Address(-1), Size(0), Order(0) {}
 };
 
 // Type to be used for a container representing a set of csects with
 // (approximately) the same storage mapping class. For example all the csects
 // with a storage mapping class of `xmc_pr` will get placed into the same
 // container.
 using CsectGroup = std::deque<XCOFFSection>;
 using CsectGroups = std::deque<CsectGroup *>;

 };
 
 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;
 
class XCOFFObjectWriter : public MCObjectWriter {
   // `executePostLayoutBinding`, this function handles building up the majority
   // of the structures in the object file representation. Namely:
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
   //    `Sections`.
   void assignAddressesAndIndices(const MCAsmLayout &);
+  void assignIndicesForSymTbl();
   void finalizeSectionInfo();
 
   // TODO aux header support not implemented.
   bool needsAuxiliaryHeader() const { return false; }
 
   // Returns the size of the auxiliary header to be written to the object file.
   size_t auxiliaryHeaderSize() const {
     assert(!needsAuxiliaryHeader() &&
if (MCSec->isCsect()) {
       DwarfSectionEntry SecEntry(MCSec->getName(),
                                  MCSec->getDwarfSubtypeFlags().getValue(),
                                  std::move(DwarfSec));
       DwarfSections.push_back(std::move(SecEntry));
     } else
       llvm_unreachable("unsupport section type!");
   }
 
-  for (const MCSymbol &S : Asm.symbols()) {
+  for (auto It : llvm::enumerate(Asm.symbols())) {
     // Nothing to do for temporary symbols.
-    if (S.isTemporary())
+    if (It.value().isTemporary())
       continue;
 
-    const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
+    const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&It.value());
     const MCSectionXCOFF *ContainingCsect = getContainingCsect(XSym);
 
     if (ContainingCsect->getCSectType() == XCOFF::XTY_ER) {
       // Handle undefined symbol.
       UndefinedCsects.emplace_back(ContainingCsect);
       SectionMap[ContainingCsect] = &UndefinedCsects.back();
+      SectionMap[ContainingCsect]->Order = It.index();
       if (nameShouldBeInStringTable(ContainingCsect->getSymbolTableName()))
         Strings.add(ContainingCsect->getSymbolTableName());
       continue;
     }
 
     // If the symbol is the csect itself, we don't need to put the symbol
     // into csect's Syms.
     if (XSym == ContainingCsect->getQualNameSymbol())
       continue;
 
     // Only put a label into the symbol table when it is an external label.
     if (!XSym->isExternal())
       continue;
 
     assert(SectionMap.find(ContainingCsect) != SectionMap.end() &&
            "Expected containing csect to exist in map");
     XCOFFSection *Csect = SectionMap[ContainingCsect];
+    Csect->Order = It.index();
     // Lookup the containing csect and add the symbol to it.
     assert(Csect->MCSec->isCsect() && "only csect is supported now!");
     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();
+  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,
for (const auto *Section : Sections) {
     }
   }
 
   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.
-  // 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,
+  for (auto FileNameIt = FileNames.begin(); FileNameIt != FileNames.end();
+       ++FileNameIt) {
+    // Write the file symbol.
+    writeSymbolEntry(FileNameIt->first, /*Value=*/0,
                      XCOFF::ReservedSectionNum::N_DEBUG,
                      /*SymbolType=*/0, XCOFF::C_FILE,
                      /*NumberOfAuxEntries=*/0);
 
+    uint32_t CurrFileSymbolIdx = FileNameIt->second;
+    uint32_t NextFileSymbolIdx = (FileNameIt + 1) != FileNames.end()
+                                     ? (FileNameIt + 1)->second
+                                     : INT32_MAX;
+
     for (const auto &Csect : UndefinedCsects) {
-    writeSymbolEntryForControlSection(Csect, XCOFF::ReservedSectionNum::N_UNDEF,
+      if (Csect.Order < CurrFileSymbolIdx || Csect.Order >= NextFileSymbolIdx)
+        continue;
+      writeSymbolEntryForControlSection(Csect,
+                                        XCOFF::ReservedSectionNum::N_UNDEF,
                                         Csect.MCSec->getStorageClass());
     }
 
     for (const auto *Section : Sections) {
       if (Section->Index == SectionEntry::UninitializedIndex)
         // Nothing to write for this Section.
         continue;
 
       for (const auto *Group : Section->Groups) {
         if (Group->empty())
           continue;
 
         const int16_t SectionIndex = Section->Index;
         for (const auto &Csect : *Group) {
+          if (Csect.Order < CurrFileSymbolIdx ||
+              Csect.Order >= NextFileSymbolIdx)
+            continue;
           // Write out the control section first and then each symbol in it.
           writeSymbolEntryForControlSection(Csect, SectionIndex,
                                             Csect.MCSec->getStorageClass());
 
           for (const auto &Sym : Csect.Syms)
             writeSymbolEntryForCsectMemberLabel(
                 Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
         }
       }
     }
 
-  for (const auto &DwarfSection : DwarfSections)
+    for (const auto &DwarfSection : DwarfSections) {
+      if (DwarfSection.DwarfSect->Order < CurrFileSymbolIdx ||
+          DwarfSection.DwarfSect->Order >= NextFileSymbolIdx)
+        continue;
       writeSymbolEntryForDwarfSection(*DwarfSection.DwarfSect,
                                       DwarfSection.Index);
     }
+  }
+}
 
 void XCOFFObjectWriter::finalizeSectionInfo() {
   for (auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to record for this Section.
       continue;
 
     for (const auto *Group : Section->Groups) {
void XCOFFObjectWriter::finalizeSectionInfo() {
   for (auto &DwarfSec : DwarfSections)
     calcOffsetToRelocations(&DwarfSec, /* IsDwarf */ true);
 
   // 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;
+void XCOFFObjectWriter::assignIndicesForSymTbl() {
+  uint32_t SymbolTableIndex = 0;
+
+  for (auto FileNameIt = FileNames.begin(); FileNameIt != FileNames.end();
+       ++FileNameIt) {
+    // The first symbol table entry is for the file name.
+    SymbolTableIndex++;
+
+    uint32_t CurrFileSymbolIdx = FileNameIt->second;
+    uint32_t NextFileSymbolIdx = (FileNameIt + 1) != FileNames.end()
+                                     ? (FileNameIt + 1)->second
+                                     : INT32_MAX;
 
     // Calculate indices for undefined symbols.
     for (auto &Csect : UndefinedCsects) {
+      if (Csect.Order < CurrFileSymbolIdx || Csect.Order >= NextFileSymbolIdx)
+        continue;
       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;
     }
 
+    for (auto *Section : Sections) {
+      if (Section->Index == SectionEntry::UninitializedIndex)
+        continue;
+
+      for (auto *Group : Section->Groups) {
+        if (Group->empty())
+          continue;
+
+        for (auto &Csect : *Group) {
+          if (Csect.Order < CurrFileSymbolIdx ||
+              Csect.Order >= NextFileSymbolIdx)
+            continue;
+          Csect.SymbolTableIndex = SymbolTableIndex;
+          SymbolIndexMap[Csect.MCSec->getQualNameSymbol()] =
+              Csect.SymbolTableIndex;
+          // 1 main and 1 auxiliary symbol table entry for the csect.
+          SymbolTableIndex += 2;
+
+          for (auto &Sym : Csect.Syms) {
+            Sym.SymbolTableIndex = SymbolTableIndex;
+            SymbolIndexMap[Sym.MCSym] = Sym.SymbolTableIndex;
+            // 1 main and 1 auxiliary symbol table entry for each contained
+            // symbol.
+            SymbolTableIndex += 2;
+          }
+        }
+      }
+    }
+
+    for (auto &DwarfSection : DwarfSections) {
+      XCOFFSection &DwarfSect = *DwarfSection.DwarfSect;
+      if (DwarfSect.Order < CurrFileSymbolIdx ||
+          DwarfSect.Order >= NextFileSymbolIdx)
+        continue;
+
+      // Symbol index.
+      DwarfSect.SymbolTableIndex = SymbolTableIndex;
+      SymbolIndexMap[DwarfSect.MCSec->getQualNameSymbol()] =
+          DwarfSect.SymbolTableIndex;
+      // 1 main and 1 auxiliary symbol table entry for the Dwarf section.
+      SymbolTableIndex += 2;
+    }
+  }
+  SymbolTableEntryCount = SymbolTableIndex;
+}
+
+void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // 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 *Group : Section->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
         const MCSectionXCOFF *MCSec = Csect.MCSec;
         Csect.Address = alignTo(Address, MCSec->getAlignment());
         Csect.Size = Layout.getSectionAddressSize(MCSec);
         Address = Csect.Address + Csect.Size;
-        Csect.SymbolTableIndex = SymbolTableIndex;
-        SymbolIndexMap[MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
-        // 1 main and 1 auxiliary symbol table entry for the csect.
-        SymbolTableIndex += 2;
-
-        for (auto &Sym : Csect.Syms) {
-          Sym.SymbolTableIndex = SymbolTableIndex;
-          SymbolIndexMap[Sym.MCSym] = Sym.SymbolTableIndex;
-          // 1 main and 1 auxiliary symbol table entry for each contained
-          // symbol.
-          SymbolTableIndex += 2;
-        }
       }
 
       if (!SectionAddressSet) {
         Section->Address = Group->front().Address;
         SectionAddressSet = true;
       }
     }
 
     // Make sure the address of the next section aligned to
     // DefaultSectionAlign.
     Address = alignTo(Address, DefaultSectionAlign);
     Section->Size = Address - Section->Address;
   }
 
   for (auto &DwarfSection : DwarfSections) {
     assert((SectionIndex <= MaxSectionIndex) && "Section index overflow!");
 
     XCOFFSection &DwarfSect = *DwarfSection.DwarfSect;
     const MCSectionXCOFF *MCSec = DwarfSect.MCSec;
 
     // Section index.
     DwarfSection.Index = SectionIndex++;
     SectionCount++;
 
-    // Symbol index.
-    DwarfSect.SymbolTableIndex = SymbolTableIndex;
-    SymbolIndexMap[MCSec->getQualNameSymbol()] = DwarfSect.SymbolTableIndex;
-    // 1 main and 1 auxiliary symbol table entry for the csect.
-    SymbolTableIndex += 2;
-
     // Section address. Make it align to section alignment.
     // We use address 0 for DWARF sections' Physical and Virtual Addresses.
     // This address is used to tell where is the section in the final object.
     // See writeSectionForDwarfSectionEntry().
     DwarfSection.Address = DwarfSect.Address =
         alignTo(Address, MCSec->getAlignment());
 
     // Section size.
     // For DWARF section, we must use the real size which may be not aligned.
     DwarfSection.Size = DwarfSect.Size = Layout.getSectionAddressSize(MCSec);
 
     // Make the Address align to default alignment for follow section.
     Address = alignTo(DwarfSect.Address + DwarfSect.Size, DefaultSectionAlign);
   }
 
-  SymbolTableEntryCount = SymbolTableIndex;
+  assignIndicesForSymTbl();
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer =
       (is64Bit() ? (XCOFF::FileHeaderSize64 +
                     SectionCount * XCOFF::SectionHeaderSize64)
                  : (XCOFF::FileHeaderSize32 +
                     SectionCount * XCOFF::SectionHeaderSize32)) +
       auxiliaryHeaderSize();

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/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]