[ELF] - Teach LLD to report line numbers for data symbols.

[grimar]

Summary

Currently LLD is unable to report line number when reporting duplicate
declaration of some variable.

That happens because for extracting line information we always use .debug_line section
content which describes mapping from machine instructions to source file locations,
what does not help for variables as does not describe them.

In this patch I am taking the approproate information about data symbol locations
from the .debug_info section.

It is PR34826.

[dblaikie]

ELF/InputFiles.cpp

91

Why are the children being visited here? the 'dies' collection in the outer loop should visit all the DIEs, right?

[grimar]

• Fixed issue found by David.

ELF/InputFiles.cpp

91

Ah, you right, my mistake. Thanks !

[grimar]

• Removed dead method, simplified testcase.

[ruiu]

Some parts of lld's source code is quite hard to understand now as an accumulated result of numerous patches. I'm trying to fix it now, so please spend a bit more time too to improve code quality so that it is understandable for future readers.

ELF/InputFiles.cpp

99

Skip something ... skip other thing... and now what? This block needs comment too.

109

What does this do?

110

Remove llvm::

ELF/InputSection.cpp

264

get -> create

(Unless it is an accessor, "get" is not a good prefix.)

264

It needs comment.

293

Remove llvm::.

test/ELF/Inputs/conflict-debug-variable.s

1 ↗

(On Diff #118399)

I don't think we want to have this machine-generated assembly in the test directory. It is hard to verify/edit. Can you do this with llvm-as?

test/ELF/conflict.s

45 ↗

(On Diff #118399)

Please create a new test file.

[grimar]

• Addressed review comments.

test/ELF/Inputs/conflict-debug-variable.s

1 ↗

(On Diff #118399)

Problem to do that is next. There is a difference in debug information produced by gcc and clang.

clang encodes variables names using DW_FORM_strp (represents an offset in .debug_str):

0x0000001e:   DW_TAG_variable [2]  
                DW_AT_name [DW_FORM_strp]	( .debug_str[0x00000048] = "foo")
                DW_AT_type [DW_FORM_ref4]	(cu + 0x0033 => {0x00000033})
                DW_AT_external [DW_FORM_flag_present]	(true)
                DW_AT_decl_file [DW_FORM_data1]	("/home/umb/tests/566_duplicatesym/1.c")
                DW_AT_decl_line [DW_FORM_data1]	(1)
                DW_AT_location [DW_FORM_exprloc]	(DW_OP_addr 0x0)

gcc places string in place using DW_FORM_string:

0x0000001d:   DW_TAG_variable [2]  
                 DW_AT_name [DW_FORM_string]	("foo")
                 DW_AT_decl_file [DW_FORM_data1]	("/home/umb/tests/566_duplicatesym/1.c")
                 DW_AT_decl_line [DW_FORM_data1]	(1)
                 DW_AT_type [DW_FORM_ref4]	(cu + 0x0032 => {0x00000032})
                DW_AT_external [DW_FORM_flag_present]	(true)
                 DW_AT_location [DW_FORM_exprloc]	(DW_OP_addr 0x0)

We want to support both ways, and this patch supports only first one, because our LLDDwarfObj
does not provide .debug_str section for DWARF parsers yet.

I tried to use llvm-as + llc and found no way to make output to use gcc way (DW_FORM_string for name attribute).
(used clang -S -emit-llvm -g to produce IR). I am not sure is it possible ? Seems - not.
I think clang has no flags to drop use of .debug_str.

I am going to implement support for DW_FORM_strp (clang way) after this patch be landed, but we need testcases
for both ways I believe. For following patch I can use llvm-as.

I updated this testcase so it should be more readable. It also should be no need to edit it in future I think.

[ruiu]

test/ELF/Inputs/conflict-debug-variable.s

1 ↗

(On Diff #118399)

I'm confused. You are saying that this patch supports only the first one (which is DW_FORM_strp and that's what clang generates), but you are also saying that you will implement a DW_FORM_strp support after this patch. Which is correct?

[grimar]

Sorry, I wanted to say "We want to support both ways, and this patch supports only second one, because ...", so it supports DW_FORM_string.

[grimar]

Ping.

• Rebased.
• Added detailed comments for DWARF data in testcase.

[ruiu]

ELF/InputFiles.cpp

90

Die(CU, &Entry)

120

Data doesn't feel quite right -- for example, an unnamed region of a section contains data, but that wasn't something you are thinking about when you wrote this function. Variable is better.

123

I don't get the meaning of this comment.

ELF/InputSection.cpp

264–279

This comment is not quite right, because it returns a string similar to the example only when you give a pathname and a line number.

Your comment gives a false impression that it always return a string consisting with a pathname and a line number. That is not true, because it is not really a property of this function but a property of a caller of this function. What this function does is just blindly concatenating strings.

287–288

What is "this", and what do you mean by "normally"?

I'd keep the original comment

// This function is intended to be used for constructing an error message. 
// The returned message looks like this:
//
//   foo.c:42 (/home/alice/possibly/very/long/path/foo.c:42)
//
//  Returns an empty string if there's no way to get line info.

[grimar]

• Addressed review comments.

ELF/InputFiles.cpp

90

Done.

123

It is the same as:
https://github.com/llvm-mirror/lld/blob/master/ELF/InputFiles.cpp#L77

We always have one compilation unit here, so offset is always 0.
I supposed it is fine because we have equal comment here:
https://github.com/llvm-mirror/lld/blob/master/ELF/InputFiles.cpp#L90

I extended this comment.

ELF/InputSection.cpp

264–279

I see. Rewrote the comment.

287–288

Restored original comment.
I used word "normally" because when no debug information is available, it tries
to take information about location from STT_FILE symbol.
So if I would omit "normally", it would be not entirely correct.

[ruiu]

ELF/InputFiles.cpp

123

The have -> There is always only one

ELF/InputFiles.h

204

Omit "Data" as DWARF is always data.

220

VariableLoc

ELF/InputSection.cpp

264–265

Function -> "A function" or "this function"

But maybe it is better to omit the subject.

// Concatenates arguments to construct a string representing an error location.

289

association between location in sourcef iles and machine instructions

->

table from offsets to source locations

290–291

For variables, we have to use .debug_info instead.

292

Are you sure that functions would never have type STT_OBJECT?

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

292

It's interesting. Specification says functions and other executable code should be of type STT_FUNC:
http://www.sco.com/developers/gabi/2000-07-17/ch4.symtab.html
So at least it does not seem correct.

At the same time it looks possible to do that:

.section .text.fn,"ax",@progbits,unique,0
.globl fn
.type fn,@object
fn:
 nop

.section .text.fn2,"ax",@progbits,unique,0
.globl fn2
.type fn2,@function
fn2:
 callq fn@PLT

And you'll get

4: 0000000000400079     0 FUNC    GLOBAL DEFAULT    1 fn2
7: 0000000000400078     0 OBJECT  GLOBAL DEFAULT    1 fn

We probably can fallback to always use .debug_line:

if (Sym.Type == STT_OBJECT)
  if (Optional<std::pair<std::string, unsigned>> FileLine =
          File->getVariableLoc(Sym.getName()))
    return createFileLineMsg(FileLine->first, FileLine->second);

if (Optional<DILineInfo> Info = File->getDILineInfo(this, Offset))
  return createFileLineMsg(Info->FileName, Info->Line);

At least such behavior does not seem harmful for me.
Do you think we should ? (I am not sure because with assembly it is possible
to do many things, and particulary this one seems violates ELF spec, not sure we
should even think about supporting that until it is reported useful).

[ruiu]

ELF/InputSection.cpp

292

Well, I think what I was trying to say is that we don't need to think about it too deeply. Why don't you just attempt both? First, try to get line info as a function, and if it fails, try as a variable.

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

292

Done.

[ruiu]

LGTM

ELF/InputFiles.cpp

87

Loop over variable records and insert them to VariableLoc.

95

Skip if a local variable because we don't need them for generating error messages. In general, only non-local symbols can fail to be linked.

99–100

Get the source filename index for the variable.

105

Get the line number on which the variable is declared.

108–109

Get the name of the variable and add the collected information to VariableLoc. Usually Name is non-empty, but it can be empty if the input object file lacks some debug info.

ELF/InputSection.cpp

288–299

// In DWARF, functions and variables are stored to different places. First, lookup a function for a given offset.

293–294

// If it failed, lookup again as a variable.

ELF/InputFiles.h

SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
     return getSymbolBody(SymIndex);
   }
 
   // Returns source line information for a given offset.
   // If no information is available, returns "".
   std::string getLineInfo(InputSectionBase *S, uint64_t Offset);
   llvm::Optional<llvm::DILineInfo> getDILineInfo(InputSectionBase *, uint64_t);
+  llvm::Optional<std::pair<std::string, unsigned>> getVariableLoc(StringRef Name);
 
   // MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
   uint32_t MipsGp0 = 0;
 
   // Name of source file obtained from STT_FILE symbol value,
   // or empty string if there is no such symbol in object file
   // symbol table.
   StringRef SourceFile;
 
 private:
   void
   initializeSections(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
   void initializeSymbols();
-  void initializeDwarfLine();
+  void initializeDwarfData();
   InputSectionBase *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase *createInputSection(const Elf_Shdr &Sec);
   StringRef getSectionName(const Elf_Shdr &Sec);
 
   bool shouldMerge(const Elf_Shdr &Sec);
   SymbolBody *createSymbolBody(const Elf_Sym *Sym);
 
   // .shstrtab contents.
   StringRef SectionStringTable;
 
   // Debugging information to retrieve source file and line for error
   // reporting. Linker may find reasonable number of errors in a
   // single object file, so we cache debugging information in order to
   // parse it only once for each object file we link.
   std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
+  llvm::DenseMap<StringRef, std::pair<unsigned, unsigned>> DataObjectsLoc;
   llvm::once_flag InitDwarfLine;
 };
 
 // LazyObjFile is analogous to ArchiveFile in the sense that
 // the file contains lazy symbols. The difference is that
 // LazyObjFile wraps a single file instead of multiple files.
 //
 // This class is used for --start-lib and --end-lib options which

ELF/InputFiles.cpp

Optional<MemoryBufferRef> elf::readFile(StringRef Path) {
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   if (Tar)
     Tar->append(relativeToRoot(Path), MBRef.getBuffer());
   return MBRef;
 }
 
-template <class ELFT> void ObjFile<ELFT>::initializeDwarfLine() {
+template <class ELFT> void ObjFile<ELFT>::initializeDwarfData() {
   DWARFContext Dwarf(make_unique<LLDDwarfObj<ELFT>>(this));
   const DWARFObject &Obj = Dwarf.getDWARFObj();
   DwarfLine.reset(new DWARFDebugLine);
   DWARFDataExtractor LineData(Obj, Obj.getLineSection(), Config->IsLE,
                               Config->Wordsize);
 
   // The second parameter is offset in .debug_line section
   // for compilation unit (CU) of interest. We have only one
   // CU (object file), so offset is always 0.
+  const DWARFDebugLine::LineTable *LT =
       DwarfLine->getOrParseLineTable(LineData, 0);
+
+  // Return if there is no debug information about CU available.
+  if (!Dwarf.getNumCompileUnits())
+    return;
+
+  // Get information about global variables location.
+  DWARFCompileUnit *CU = Dwarf.getCompileUnitAtIndex(0);
+  for (const auto &Entry : CU->dies()) {
+    DWARFDie Die(CU, &Entry);
+    // Skip all tags that are not variables.
+    if (Die.getTag() != dwarf::DW_TAG_variable)
+      continue;
+
+    // Skip variables that are invisible outside the compilation unit.
+    if (!dwarf::toUnsigned(Die.find(dwarf::DW_AT_external), 0))
+      continue;
+
+    // Take file number in the line number information table. Skip if
+    // no source file is available.
+    unsigned File = dwarf::toUnsigned(Die.find(dwarf::DW_AT_decl_file), 0);
+    if (!LT->hasFileAtIndex(File))
+      continue;
+
+    // Take source line number where declared object appears.
+    unsigned Line = dwarf::toUnsigned(Die.find(dwarf::DW_AT_decl_line), 0);
+
+    // Take the name of variable. Ignore it if no name available, it can
+    // happen if some debug information is missing or corrupted.
+    StringRef Name = dwarf::toString(Die.find(dwarf::DW_AT_name), "");
+    if (!Name.empty())
+      DataObjectsLoc.insert({Name, {File, Line}});
+  }
+}
+
+// Returns the pair of file name and line number describing location of data
+// object (variable, array, etc) definition.
+template <class ELFT>
+Optional<std::pair<std::string, unsigned>>
+ObjFile<ELFT>::getVariableLoc(StringRef Name) {
+  llvm::call_once(InitDwarfLine, [this]() { initializeDwarfData(); });
+
+  // The have single CU so it's offset is always 0.
+  const DWARFDebugLine::LineTable *LT = DwarfLine->getLineTable(0);
+  if (!LT)
+    return None;
+
+  // Return if we have no debug information about data object.
+  auto It = DataObjectsLoc.find(Name);
+  if (It == DataObjectsLoc.end())
+    return None;
+
+  // Take file name string from line table.
+  std::string FileName;
+  if (!LT->getFileNameByIndex(
+          It->second.first /* File */, nullptr,
+          DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FileName))
+    return None;
+
+  return std::make_pair(FileName, It->second.second /*Line*/);
 }
 
 // Returns source line information for a given offset
 // using DWARF debug info.
 template <class ELFT>
 Optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(InputSectionBase *S,
                                                   uint64_t Offset) {
-  llvm::call_once(InitDwarfLine, [this]() { initializeDwarfLine(); });
+  llvm::call_once(InitDwarfLine, [this]() { initializeDwarfData(); });
 
   // The offset to CU is 0.
   const DWARFDebugLine::LineTable *Tbl = DwarfLine->getLineTable(0);
   if (!Tbl)
     return None;
 
   // Use fake address calcuated by adding section file offset and offset in
   // section. See comments for ObjectInfo class.

ELF/InputSection.h

public:
 
   // Compilers emit zlib-compressed debug sections if the -gz option
   // is given. This function checks if this section is compressed, and
   // if so, decompress in memory.
   void maybeUncompress();
 
   // Returns a source location string. Used to construct an error message.
   template <class ELFT> std::string getLocation(uint64_t Offset);
-  template <class ELFT> std::string getSrcMsg(uint64_t Offset);
+  template <class ELFT> std::string getSrcMsg(const SymbolBody &Sym, uint64_t Offset);
   template <class ELFT> std::string getObjMsg(uint64_t Offset);
 
   // Each section knows how to relocate itself. These functions apply
   // relocations, assuming that Buf points to this section's copy in
   // the mmap'ed output buffer.
   template <class ELFT> void relocate(uint8_t *Buf, uint8_t *BufEnd);
   void relocateAlloc(uint8_t *Buf, uint8_t *BufEnd);
 

ELF/InputSection.cpp

if (auto *D = dyn_cast<DefinedRegular>(B))
       if (D->Section == this && D->Type == STT_FUNC)
         if (D->Value <= Offset && Offset < D->Value + D->Size)
           return SrcFile + ":(function " + toString(*D) + ")";
 
   // If there's no symbol, print out the offset in the section.
   return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
 }
 
-// Returns a source location string. This function is intended to be
-// used for constructing an error message. The returned message looks
-// like this:
+// Function concatenates Path and Line provided. It is used for
+// constructing error messages containing source location.
+static std::string createFileLineMsg(StringRef Path, unsigned Line) {
+  std::string Filename = path::filename(Path);
+  std::string Lineno = ":" + std::to_string(Line);
+  if (Filename == Path)
+    return Filename + Lineno;
+  return Filename + Lineno + " (" + Path.str() + Lineno + ")";
+}
+
+// This function is intended to be used for constructing an error message.
+// The returned message looks like this:
 //
 //   foo.c:42 (/home/alice/possibly/very/long/path/foo.c:42)
 //
-// Returns an empty string if there's no way to get line info.
-template <class ELFT> std::string InputSectionBase::getSrcMsg(uint64_t Offset) {
+//  Returns an empty string if there's no way to get line info.
+template <class ELFT>
+std::string InputSectionBase::getSrcMsg(const SymbolBody &Sym,
+                                        uint64_t Offset) {
   // Synthetic sections don't have input files.
   ObjFile<ELFT> *File = getFile<ELFT>();
   if (!File)
     return "";
 
-  Optional<DILineInfo> Info = File->getDILineInfo(this, Offset);
+  // We want to get location string here. For functions we take information from
+  // .debug_line which contains association between location in source files and
+  // machine instuctions. But for data objects we have to scan DIEs in .debug_info
+  // which describes variables and their locations.
+  if (Sym.Type == STT_OBJECT) {
+    if (Optional<std::pair<std::string, unsigned>> FileLine =
+            File->getVariableLoc(Sym.getName()))
+      return createFileLineMsg(FileLine->first, FileLine->second);
+  } else if (Optional<DILineInfo> Info = File->getDILineInfo(this, Offset)) {
+    return createFileLineMsg(Info->FileName, Info->Line);
+  }
 
   // File->SourceFile contains STT_FILE symbol, and that is a last resort.
-  if (!Info)
-    return File->SourceFile;
-
-  std::string Path = Info->FileName;
-  std::string Filename = path::filename(Path);
-  std::string Lineno = ":" + std::to_string(Info->Line);
-  if (Filename == Path)
-    return Filename + Lineno;
-  return Filename + Lineno + " (" + Path + Lineno + ")";
 }
 
 // Returns a filename string along with an optional section name. This
 // function is intended to be used for constructing an error
 // message. The returned message looks like this:
 //
 //   path/to/foo.o:(function bar)
 //

 template InputSection::InputSection(ObjFile<ELF64BE> *, const ELF64BE::Shdr *,
                                     StringRef);
 
 template std::string InputSectionBase::getLocation<ELF32LE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF32BE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t);
 
-template std::string InputSectionBase::getSrcMsg<ELF32LE>(uint64_t);
-template std::string InputSectionBase::getSrcMsg<ELF32BE>(uint64_t);
-template std::string InputSectionBase::getSrcMsg<ELF64LE>(uint64_t);
-template std::string InputSectionBase::getSrcMsg<ELF64BE>(uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF32LE>(const SymbolBody &,
+                                                          uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF32BE>(const SymbolBody &,
+                                                          uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF64LE>(const SymbolBody &,
+                                                          uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF64BE>(const SymbolBody &,
+                                                          uint64_t);
 
 template std::string InputSectionBase::getObjMsg<ELF32LE>(uint64_t);
 template std::string InputSectionBase::getObjMsg<ELF32BE>(uint64_t);
 template std::string InputSectionBase::getObjMsg<ELF64LE>(uint64_t);
 template std::string InputSectionBase::getObjMsg<ELF64BE>(uint64_t);
 
 template void InputSection::writeTo<ELF32LE>(uint8_t *);
 template void InputSection::writeTo<ELF32BE>(uint8_t *);

ELF/Relocations.cpp

 // >>> defined in /home/alice/src/foo.o
 // >>> referenced by bar.c:12 (/home/alice/src/bar.c:12)
 // >>>               /home/alice/src/bar.o:(.text+0x1)
 template <class ELFT>
 static std::string getLocation(InputSectionBase &S, const SymbolBody &Sym,
                                uint64_t Off) {
   std::string Msg =
       "\n>>> defined in " + toString(Sym.getFile()) + "\n>>> referenced by ";
-  std::string Src = S.getSrcMsg<ELFT>(Off);
+  std::string Src = S.getSrcMsg<ELFT>(Sym, Off);
   if (!Src.empty())
     Msg += Src + "\n>>>               ";
   return Msg + S.getObjMsg<ELFT>(Off);
 }
 
 // This is a MIPS-specific rule.
 //
 // In case of MIPS GP-relative relocations always resolve to a definition
static bool maybeReportUndefined(SymbolBody &Sym, InputSectionBase &Sec,
   bool CanBeExternal = Sym.symbol()->computeBinding() != STB_LOCAL &&
                        Sym.getVisibility() == STV_DEFAULT;
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore && CanBeExternal)
     return false;
 
   std::string Msg =
       "undefined symbol: " + toString(Sym) + "\n>>> referenced by ";
 
-  std::string Src = Sec.getSrcMsg<ELFT>(Offset);
+  std::string Src = Sec.getSrcMsg<ELFT>(Sym, Offset);
   if (!Src.empty())
     Msg += Src + "\n>>>               ";
   Msg += Sec.getObjMsg<ELFT>(Offset);
 
   if ((Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal) ||
       Config->NoinhibitExec) {
     warn(Msg);
     return false;

ELF/SymbolTable.cpp

static void reportDuplicate(SymbolBody *Sym, InputSectionBase *ErrSec,
   // Construct and print an error message in the form of:
   //
   //   ld.lld: error: duplicate symbol: foo
   //   >>> defined at bar.c:30
   //   >>>            bar.o (/home/alice/src/bar.o)
   //   >>> defined at baz.c:563
   //   >>>            baz.o in archive libbaz.a
   auto *Sec1 = cast<InputSectionBase>(D->Section);
-  std::string Src1 = Sec1->getSrcMsg<ELFT>(D->Value);
+  std::string Src1 = Sec1->getSrcMsg<ELFT>(*Sym, D->Value);
   std::string Obj1 = Sec1->getObjMsg<ELFT>(D->Value);
-  std::string Src2 = ErrSec->getSrcMsg<ELFT>(ErrOffset);
+  std::string Src2 = ErrSec->getSrcMsg<ELFT>(*Sym, ErrOffset);
   std::string Obj2 = ErrSec->getObjMsg<ELFT>(ErrOffset);
 
   std::string Msg = "duplicate symbol: " + toString(*Sym) + "\n>>> defined at ";
   if (!Src1.empty())
     Msg += Src1 + "\n>>>            ";
   Msg += Obj1 + "\n>>> defined at ";
   if (!Src2.empty())
     Msg += Src2 + "\n>>>            ";

test/ELF/conflict-debug-variable.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: llvm-dwarfdump %t.o | FileCheck -check-prefix=INPUT %s
+# RUN: not ld.lld %t.o %t.o -o %t 2>&1 | FileCheck %s
+
+# INPUT:     .debug_info contents:
+# INPUT:       DW_TAG_variable
+# INPUT-NEXT:    DW_AT_name      ("foo")
+# INPUT-NEXT:    DW_AT_decl_file ("1.c")
+# INPUT-NEXT:    DW_AT_decl_line (1)
+# INPUT-NEXT:    DW_AT_type      (cu + 0x0032 "int")
+# INPUT-NEXT:    DW_AT_external  (true)
+# INPUT-NEXT:    DW_AT_location  (DW_OP_addr 0x0)
+# INPUT:       DW_TAG_variable
+# INPUT-NEXT:    DW_AT_name      ("bar")
+# INPUT-NEXT:    DW_AT_decl_file ("1.c")
+# INPUT-NEXT:    DW_AT_decl_line (2)
+# INPUT-NEXT:    DW_AT_type      (cu + 0x0032 "int")
+# INPUT-NEXT:    DW_AT_external  (true)
+# INPUT-NEXT:    DW_AT_location  (DW_OP_addr 0x0)
+
+## Check we use information from .debug_info in messages.
+# CHECK:      duplicate symbol: bar
+# CHECK-NEXT: >>> defined at 1.c:2
+# CHECK-NEXT: >>>            {{.*}}:(bar)
+# CHECK-NEXT: >>> defined at 1.c:2
+# CHECK-NEXT: >>>            {{.*}}:(.data+0x0)
+# CHECK:      duplicate symbol: foo
+# CHECK-NEXT: >>> defined at 1.c:1
+# CHECK-NEXT: >>>            {{.*}}:(foo)
+# CHECK-NEXT: >>> defined at 1.c:1
+# CHECK-NEXT: >>>            {{.*}}:(.bss+0x0)
+
+# Used reduced output from following code and gcc 7.1.0
+# to produce this input file:
+# Source (1.c):
+#  int foo = 0;
+#  int bar = 1;
+# Invocation: g++ -g -S 1.c
+
+.bss
+.globl  foo
+.type  foo, @object
+.size  foo, 4
+foo:
+
+.data
+.globl  bar
+.type  bar, @object
+.size  bar, 4
+bar:
+
+.text
+.file 1 "1.c"
+
+.section  .debug_info,"",@progbits
+  .long  0x4b            # Compile Unit: length = 0x0000004b)
+  .value  0x4            # version = 0x0004
+  .long  0               # abbr_offset = 0x0
+  .byte  0x8             # addr_size = 0x08
+
+  .uleb128 0x1           # DW_TAG_compile_unit [1] *
+  .long  0               # DW_AT_producer [DW_FORM_strp]  ( .debug_str[0x00000000] = )
+  .byte  0x4             # DW_AT_language [DW_FORM_data1]  (DW_LANG_C_plus_plus)
+  .string  "1.c"         # DW_AT_name [DW_FORM_string]  ("1.c")
+  .long  0               # DW_AT_comp_dir [DW_FORM_strp]  ( .debug_str[0x00000000] = )
+  .long  0               # DW_AT_stmt_list [DW_FORM_sec_offset]  (0x00000000)
+                         
+  .uleb128 0x2           # DW_TAG_variable [2]
+  .string  "foo"         # DW_AT_name [DW_FORM_string]  ("foo")
+  .byte  0x1             # DW_AT_decl_file [DW_FORM_data1]  ("1.c")
+  .byte  0x1             # DW_AT_decl_line [DW_FORM_data1]  (1)
+  .long  0x32            # DW_AT_type [DW_FORM_ref4]  (cu + 0x0032 => {0x00000032})
+  .uleb128 0x9           # DW_AT_external [DW_FORM_flag_present]  (true)
+  .byte  0x3             
+  .quad  foo             # DW_AT_location [DW_FORM_exprloc]  (DW_OP_addr 0x0)
+                         
+  .uleb128 0x3           # DW_TAG_base_type [3]
+  .byte  0x4             # DW_AT_byte_size [DW_FORM_data1]  (0x04)
+  .byte  0x5             # DW_AT_encoding [DW_FORM_data1]  (DW_ATE_signed)
+  .string  "int"         # DW_AT_name [DW_FORM_string]  ("int")
+                         
+  .uleb128 0x2           # DW_TAG_variable [2]
+  .string  "bar"         # DW_AT_name [DW_FORM_string]  ("bar")
+  .byte  0x1             # DW_AT_decl_file [DW_FORM_data1]  ("1.c")
+  .byte  0x2             # DW_AT_decl_line [DW_FORM_data1]  (2)
+  .long  0x32            # DW_AT_type [DW_FORM_ref4]  (cu + 0x0032 => {0x00000032})
+  .uleb128 0x9           # DW_AT_external [DW_FORM_flag_present]  (true)
+  .byte  0x3             
+  .quad  bar             # DW_AT_location [DW_FORM_exprloc]  (DW_OP_addr 0x0)
+  .byte  0               # END
+  
+
+.section  .debug_abbrev,"",@progbits
+  .uleb128 0x1   # Abbreviation code.
+  .uleb128 0x11  # DW_TAG_compile_unit
+  
+  .byte  0x1     # ID
+  .uleb128 0x25  # DW_AT_producer, DW_FORM_strp
+  .uleb128 0xe
+  .uleb128 0x13  # DW_AT_language, DW_FORM_data1
+  .uleb128 0xb
+  .uleb128 0x3   # DW_AT_name, DW_FORM_string
+  .uleb128 0x8
+  .uleb128 0x1b  # DW_AT_comp_dir, DW_FORM_strp
+  .uleb128 0xe
+  .uleb128 0x10  # DW_AT_stmt_list, DW_FORM_sec_offset
+  .uleb128 0x17
+  .byte  0
+  .byte  0
+  
+  .uleb128 0x2  # ID
+  .uleb128 0x34 # DW_TAG_variable, DW_CHILDREN_no
+  .byte  0
+  .uleb128 0x3  # DW_AT_name, DW_FORM_string
+  .uleb128 0x8
+  .uleb128 0x3a # DW_AT_decl_file, DW_FORM_data1
+  .uleb128 0xb
+  .uleb128 0x3b # DW_AT_decl_line, DW_FORM_data1
+  .uleb128 0xb
+  .uleb128 0x49 # DW_AT_type, DW_FORM_ref4
+  .uleb128 0x13
+  .uleb128 0x3f # DW_AT_external, DW_FORM_flag_present
+  .uleb128 0x19
+  .uleb128 0x2  # DW_AT_location, DW_FORM_exprloc
+  .uleb128 0x18
+  .byte  0
+  .byte  0
+  
+  .uleb128 0x3  # ID
+  .uleb128 0x24 # DW_TAG_base_type, DW_CHILDREN_no
+  .byte  0
+  .uleb128 0xb  # DW_AT_byte_size, DW_FORM_data1
+  .uleb128 0xb
+  .uleb128 0x3e # DW_AT_encoding, DW_FORM_data1
+  .uleb128 0xb
+  .uleb128 0x3  # DW_AT_name, DW_FORM_string
+  .uleb128 0x8
+  .byte  0
+  .byte  0
+  .byte  0
+