Teach the symbolizer lib symbolize objects directly.

[ychen]

Summary

Currently, the symbolizer lib can only symbolize a file on disk.
This patch teaches the symbolizer lib to symbolize objects.
llvm-objdump needs this to support archive disassembly with source info.

https://bugs.llvm.org/show_bug.cgi?id=41871

[jhenderson]

llvm/test/tools/llvm-objdump/X86/disassemble-archive-with-source.ll

3 ↗

(On Diff #205452)

debuginfo is usually two words (i.e. debug info) or better yet, call it debug data, to avoid confusion with the .debug_info DWARF section.

[ychen]

• update comment

[jhenderson]

So I'm happy with this approach, but I'd like somebody else to confirm that they are too.

[grimar]

I am probably not the right person to accept this, so minor suggestion is below.

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

92 ↗

(On Diff #205678)

I'd simplify.

const auto &I = Modules.find(ModuleName);
if (I != Modules.end())
  return symbolizeCodeCommon(I->second.get(), ModuleOffset);

Expected<SymbolizableModule *> InfoOrErr =
                    createModuleInfo(&Obj, std::move(Context), ModuleName);
if (!InfoOrErr)
  return InfoOrErr.takeError();
return symbolizeCodeCommon(InfoOrErr.get(), ModuleOffset);

[MaskRay]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

92 ↗

(On Diff #205678)

Let's avoid the lifetime extension:

auto I = Modules.find(ModuleName);

const auto &I is a const reference to a temporary iterator. It is odd.

[MaskRay]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

403 ↗

(On Diff #205678)

I think we can split getOrCreateModuleInfo into two halves. The latter half can be reused by this part of code in the new symbolizeCode:

  std::unique_ptr<DIContext> Context =
      DWARFContext::create(Obj, nullptr, DWARFContext::defaultErrorHandler);
/////////// codeview is not supported
  Expected<SymbolizableModule *> InfoOrErr =
      createModuleInfo(&Obj, std::move(Context), ModuleName);
  if (!InfoOrErr)
    return InfoOrErr.takeError();
  Info = InfoOrErr.get();

This way, it may make it easy to add codeview support for archive files is someone cares about it.

(getOrCreateObjectPair handles .gnu_debuglink, but I think we can forget about that for an archive member..

470 ↗

(On Diff #205678)

Nonnullness of Context is obvious.

[ychen]

• address reviewer's comments.

[jhenderson]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

82 ↗

(On Diff #206255)

This TODO seems somewhat arbitrary in this location. Is CodeView supported for other parts of LLVM symbolizer? What would happen if somebody tried to use this bit of code with CodeView, compared with old behaviour?

[ychen]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

82 ↗

(On Diff #206255)

I'm not entirely sure. I know PDB and CodeView are not exactly the same thing. Looks like the name is used interchangeably in this context? COFFObjectFile::getDebugPDBInfo said it is COFF::IMAGE_DEBUG_TYPE_CODEVIEW. If somebody uses this code with CodeView, loadDataForEXE would fail because of Objects.first->getFileName(), symbolizeCode would return error. Old behavior of symbolizeCode(const ObjectFile &Obj, ..) would always create a DWARFContext.

// If this is a COFF object containing PDB info, use a PDBContext to
// symbolize. Otherwise, use DWARF.
if (auto CoffObject = dyn_cast<COFFObjectFile>(Objects.first)) {
  const codeview::DebugInfo *DebugInfo;
  StringRef PDBFileName;
  auto EC = CoffObject->getDebugPDBInfo(DebugInfo, PDBFileName);
  if (!EC && DebugInfo != nullptr && !PDBFileName.empty()) {
    using namespace pdb;
    std::unique_ptr<IPDBSession> Session;
    if (auto Err = loadDataForEXE(PDB_ReaderType::DIA,
                                  Objects.first->getFileName(), Session)) {
      Modules.insert(
          std::make_pair(ModuleName, std::unique_ptr<SymbolizableModule>()));
      // Return along the PDB filename to provide more context
      return createFileError(PDBFileName, std::move(Err));
    }
    Context.reset(new PDBContext(*CoffObject, std::move(Session)));
  }
}

[jhenderson]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

82 ↗

(On Diff #206255)

I'm not comfortable with a loss in functionality versus the previous version, unless the old functionality was broken and wouldn't work anyway. Not knowing enough about how CodeView/PDB work, I'm not sure I can comment much further.

[ychen]

I don't think it's a loss of functionality versus the previous version which creates DWARFContext even for COFF object (not work obviously). This version still does not work for COFF archive but looks a little bit more reasonable. IMHO, we should have no or all support for COFF archive, not partial support. I could either

1. Land the previous version (with the additional check for COFF so users are notified of the lack of support) and revisit COFF archive support later.
2. Support COFF archive file in this patch with the necessary tests.

I would prefer the first choice since one patch for each makes more sense. @MaskRay @jhenderson thoughts?

[MaskRay]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

82 ↗

(On Diff #206255)

This todo (archive not supported) is fine, as long as the normal code path LLVMSymbolizer::symbolizeCode(const std::string &ModuleName, object::SectionedAddress ModuleOffset) below still works.

93 ↗

(On Diff #206255)

Should make sure test/tools/llvm-symbolizer/pdb/ still works.

[jhenderson]

In D63521#1560218, @ychen wrote:

I don't think it's a loss of functionality versus the previous version which creates DWARFContext even for COFF object (not work obviously). This version still does not work for COFF archive but looks a little bit more reasonable. IMHO, we should have no or all support for COFF archive, not partial support. I could either

1. Land the previous version (with the additional check for COFF so users are notified of the lack of support) and revisit COFF archive support later.
2. Support COFF archive file in this patch with the necessary tests.

I would prefer the first choice since one patch for each makes more sense. @MaskRay @jhenderson thoughts?

If we don't support COFF archives already at all (i.e. they don't work under any situation), then I don't think there's a problem that needs solving here, but we should definitely not make things worse. If archives containing COFF with PDBs work as well as before, then I think this is fine. If they no longer work, that's a problem and you should go back to the old behaviour. Beyond that, I don't think you need to fix the world in this patch. You've fixed the problem for DWARF-based debug information, and further improvements can be separate patches. Perhaps best would be to file a separate bug to track the additional cases that are unfixed by this?

[rnk]

I'm pretty sure the PDB symbolization context assumes it has a PE image (EXE or DLL), which it can use to extract the moral equivalent of .gnu_debuglink to find the PDB. That's all handled internally.

Hypothetically, we could change things to read the debug info sections from plain object files before they have been linked, but it's difficult and probably not worth the effort.

[ychen]

Hi @MaskRay, from @rnk 's inputs, seems this is not a common case worth pursuing at least for the moment, is it ok to move forward with the first choice I described?

[MaskRay]

In D63521#1562497, @ychen wrote:

Hi @MaskRay, from @rnk 's inputs, seems this is not a common case worth pursuing at least for the moment, is it ok to move forward with the first choice I described?

My comment on your first version of this patch is about the potential code duplication. Now the codeview concern of the code duplication has been addressed.

The current version doesn't look bad to me. Do you think the initial version is better?

[ychen]

In D63521#1563367, @MaskRay wrote:

In D63521#1562497, @ychen wrote:

Hi @MaskRay, from @rnk 's inputs, seems this is not a common case worth pursuing at least for the moment, is it ok to move forward with the first choice I described?

My comment on your first version of this patch is about the potential code duplication. Now the codeview concern of the code duplication has been addressed.

The current version doesn't look bad to me. Do you think the initial version is better?

The expected client for this new symbolizeCode interface is for archive members and COFF is unlikely to symbolize plain object files for the moment.
I think the concern here the code movement for removing the potential duplication puts some untested code in the path for DWARF. I assume if there is a need for the COFF archive member symbolization we could easily deduplicate the code in the patch for COFF?

[MaskRay]

In D63521#1564998, @ychen wrote:

In D63521#1563367, @MaskRay wrote:

In D63521#1562497, @ychen wrote:

Hi @MaskRay, from @rnk 's inputs, seems this is not a common case worth pursuing at least for the moment, is it ok to move forward with the first choice I described?

My comment on your first version of this patch is about the potential code duplication. Now the codeview concern of the code duplication has been addressed.

The current version doesn't look bad to me. Do you think the initial version is better?

The expected client for this new symbolizeCode interface is for archive members and COFF is unlikely to symbolize plain object files for the moment.
I think the concern here the code movement for removing the potential duplication puts some untested code in the path for DWARF. I assume if there is a need for the COFF archive member symbolization we could easily deduplicate the code in the patch for COFF?

I think you meant "puts some untested code in the path for COFF". That is fine to me.

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

431 ↗

(On Diff #206255)

You can place this block before createModuleInfo to minimize the diff.

[ychen]

• update

[jhenderson]

LGTM, with a couple of nits. Happy with or without them.

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

88 ↗

(On Diff #207601)

It's more common to use *InfoOrErr for Expected, I believe, to get the actual value.

97 ↗

(On Diff #207601)

Ditto.

[MaskRay]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

429 ↗

(On Diff #207601)

Nit: std::error_code

[ychen]

• update

llvm/trunk/include/llvm/DebugInfo/Symbolize/Symbolize.h

public:
 
   LLVMSymbolizer() = default;
   LLVMSymbolizer(const Options &Opts) : Opts(Opts) {}
 
   ~LLVMSymbolizer() {
     flush();
   }
 
+  Expected<DILineInfo> symbolizeCode(const ObjectFile &Obj,
+                                     object::SectionedAddress ModuleOffset);
   Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
                                      object::SectionedAddress ModuleOffset);
   Expected<DIInliningInfo>
   symbolizeInlinedCode(const std::string &ModuleName,
                        object::SectionedAddress ModuleOffset);
   Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
                                    object::SectionedAddress ModuleOffset);
   Expected<std::vector<DILocal>>
   symbolizeFrame(const std::string &ModuleName,
                  object::SectionedAddress ModuleOffset);
   void flush();
 
   static std::string
   DemangleName(const std::string &Name,
                const SymbolizableModule *DbiModuleDescriptor);
 
 private:
   // Bundles together object file with code/data and object file with
   // corresponding debug info. These objects can be the same.
-  using ObjectPair = std::pair<ObjectFile *, ObjectFile *>;
+  using ObjectPair = std::pair<const ObjectFile *, const ObjectFile *>;
+
+  Expected<DILineInfo>
+  symbolizeCodeCommon(SymbolizableModule *Info,
+                      object::SectionedAddress ModuleOffset);
 
   /// Returns a SymbolizableModule or an error if loading debug info failed.
   /// Only one attempt is made to load a module, and errors during loading are
   /// only reported once. Subsequent calls to get module info for a module that
   /// failed to load will return nullptr.
   Expected<SymbolizableModule *>
   getOrCreateModuleInfo(const std::string &ModuleName);
 
+  Expected<SymbolizableModule *>
+  createModuleInfo(const ObjectFile *Obj,
+                   std::unique_ptr<DIContext> Context,
+                   StringRef ModuleName);
+
   ObjectFile *lookUpDsymFile(const std::string &Path,
                              const MachOObjectFile *ExeObj,
                              const std::string &ArchName);
   ObjectFile *lookUpDebuglinkObject(const std::string &Path,
                                     const ObjectFile *Obj,
                                     const std::string &ArchName);
 
   /// Returns pair of pointers to object and debug object.

llvm/trunk/lib/DebugInfo/Symbolize/SymbolizableObjectFile.h

 
 class DataExtractor;
 
 namespace symbolize {
 
 class SymbolizableObjectFile : public SymbolizableModule {
 public:
   static ErrorOr<std::unique_ptr<SymbolizableObjectFile>>
-  create(object::ObjectFile *Obj, std::unique_ptr<DIContext> DICtx);
+  create(const object::ObjectFile *Obj, std::unique_ptr<DIContext> DICtx);
 
   DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
                            FunctionNameKind FNKind,
                            bool UseSymbolTable) const override;
   DIInliningInfo symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
                                       FunctionNameKind FNKind,
                                       bool UseSymbolTable) const override;
   DIGlobal symbolizeData(object::SectionedAddress ModuleOffset) const override;
std::error_code addSymbol(const object::SymbolRef &Symbol,
                             uint64_t SymbolSize,
                             DataExtractor *OpdExtractor = nullptr,
                             uint64_t OpdAddress = 0);
   std::error_code addCoffExportSymbols(const object::COFFObjectFile *CoffObj);
 
   /// Search for the first occurence of specified Address in ObjectFile.
   uint64_t getModuleSectionIndexForAddress(uint64_t Address) const;
 
-  object::ObjectFile *Module;
+  const object::ObjectFile *Module;
   std::unique_ptr<DIContext> DebugInfoContext;
 
   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;
 
     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;
 
-  SymbolizableObjectFile(object::ObjectFile *Obj,
+  SymbolizableObjectFile(const object::ObjectFile *Obj,
                          std::unique_ptr<DIContext> DICtx);
 };
 
 } // end namespace symbolize
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_DEBUGINFO_SYMBOLIZE_SYMBOLIZABLEOBJECTFILE_H

llvm/trunk/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

 
 static DILineInfoSpecifier
 getDILineInfoSpecifier(FunctionNameKind FNKind) {
   return DILineInfoSpecifier(
       DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FNKind);
 }
 
 ErrorOr<std::unique_ptr<SymbolizableObjectFile>>
-SymbolizableObjectFile::create(object::ObjectFile *Obj,
+SymbolizableObjectFile::create(const object::ObjectFile *Obj,
                                std::unique_ptr<DIContext> DICtx) {
   assert(DICtx);
   std::unique_ptr<SymbolizableObjectFile> res(
       new SymbolizableObjectFile(Obj, std::move(DICtx)));
   std::unique_ptr<DataExtractor> OpdExtractor;
   uint64_t OpdAddress = 0;
   // Find the .opd (function descriptor) section if any, for big-endian
   // PowerPC64 ELF.
auto Uniquify = [](std::vector<std::pair<SymbolDesc, StringRef>> &S) {
     S.erase(J, S.end());
   };
   Uniquify(Fs);
   Uniquify(Os);
 
   return std::move(res);
 }
 
-SymbolizableObjectFile::SymbolizableObjectFile(ObjectFile *Obj,
+SymbolizableObjectFile::SymbolizableObjectFile(const ObjectFile *Obj,
                                                std::unique_ptr<DIContext> DICtx)
     : Module(Obj), DebugInfoContext(std::move(DICtx)) {}
 
 namespace {
 
 struct OffsetNamePair {
   uint32_t Offset;
   StringRef Name;

llvm/trunk/lib/DebugInfo/Symbolize/Symbolize.cpp

 #undef IMAGE_FILE_MACHINE_I386
 #endif
 #endif
 
 namespace llvm {
 namespace symbolize {
 
 Expected<DILineInfo>
-LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
+LLVMSymbolizer::symbolizeCodeCommon(SymbolizableModule *Info,
                                     object::SectionedAddress ModuleOffset) {
-  SymbolizableModule *Info;
-  if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
-    Info = InfoOrErr.get();
-  else
-    return InfoOrErr.takeError();
-
   // A null module means an error has already been reported. Return an empty
   // result.
   if (!Info)
     return DILineInfo();
 
   // If the user is giving us relative addresses, add the preferred base of the
   // object to the offset before we do the query. It's what DIContext expects.
   if (Opts.RelativeAddresses)
     ModuleOffset.Address += Info->getModulePreferredBase();
 
   DILineInfo LineInfo = Info->symbolizeCode(ModuleOffset, Opts.PrintFunctions,
                                             Opts.UseSymbolTable);
   if (Opts.Demangle)
     LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info);
   return LineInfo;
 }
 
+Expected<DILineInfo>
+LLVMSymbolizer::symbolizeCode(const ObjectFile &Obj,
+                              object::SectionedAddress ModuleOffset) {
+  StringRef ModuleName = Obj.getFileName();
+  auto I = Modules.find(ModuleName);
+  if (I != Modules.end())
+    return symbolizeCodeCommon(I->second.get(), ModuleOffset);
+
+  std::unique_ptr<DIContext> Context =
+        DWARFContext::create(Obj, nullptr, DWARFContext::defaultErrorHandler);
+  Expected<SymbolizableModule *> InfoOrErr =
+                     createModuleInfo(&Obj, std::move(Context), ModuleName);
+  if (!InfoOrErr)
+    return InfoOrErr.takeError();
+  return symbolizeCodeCommon(*InfoOrErr, ModuleOffset);
+}
+
+Expected<DILineInfo>
+LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
+                              object::SectionedAddress ModuleOffset) {
+  Expected<SymbolizableModule *> InfoOrErr = getOrCreateModuleInfo(ModuleName);
+  if (!InfoOrErr)
+    return InfoOrErr.takeError();
+  return symbolizeCodeCommon(*InfoOrErr, ModuleOffset);
+}
+
 Expected<DIInliningInfo>
 LLVMSymbolizer::symbolizeInlinedCode(const std::string &ModuleName,
                                      object::SectionedAddress ModuleOffset) {
   SymbolizableModule *Info;
   if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
     Info = InfoOrErr.get();
   else
     return InfoOrErr.takeError();
LLVMSymbolizer::getOrCreateObject(const std::string &Path,
   }
   if (Bin->isObject()) {
     return cast<ObjectFile>(Bin);
   }
   return errorCodeToError(object_error::arch_not_found);
 }
 
 Expected<SymbolizableModule *>
+LLVMSymbolizer::createModuleInfo(const ObjectFile *Obj,
+                                 std::unique_ptr<DIContext> Context,
+                                 StringRef ModuleName) {
+  auto InfoOrErr =
+      SymbolizableObjectFile::create(Obj, std::move(Context));
+  std::unique_ptr<SymbolizableModule> SymMod;
+  if (InfoOrErr)
+    SymMod = std::move(*InfoOrErr);
+  auto InsertResult =
+      Modules.insert(std::make_pair(ModuleName, std::move(SymMod)));
+  assert(InsertResult.second);
+  if (std::error_code EC = InfoOrErr.getError())
+    return errorCodeToError(EC);
+  return InsertResult.first->second.get();
+}
+
+Expected<SymbolizableModule *>
 LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
   auto I = Modules.find(ModuleName);
   if (I != Modules.end())
     return I->second.get();
 
   std::string BinaryName = ModuleName;
   std::string ArchName = Opts.DefaultArch;
   size_t ColonPos = ModuleName.find_last_of(':');
if (!EC && DebugInfo != nullptr && !PDBFileName.empty()) {
       }
       Context.reset(new PDBContext(*CoffObject, std::move(Session)));
     }
   }
   if (!Context)
     Context =
         DWARFContext::create(*Objects.second, nullptr,
                              DWARFContext::defaultErrorHandler, Opts.DWPName);
-  auto InfoOrErr =
-      SymbolizableObjectFile::create(Objects.first, std::move(Context));
-  std::unique_ptr<SymbolizableModule> SymMod;
-  if (InfoOrErr)
-    SymMod = std::move(InfoOrErr.get());
-  auto InsertResult = Modules.emplace(ModuleName, std::move(SymMod));
-  assert(InsertResult.second);
-  if (auto EC = InfoOrErr.getError())
-    return errorCodeToError(EC);
-  return InsertResult.first->second.get();
+  return createModuleInfo(Objects.first, std::move(Context), ModuleName);
 }
 
 namespace {
 
 // Undo these various manglings for Win32 extern "C" functions:
 // cdecl       - _foo
 // stdcall     - _foo@12
 // fastcall    - @foo@12

llvm/trunk/test/tools/llvm-objdump/X86/disassemble-archive-with-source.ll

+; This test checks that 'llvm-objdump --source' works with archive files.
+; The reason this test is written in .ll is that showing source code
+; requires the debug data to have the source file path. Since we create
+; the source file ad-hoc in this test, we don't know the path beforehand to
+; create the object and archive.
+
+; RUN: rm -rf %t && mkdir -p %t/subdir && cd %t
+; RUN: echo -e "int foo(int a)\n\n{ return a+1; }" > subdir/a.c
+; RUN: sed -e "s,DIRNAME,%/t/subdir," %s | llc --filetype=obj -mtriple=x86_64-pc-linux -o a.o
+; RUN: llvm-ar rc a.a a.o
+; RUN: rm a.o
+; RUN: llvm-objdump --source a.a | FileCheck %s
+
+; CHECK: { return a+1; }
+
+define i32 @foo(i32 %a) #0 !dbg !8 {
+entry:
+  %a.addr = alloca i32, align 4
+  store i32 %a, i32* %a.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !12, metadata !DIExpression()), !dbg !13
+  %0 = load i32, i32* %a.addr, align 4, !dbg !14
+  %add = add nsw i32 %0, 1, !dbg !14
+  ret i32 %add, !dbg !14
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind optnone sspstrong uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 9.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "a.c", directory: "DIRNAME")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 2}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{!"clang version 9.0.0"}
+!8 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !9, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 1, type: !11)
+!13 = !DILocation(line: 1, scope: !8)
+!14 = !DILocation(line: 3, scope: !8)

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

 
 void SourcePrinter::printSourceLine(raw_ostream &OS,
                                     object::SectionedAddress Address,
                                     StringRef Delimiter) {
   if (!Symbolizer)
     return;
 
   DILineInfo LineInfo = DILineInfo();
-  auto ExpectedLineInfo =
-      Symbolizer->symbolizeCode(Obj->getFileName(), Address);
+  auto ExpectedLineInfo = Symbolizer->symbolizeCode(*Obj, Address);
   if (!ExpectedLineInfo)
     consumeError(ExpectedLineInfo.takeError());
   else
     LineInfo = *ExpectedLineInfo;
 
   if ((LineInfo.FileName == "<invalid>") || LineInfo.Line == 0 ||
       ((OldLineInfo.Line == LineInfo.Line) &&
        (OldLineInfo.FileName == LineInfo.FileName)))