DebugInfo/Symbolize: Retrieve filename from the preceding STT_FILE for .symtab symbolization

[MaskRay]

Summary

The ELF spec says:

STT_FILE: Conventionally, the symbol's name gives the name of the source file associated with the object file. A file symbol has STB_LOCAL binding, its section index is SHN_ABS, and it precedes the other STB_LOCAL symbols for the file, if it is present.

For a local symbol, the preceding STT_FILE symbol is almost always in the same
file[1]. GNU addr2line uses this heuristic to retrieve the filename associated
with a local symbol (e.g. internal linkage functions in C/C++).

GNU addr2line can assign STT_FILE filename to a non-local symbol, too, but the trick
only works if no regular symbol precede STT_FILE. This patch does not implement this corner case
(not useful for most executables which have more than one files).

In case of filename mismatch between .debug_line & .symtab, arbitrarily make .debug_line win.

[1]: LLD does not synthesize STT_FILE symbols
(https://bugs.llvm.org/show_bug.cgi?id=48023 see also
https://sourceware.org/bugzilla/show_bug.cgi?id=26822). An assembly file
without .file directives can cause mis-attribution. This is an edge case.

[MaskRay]

rebase

[dblaikie]

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

240

Could do the pair removal/rolling the StringRef into the struct as a preliminary patch to focus this patch a bit more. Not absolutely necessary by any means, though.

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.h

87

Separate patch, but this might be more tidily written as return std::tie(Addr, Size) < std::tie(RHS.Addr, RHS.Size);

[jhenderson]

There are some pre-merge bot failures looking at this patch, although I guess some of them might be a patch ordering issue.

Do we have test cases for the following negative aspects where the symbol isn't used?

1. The symbol name can't be looked up due to a corrupt st_name value.
2. There are no STT_FILE symbols before the local symbol in question (possibly there may be some after).
3. The symbol is a global symbol, with an STT_FILE symbol before it.
4. The symbol has a corresponding STT_FILE symbol, but the name from .debug_line can be found.

[MaskRay]

In D95927#2548006, @jhenderson wrote:

There are some pre-merge bot failures looking at this patch, although I guess some of them might be a patch ordering issue.

Do we have test cases for the following negative aspects where the symbol isn't used?

1. The symbol name can't be looked up due to a corrupt st_name value.
2. There are no STT_FILE symbols before the local symbol in question (possibly there may be some after).
3. The symbol is a global symbol, with an STT_FILE symbol before it.
4. The symbol has a corresponding STT_FILE symbol, but the name from .debug_line can be found.

The current --use-symbol-table=true (which allows .symtab information to override debug info) has no test coverage. The previous patch and this patch added more coverage in this area.

There are some interesting cases but I think the coverage can be added separately.

Making sure .file & debug info have consistent information is the responsibility of other components (DebugInfo/AsmPrinter/ELFObjectWriter/etc). The additional tests can check what we behave when inconsistent information is present.

[MaskRay]

rebase

[jhenderson]

In D95927#2549451, @MaskRay wrote:

In D95927#2548006, @jhenderson wrote:

There are some pre-merge bot failures looking at this patch, although I guess some of them might be a patch ordering issue.

Do we have test cases for the following negative aspects where the symbol isn't used?

1. The symbol name can't be looked up due to a corrupt st_name value.
2. There are no STT_FILE symbols before the local symbol in question (possibly there may be some after).
3. The symbol is a global symbol, with an STT_FILE symbol before it.
4. The symbol has a corresponding STT_FILE symbol, but the name from .debug_line can be found.

The current --use-symbol-table=true (which allows .symtab information to override debug info) has no test coverage. The previous patch and this patch added more coverage in this area.

There are some interesting cases but I think the coverage can be added separately.

All of the cases I highlighted are new cases introduced by this patch, since the STT_FILE symbols were not used to look up file names previously. Whether or not the rest of --use-symbol-table=true functionality is tested is rather irrelevant to this, I think. We shouldn't be creating additional technical debt by adding more areas that aren't tested properly.

Making sure .file & debug info have consistent information is the responsibility of other components (DebugInfo/AsmPrinter/ELFObjectWriter/etc). The additional tests can check what we behave when inconsistent information is present.

The Symbolizer library needs testing for consumption of both consistent and inconsistent information. I don't think the responsibility of ensuring this information is consistent is relevant to that.

[MaskRay]

more tests

[jhenderson]

LGTM, with a few nits.

llvm/test/DebugInfo/Symbolize/ELF/symtab-file-conflict.s

10

Nit: Do we actually need the CHECK-EMPTY line?

llvm/test/DebugInfo/Symbolize/ELF/symtab-file2.yaml

19

Same comment as above - do we need the trailing CHECK-EMPTY?

48

This is a bit unfortunate - possibly worth adding a TODO saying that we shouldn't throw away the symbol's name?

56

Should this be CHECK2-NEXT?

58

Unnecessary CHECK-EMPTY?

[MaskRay]

comments

[justice_adams]

Hi @MaskRay,

Looks like this commit caused some test failures on linux build machines. Buildbots for reference:
http://lab.llvm.org:8011/#/builders/94/builds/2238
http://lab.llvm.org:8011/#/builders/105/builds/5805

Could I have you take a look?
-Justice

[MaskRay]

In D95927#2555199, @justice_adams wrote:

Hi @MaskRay,

Looks like this commit caused some test failures on linux build machines. Buildbots for reference:
http://lab.llvm.org:8011/#/builders/94/builds/2238
http://lab.llvm.org:8011/#/builders/105/builds/5805

Could I have you take a look?
-Justice

Thanks. The filename in the llvm-symbolizer output changed. I temporarily changed the test's CHECK line and will check with sanitizer maintainers.

edit: vitalybuka said the filename change is fine.

[RKSimon]

@MaskRay the sanitizer buildbots are still broken by this: http://lab.llvm.org:8011/#/builders/121

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.h

public:
   // it in memory assuming there were no conflicts.
   uint64_t getModulePreferredBase() const override;
 
 private:
   bool shouldOverrideWithSymbolTable(FunctionNameKind FNKind,
                                      bool UseSymbolTable) const;
 
   bool getNameFromSymbolTable(object::SymbolRef::Type Type, uint64_t Address,
-                              std::string &Name, uint64_t &Addr,
-                              uint64_t &Size) const;
+                              std::string &Name, uint64_t &Addr, uint64_t &Size,
+                              std::string &FileName) const;
   // For big-endian PowerPC64 ELF, OpdAddress is the address of the .opd
   // (function descriptor) section and OpdExtractor refers to its contents.
   Error addSymbol(const object::SymbolRef &Symbol, uint64_t SymbolSize,
                   DataExtractor *OpdExtractor = nullptr,
                   uint64_t OpdAddress = 0);
   Error addCoffExportSymbols(const object::COFFObjectFile *CoffObj);
 
   /// Search for the first occurence of specified Address in ObjectFile.
   uint64_t getModuleSectionIndexForAddress(uint64_t Address) const;
 
   const object::ObjectFile *Module;
   std::unique_ptr<DIContext> DebugInfoContext;
   bool UntagAddresses;
 
   struct SymbolDesc {
     uint64_t Addr;
     // If size is 0, assume that symbol occupies the whole memory range up to
     // the following symbol.
     uint64_t Size;
 
+    StringRef Name;
+    // Non-zero if this is an ELF local symbol. See the comment in
+    // getNameFromSymbolTable.
+    uint32_t ELFLocalSymIdx;
+
     bool operator<(const SymbolDesc &RHS) const {
       return Addr != RHS.Addr ? Addr < RHS.Addr : Size < RHS.Size;
     }
   };
-  std::vector<std::pair<SymbolDesc, StringRef>> Functions;
-  std::vector<std::pair<SymbolDesc, StringRef>> Objects;
+  std::vector<SymbolDesc> Functions;
+  std::vector<SymbolDesc> Objects;
+  // (index, filename) pairs of ELF STT_FILE symbols.
+  std::vector<std::pair<uint32_t, StringRef>> FileSymbols;
 
   SymbolizableObjectFile(const object::ObjectFile *Obj,
                          std::unique_ptr<DIContext> DICtx,
                          bool UntagAddresses);
 };
 
 } // end namespace symbolize
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_DEBUGINFO_SYMBOLIZE_SYMBOLIZABLEOBJECTFILE_H

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

 //===----------------------------------------------------------------------===//
 
 #include "SymbolizableObjectFile.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolSize.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataExtractor.h"
 #include <algorithm>
 
 using namespace llvm;
 using namespace object;
SymbolizableObjectFile::create(const object::ObjectFile *Obj,
   // If this is a COFF object and we didn't find any symbols, try the export
   // table.
   if (Symbols.empty()) {
     if (auto *CoffObj = dyn_cast<COFFObjectFile>(Obj))
       if (Error E = res->addCoffExportSymbols(CoffObj))
         return std::move(E);
   }
 
-  std::vector<std::pair<SymbolDesc, StringRef>> &Fs = res->Functions,
-                                                &Os = res->Objects;
-  auto Uniquify = [](std::vector<std::pair<SymbolDesc, StringRef>> &S) {
+  std::vector<SymbolDesc> &Fs = res->Functions, &Os = res->Objects;
+  auto Uniquify = [](std::vector<SymbolDesc> &S) {
     // Sort by (Addr,Size,Name). If several SymbolDescs share the same Addr,
     // pick the one with the largest Size. This helps us avoid symbols with no
     // size information (Size=0).
     llvm::sort(S);
     auto I = S.begin(), E = S.end(), J = S.begin();
     while (I != E) {
       auto OI = I;
-      while (++I != E && OI->first.Addr == I->first.Addr) {
+      while (++I != E && OI->Addr == I->Addr) {
       }
       *J++ = I[-1];
     }
     S.erase(J, S.end());
   };
   Uniquify(Fs);
   Uniquify(Os);
 
Error SymbolizableObjectFile::addCoffExportSymbols(
   // FIXME: This assumes all exports are functions.
   uint64_t ImageBase = CoffObj->getImageBase();
   for (auto I = ExportSyms.begin(), E = ExportSyms.end(); I != E; ++I) {
     OffsetNamePair &Export = *I;
     // FIXME: The last export has a one byte size now.
     uint32_t NextOffset = I != E ? I->Offset : Export.Offset + 1;
     uint64_t SymbolStart = ImageBase + Export.Offset;
     uint64_t SymbolSize = NextOffset - Export.Offset;
-    SymbolDesc SD = {SymbolStart, SymbolSize};
-    Functions.emplace_back(SD, Export.Name);
+    Functions.push_back({SymbolStart, SymbolSize, Export.Name, 0});
   }
   return Error::success();
 }
 
 Error SymbolizableObjectFile::addSymbol(const SymbolRef &Symbol,
                                         uint64_t SymbolSize,
                                         DataExtractor *OpdExtractor,
                                         uint64_t OpdAddress) {
   // Avoid adding symbols from an unknown/undefined section.
   const ObjectFile &Obj = *Symbol.getObject();
+  Expected<StringRef> SymbolNameOrErr = Symbol.getName();
+  if (!SymbolNameOrErr)
+    return SymbolNameOrErr.takeError();
+  StringRef SymbolName = *SymbolNameOrErr;
+
+  uint32_t ELFSymIdx =
+      Obj.isELF() ? ELFSymbolRef(Symbol).getRawDataRefImpl().d.b : 0;
   Expected<section_iterator> Sec = Symbol.getSection();
-  if (!Sec || Obj.section_end() == *Sec)
+  if (!Sec || Obj.section_end() == *Sec) {
+    if (Obj.isELF()) {
+      // Store the (index, filename) pair for a file symbol.
+      ELFSymbolRef ESym(Symbol);
+      if (ESym.getELFType() == ELF::STT_FILE)
+        FileSymbols.emplace_back(ELFSymIdx, SymbolName);
+    }
     return Error::success();
+  }
 
   Expected<SymbolRef::Type> SymbolTypeOrErr = Symbol.getType();
   if (!SymbolTypeOrErr)
     return SymbolTypeOrErr.takeError();
   SymbolRef::Type SymbolType = *SymbolTypeOrErr;
   if (Obj.isELF()) {
     // Allow function and data symbols. Additionally allow STT_NONE, which are
     // common for functions defined in assembly.
if (OpdExtractor) {
     // function descriptors. The first word of the descriptor is a pointer to
     // the function's code.
     // For the purposes of symbolization, pretend the symbol's address is that
     // of the function's code, not the descriptor.
     uint64_t OpdOffset = SymbolAddress - OpdAddress;
     if (OpdExtractor->isValidOffsetForAddress(OpdOffset))
       SymbolAddress = OpdExtractor->getAddress(&OpdOffset);
   }
-  Expected<StringRef> SymbolNameOrErr = Symbol.getName();
-  if (!SymbolNameOrErr)
-    return SymbolNameOrErr.takeError();
-  StringRef SymbolName = *SymbolNameOrErr;
   // Mach-O symbol table names have leading underscore, skip it.
   if (Module->isMachO() && !SymbolName.empty() && SymbolName[0] == '_')
     SymbolName = SymbolName.drop_front();
 
-  SymbolDesc SD = {SymbolAddress, SymbolSize};
-
+  if (Obj.isELF() && ELFSymbolRef(Symbol).getBinding() != ELF::STB_LOCAL)
+    ELFSymIdx = 0;
+  SymbolDesc SD = {SymbolAddress, SymbolSize, SymbolName, ELFSymIdx};
   // DATA command symbolizes just ST_Data (ELF STT_OBJECT) symbols as an
   // optimization. Treat everything else (e.g. ELF STT_NOTYPE, STT_FUNC and
   // STT_GNU_IFUNC) as function symbols which can be used to symbolize
   // addresses.
   if (SymbolType == SymbolRef::ST_Data)
-    Objects.emplace_back(SD, SymbolName);
+    Objects.push_back(SD);
   else
-    Functions.emplace_back(SD, SymbolName);
+    Functions.push_back(SD);
   return Error::success();
 }
 
 // Return true if this is a 32-bit x86 PE COFF module.
 bool SymbolizableObjectFile::isWin32Module() const {
   auto *CoffObject = dyn_cast<COFFObjectFile>(Module);
   return CoffObject && CoffObject->getMachine() == COFF::IMAGE_FILE_MACHINE_I386;
 }
 
 uint64_t SymbolizableObjectFile::getModulePreferredBase() const {
   if (auto *CoffObject = dyn_cast<COFFObjectFile>(Module))
     return CoffObject->getImageBase();
   return 0;
 }
 
-bool SymbolizableObjectFile::getNameFromSymbolTable(SymbolRef::Type Type,
-                                                    uint64_t Address,
-                                                    std::string &Name,
-                                                    uint64_t &Addr,
-                                                    uint64_t &Size) const {
+bool SymbolizableObjectFile::getNameFromSymbolTable(
+    SymbolRef::Type Type, uint64_t Address, std::string &Name, uint64_t &Addr,
+    uint64_t &Size, std::string &FileName) const {
   const auto &Symbols = Type == SymbolRef::ST_Function ? Functions : Objects;
-  std::pair<SymbolDesc, StringRef> SD{{Address, UINT64_C(-1)}, StringRef()};
+  SymbolDesc SD{Address, UINT64_C(-1), StringRef(), 0};
   auto SymbolIterator = llvm::upper_bound(Symbols, SD);
   if (SymbolIterator == Symbols.begin())
     return false;
   --SymbolIterator;
-  if (SymbolIterator->first.Size != 0 &&
-      SymbolIterator->first.Addr + SymbolIterator->first.Size <= Address)
+  if (SymbolIterator->Size != 0 &&
+      SymbolIterator->Addr + SymbolIterator->Size <= Address)
     return false;
-  Name = SymbolIterator->second.str();
-  Addr = SymbolIterator->first.Addr;
-  Size = SymbolIterator->first.Size;
+  Name = SymbolIterator->Name.str();
+  Addr = SymbolIterator->Addr;
+  Size = SymbolIterator->Size;
+
+  if (SymbolIterator->ELFLocalSymIdx != 0) {
+    // If this is an ELF local symbol, find the STT_FILE symbol preceding
+    // SymbolIterator to get the filename. The ELF spec requires the STT_FILE
+    // symbol (if present) precedes the other STB_LOCAL symbols for the file.
+    assert(Module->isELF());
+    auto It = llvm::upper_bound(
+        FileSymbols,
+        std::make_pair(SymbolIterator->ELFLocalSymIdx, StringRef()));
+    if (It != FileSymbols.begin())
+      FileName = It[-1].second.str();
+  }
   return true;
 }
 
 bool SymbolizableObjectFile::shouldOverrideWithSymbolTable(
     FunctionNameKind FNKind, bool UseSymbolTable) const {
   // When DWARF is used with -gline-tables-only / -gmlt, the symbol table gives
   // better answers for linkage names than the DIContext. Otherwise, we are
   // probably using PEs and PDBs, and we shouldn't do the override. PE files
SymbolizableObjectFile::symbolizeCode(object::SectionedAddress ModuleOffset,
   if (ModuleOffset.SectionIndex == object::SectionedAddress::UndefSection)
     ModuleOffset.SectionIndex =
         getModuleSectionIndexForAddress(ModuleOffset.Address);
   DILineInfo LineInfo =
       DebugInfoContext->getLineInfoForAddress(ModuleOffset, LineInfoSpecifier);
 
   // Override function name from symbol table if necessary.
   if (shouldOverrideWithSymbolTable(LineInfoSpecifier.FNKind, UseSymbolTable)) {
-    std::string FunctionName;
+    std::string FunctionName, FileName;
     uint64_t Start, Size;
     if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset.Address,
-                               FunctionName, Start, Size)) {
+                               FunctionName, Start, Size, FileName)) {
       LineInfo.FunctionName = FunctionName;
+      if (LineInfo.FileName == DILineInfo::BadString && !FileName.empty())
+        LineInfo.FileName = FileName;
     }
   }
   return LineInfo;
 }
 
 DIInliningInfo SymbolizableObjectFile::symbolizeInlinedCode(
     object::SectionedAddress ModuleOffset,
     DILineInfoSpecifier LineInfoSpecifier, bool UseSymbolTable) const {
   if (ModuleOffset.SectionIndex == object::SectionedAddress::UndefSection)
     ModuleOffset.SectionIndex =
         getModuleSectionIndexForAddress(ModuleOffset.Address);
   DIInliningInfo InlinedContext = DebugInfoContext->getInliningInfoForAddress(
       ModuleOffset, LineInfoSpecifier);
 
   // Make sure there is at least one frame in context.
   if (InlinedContext.getNumberOfFrames() == 0)
     InlinedContext.addFrame(DILineInfo());
 
   // Override the function name in lower frame with name from symbol table.
   if (shouldOverrideWithSymbolTable(LineInfoSpecifier.FNKind, UseSymbolTable)) {
-    std::string FunctionName;
+    std::string FunctionName, FileName;
     uint64_t Start, Size;
     if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset.Address,
-                               FunctionName, Start, Size)) {
-      InlinedContext.getMutableFrame(InlinedContext.getNumberOfFrames() - 1)
-          ->FunctionName = FunctionName;
+                               FunctionName, Start, Size, FileName)) {
+      DILineInfo *LI = InlinedContext.getMutableFrame(
+          InlinedContext.getNumberOfFrames() - 1);
+      LI->FunctionName = FunctionName;
+      if (LI->FileName == DILineInfo::BadString && !FileName.empty())
+        LI->FileName = FileName;
     }
   }
 
   return InlinedContext;
 }
 
 DIGlobal SymbolizableObjectFile::symbolizeData(
     object::SectionedAddress ModuleOffset) const {
   DIGlobal Res;
+  std::string FileName;
   getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset.Address, Res.Name,
-                         Res.Start, Res.Size);
+                         Res.Start, Res.Size, FileName);
   return Res;
 }
 
 std::vector<DILocal> SymbolizableObjectFile::symbolizeFrame(
     object::SectionedAddress ModuleOffset) const {
   if (ModuleOffset.SectionIndex == object::SectionedAddress::UndefSection)
     ModuleOffset.SectionIndex =
         getModuleSectionIndexForAddress(ModuleOffset.Address);

llvm/test/DebugInfo/Symbolize/ELF/symtab-file-conflict.s

+# REQUIRES: x86-registered-target
+## If the filename from the preceding STT_FILE does not match .debug_line,
+## STT_FILE wins. Compilers should not emit such bogus information.
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t
+# RUN: llvm-symbolizer --obj=%t 0 | FileCheck %s
+
+# CHECK:       foo
+# CHECK-NEXT:  1.c:0:0
+
+.file "1.c"
+.file 0 "/tmp" "0.c"
+foo:
+  .loc 0 1 0
+  nop

llvm/test/DebugInfo/Symbolize/ELF/symtab-file.s

 # REQUIRES: x86-registered-target
 ## When locating a local symbol, we can obtain the filename according to the
 ## preceding STT_FILE symbol.
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t
 # RUN: llvm-symbolizer --obj=%t 0 1 2 | FileCheck %s
 
-## TODO Find the preceding STT_FILE symbol as the filename of a local symbol.
 # CHECK:       local1
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  1.c:0:0
 # CHECK-EMPTY:
 # CHECK-NEXT:  local2
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  2.c:0:0
 # CHECK-EMPTY:
 # CHECK-NEXT:  local3
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  3.c:0:0
 # CHECK-EMPTY:
 
 .file "1.c"
 local1:
   nop
 
 .file "2.c"
 local2:
   nop
 
 .file "3.c"
 local3:
   nop

llvm/test/DebugInfo/Symbolize/ELF/symtab-file2.yaml

+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-symbolizer --obj=%t1 0 1 2 | FileCheck %s
+
+## The local symbol has no preceding STT_FILE. Its filename is unavailable.
+# CHECK:       local
+# CHECK-NEXT:  ??:0:0
+# CHECK-EMPTY:
+
+## All local symbols precede all non-local symbols. When there are multiple
+## STT_FILE symbols, we cannot tell which file defines the non-local symbol in
+## question. We could tell if there is only one STT_FILE but in reality there
+## are always more than one file, so implementing the special case is not useful.
+# CHECK-NEXT:  global
+# CHECK-NEXT:  ??:0:0
+# CHECK-EMPTY:
+# CHECK-NEXT:  weak
+# CHECK-NEXT:  ??:0:0
+# CHECK-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .text
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
+    Size:  3
+Symbols:
+  - Name:    local
+    Section: .text
+    Value:   0
+  - Name:    1.c
+    Type:    STT_FILE
+    Index:   SHN_ABS
+  - Name:    global
+    Binding: STB_GLOBAL
+    Section: .text
+    Value:   1
+  - Name:    weak
+    Binding: STB_WEAK
+    Section: .text
+    Value:   2
+
+## If st_name of the STT_FILE symbols is invalid, the symbol name is lost as well.
+## TODO Keep the symbol name.
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-symbolizer --obj=%t2 0 0 2>&1 | FileCheck %s --check-prefix=CHECK2
+
+# CHECK2:      error reading file: st_name (0xffff) is past the end of the string table of size
+# CHECK2-NEXT: ??
+# CHECK2-NEXT: ??:0:0
+# CHECK2-EMPTY:
+# CHECK2-NEXT: ??
+# CHECK2-NEXT: ??:0:0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .text
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
+    Size:  1
+Symbols:
+  - StName:  0xffff
+    Type:    STT_FILE
+    Index:   SHN_ABS
+  - Name:    local
+    Section: .text

llvm/test/DebugInfo/Symbolize/ELF/symtab-ignored.s

 # REQUIRES: x86-registered-target
 ## Ignore STT_SECTION and STT_TLS symbols for .symtab symbolization.
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t
 # RUN: llvm-symbolizer --obj=%t 0 | FileCheck %s
 
 # CHECK:       b
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  1.c:0:0
 # CHECK-EMPTY:
 
 .file "1.c"
 
 .section a,"a",@progbits
 b:
   .reloc ., R_X86_64_NONE, a
 .section c,"a",@progbits
   .reloc ., R_X86_64_NONE, c
 
 .section .tbss,"awT",@nobits
 .globl tls
 tls:

llvm/test/DebugInfo/Symbolize/ELF/symtab-notype.s

 # CHECK-EMPTY:
 
 ## This is a gap.
 # CHECK-NEXT:  ??
 # CHECK-NEXT:  ??:0:0
 # CHECK-EMPTY:
 
 # CHECK-NEXT:  l_notype
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  symtab-notype.s:0:0
 # CHECK-EMPTY:
 
 ## TODO addr2line does not symbolize the last two out-of-bounds addresses.
 # CHECK-NEXT:  l_notype_nosize
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  symtab-notype.s:0:0
 # CHECK-EMPTY:
 # CHECK-NEXT:  l_notype_nosize
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  symtab-notype.s:0:0
 # CHECK-EMPTY:
 # CHECK-NEXT:  l_notype_nosize
-# CHECK-NEXT:  ??:0:0
+# CHECK-NEXT:  symtab-notype.s:0:0
 # CHECK-EMPTY:
 
-## TODO Find the preceding STT_FILE symbol as the filename of a local symbol.
 .file "symtab-notype.s"
 
 .globl _start, g_notype
 _start:
   retq
 
 g_notype:
   nop