[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 ↗

(On Diff #118352)

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 ↗

(On Diff #118352)

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 ↗

(On Diff #118399)

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

109 ↗

(On Diff #118399)

What does this do?

110 ↗

(On Diff #118399)

Remove llvm::

ELF/InputSection.cpp

281 ↗

(On Diff #118399)

get -> create

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

281 ↗

(On Diff #118399)

It needs comment.

309 ↗

(On Diff #118399)

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 ↗

(On Diff #119656)

Die(CU, &Entry)

120 ↗

(On Diff #119656)

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 ↗

(On Diff #119656)

I don't get the meaning of this comment.

ELF/InputSection.cpp

261–265 ↗

(On Diff #119656)

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.

274–275 ↗

(On Diff #119656)

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 ↗

(On Diff #119656)

Done.

123 ↗

(On Diff #119656)

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

261–265 ↗

(On Diff #119656)

I see. Rewrote the comment.

274–275 ↗

(On Diff #119656)

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 ↗

(On Diff #119656)

The have -> There is always only one

ELF/InputFiles.h

204 ↗

(On Diff #120399)

Omit "Data" as DWARF is always data.

220 ↗

(On Diff #120399)

VariableLoc

ELF/InputSection.cpp

264–265 ↗

(On Diff #120399)

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 ↗

(On Diff #120399)

association between location in sourcef iles and machine instructions

->

table from offsets to source locations

290–291 ↗

(On Diff #120399)

For variables, we have to use .debug_info instead.

292 ↗

(On Diff #120399)

Are you sure that functions would never have type STT_OBJECT?

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

292 ↗

(On Diff #120399)

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 ↗

(On Diff #120399)

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 ↗

(On Diff #120399)

Done.

[ruiu]

LGTM

ELF/InputFiles.cpp

87 ↗

(On Diff #120807)

Loop over variable records and insert them to VariableLoc.

95 ↗

(On Diff #120807)

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 ↗

(On Diff #120807)

Get the source filename index for the variable.

105 ↗

(On Diff #120807)

Get the line number on which the variable is declared.

108–109 ↗

(On Diff #120807)

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

287–288 ↗

(On Diff #120807)

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

292–293 ↗

(On Diff #120807)

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

lld/trunk/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 initializeDwarf();
   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>> VariableLoc;
   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

lld/trunk/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>::initializeDwarf() {
   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;
+
+  // Loop over variable records and insert them to VariableLoc.
+  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 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.
+    if (!dwarf::toUnsigned(Die.find(dwarf::DW_AT_external), 0))
+      continue;
+
+    // Get the source filename index for the variable.
+    unsigned File = dwarf::toUnsigned(Die.find(dwarf::DW_AT_decl_file), 0);
+    if (!LT->hasFileAtIndex(File))
+      continue;
+
+    // Get the line number on which the variable is declared.
+    unsigned Line = dwarf::toUnsigned(Die.find(dwarf::DW_AT_decl_line), 0);
+
+    // 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.
+    StringRef Name = dwarf::toString(Die.find(dwarf::DW_AT_name), "");
+    if (!Name.empty())
+      VariableLoc.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]() { initializeDwarf(); });
+
+  // There is always only one CU so it's offset is 0.
+  const DWARFDebugLine::LineTable *LT = DwarfLine->getLineTable(0);
+  if (!LT)
+    return None;
+
+  // Return if we have no debug information about data object.
+  auto It = VariableLoc.find(Name);
+  if (It == VariableLoc.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]() { initializeDwarf(); });
 
   // 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.

lld/trunk/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);
   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);
 

lld/trunk/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:
+// Concatenates arguments to construct a string representing an error 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);
+  // In DWARF, functions and variables are stored to different places.
+  // First, lookup a function for a given offset.
+  if (Optional<DILineInfo> Info = File->getDILineInfo(this, Offset))
+    return createFileLineMsg(Info->FileName, Info->Line);
+
+  // If it failed, lookup again as a variable.
+  if (Optional<std::pair<std::string, unsigned>> FileLine =
+          File->getVariableLoc(Sym.getName()))
+    return createFileLineMsg(FileLine->first, FileLine->second);
 
   // 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 void InputSection::writeTo<ELF32LE>(uint8_t *);
 template void InputSection::writeTo<ELF32BE>(uint8_t *);
 template void InputSection::writeTo<ELF64LE>(uint8_t *);
 template void InputSection::writeTo<ELF64BE>(uint8_t *);
 
 template MergeInputSection::MergeInputSection(ObjFile<ELF32LE> *,
                                               const ELF32LE::Shdr *, StringRef);

lld/trunk/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(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.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(Offset);
 
   if ((Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal) ||
       Config->NoinhibitExec) {
     warn(Msg);
     return false;

lld/trunk/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(D->Value);
-  std::string Src2 = ErrSec->getSrcMsg<ELFT>(ErrOffset);
+  std::string Src2 = ErrSec->getSrcMsg<ELFT>(*Sym, ErrOffset);
   std::string Obj2 = ErrSec->getObjMsg(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>>>            ";

lld/trunk/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
+