[ELF] Fix fetching source line, when file has multiple "AX" sections

[evgeny777]

Summary

Very often object file would have multiple .text.* sections instead of one. This happens if you have comdat groups (use C++ templates) or compile C/C++ source
using -ffunction-sections compiler argument. In this case LLVM DWARF parser needs help fetching source line from .debug_line section, because it is not possible
to distinguish input section given its address (in ELF object file all sections have zero VA).

This patch implements DWARF parser LoadedObjectInfo interface to return fake VA for each section, which is equal to section file offset.

[• rafael]

ELF/InputFiles.cpp

52

Section names don't need to be unique. You need to used the section index.

For an easy example use -fno-unique-section-names.

[evgeny777]

ELF/InputFiles.cpp

52

Unfortunately SectionRef doesn't allow getting it. Probably makes sense to propose patch to ELFObjectFile.h first and get Offset directly from SectionRef

[ruiu]

ELF/InputFiles.cpp

45

Enclose this file-local class definition in an anonymous namespace.

56–60

for (...)
  if (<flip the condition>)
    OffsetMap.insert(...);

[evgeny777]

Addressed review comments

[ruiu]

LGTM

ELF/InputFiles.cpp

48–49

Both functions are small, so I'd inline them here.

56–57

You can use auto or just return static_cast<const ELFSectionRef &>(Sec)->getOffset();.

ELF/InputFiles.h

 // we cache debugging information in order to parse it only once
 // for each object file we link.
 template <class ELFT> class DIHelper {
   typedef typename ELFT::uint uintX_t;
 
 public:
   DIHelper(InputFile *F);
   ~DIHelper();
-  std::string getLineInfo(uintX_t Offset);
+  std::string getLineInfo(InputSectionBase<ELFT> *S, uintX_t Offset);
 
 private:
   std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
 };
 
 // The root class of input files.
 class InputFile {
 public:

ELF/InputFiles.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys::fs;
 
 using namespace lld;
 using namespace lld::elf;
 
 std::vector<InputFile *> InputFile::Pool;
 
-template <class ELFT> DIHelper<ELFT>::DIHelper(elf::InputFile *F) {
+namespace {
+// In ELF object file all section addresses are zero. If we have multiple
+// .text sections (when using -ffunction-section or comdat group) then
+// LLVM DWARF parser will not be able to parse .debug_line correctly, unless
+// we assign each section some unique address. This callback method assigns
+// each section an address equal to its offset in ELF object file.
+class ObjectInfo : public LoadedObjectInfo {
+public:
+  uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override;
+  std::unique_ptr<LoadedObjectInfo> clone() const override;
+};
+}
+
+uint64_t
+ObjectInfo::getSectionLoadAddress(const object::SectionRef &Sec) const {
+
+  const ELFSectionRef &ELFSec = static_cast<const ELFSectionRef &>(Sec);
+  return ELFSec.getOffset();
+}
+
+std::unique_ptr<LoadedObjectInfo> ObjectInfo::clone() const {
+  return std::unique_ptr<LoadedObjectInfo>();
+}
+
+template <class ELFT> DIHelper<ELFT>::DIHelper(InputFile *F) {
   Expected<std::unique_ptr<object::ObjectFile>> Obj =
       object::ObjectFile::createObjectFile(F->MB);
   if (!Obj)
     return;
 
-  DWARFContextInMemory Dwarf(*Obj.get());
+  ObjectInfo ObjInfo;
+  DWARFContextInMemory Dwarf(*Obj.get(), &ObjInfo);
   DwarfLine.reset(new DWARFDebugLine(&Dwarf.getLineSection().Relocs));
   DataExtractor LineData(Dwarf.getLineSection().Data,
                          ELFT::TargetEndianness == support::little,
                          ELFT::Is64Bits ? 8 : 4);
   // 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.
   DwarfLine->getOrParseLineTable(LineData, 0);
 }
 
 template <class ELFT> DIHelper<ELFT>::~DIHelper() {}
 
-template <class ELFT> std::string DIHelper<ELFT>::getLineInfo(uintX_t Offset) {
+template <class ELFT>
+std::string DIHelper<ELFT>::getLineInfo(InputSectionBase<ELFT> *S,
+                                        uintX_t Offset) {
   if (!DwarfLine)
     return "";
 
   DILineInfo LineInfo;
   DILineInfoSpecifier Spec;
   // The offset to CU is 0 (see DIHelper constructor).
   const DWARFDebugLine::LineTable *LineTbl = DwarfLine->getLineTable(0);
   if (!LineTbl)
     return "";
-  LineTbl->getFileLineInfoForAddress(Offset, nullptr, Spec.FLIKind, LineInfo);
+
+  // Use fake address calcuated by adding section file offset and offset in
+  // section.
+  // See comments for ObjectInfo class
+  LineTbl->getFileLineInfoForAddress(S->Offset + Offset, nullptr, Spec.FLIKind,
+                                     LineInfo);
   return LineInfo.Line != 0
              ? LineInfo.FileName + " (" + std::to_string(LineInfo.Line) + ")"
              : "";
 }
 
 // Deletes all InputFile instances created so far.
 void InputFile::freePool() {
   // Files are freed in reverse order so that files created

ELF/InputSection.h

protected:
   typedef typename ELFT::uint uintX_t;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
 public:
   // These corresponds to the fields in Elf_Shdr.
   uintX_t Flags;
+  uintX_t Offset = 0;
   uintX_t Entsize;
   uint32_t Type;
   uint32_t Link;
   uint32_t Info;
 
   InputSectionBase()
       : InputSectionData(Regular, "", ArrayRef<uint8_t>(), false, false),
         Repl(this) {}

ELF/InputSection.cpp

 }
 
 template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Hdr, StringRef Name,
                                          Kind SectionKind)
     : InputSectionBase(File, Hdr->sh_flags, Hdr->sh_type, Hdr->sh_entsize,
                        Hdr->sh_link, Hdr->sh_info, Hdr->sh_addralign,
-                       getSectionContents(File, Hdr), Name, SectionKind) {}
+                       getSectionContents(File, Hdr), Name, SectionKind) {
+  this->Offset = Hdr->sh_offset;
+}
 
 template <class ELFT> size_t InputSectionBase<ELFT>::getSize() const {
   if (auto *D = dyn_cast<InputSection<ELFT>>(this))
     if (D->getThunksSize() > 0)
       return D->getThunkOff() + D->getThunksSize();
   return Data.size();
 }
 

ELF/Relocations.cpp

 }
 
 template <class ELFT>
 static std::string getLocation(SymbolBody &Sym, InputSectionBase<ELFT> &S,
                                typename ELFT::uint Offset) {
   ObjectFile<ELFT> *File = S.getFile();
 
   // First check if we can get desired values from debugging information.
-  std::string LineInfo = File->getDIHelper()->getLineInfo(Offset);
+  std::string LineInfo = File->getDIHelper()->getLineInfo(&S, Offset);
   if (!LineInfo.empty())
     return LineInfo;
 
   // If don't have STT_FILE typed symbol in object file then
   // use object file name.
   std::string SrcFile = File->SourceFile;
   if (SrcFile.empty())
     SrcFile = Sym.File ? getFilename(Sym.File) : getFilename(File);

test/ELF/Inputs/undef-debug.s

 .file 1 "undef-debug.s"
 .loc 1 3
         .quad zed3
+
+.section .text.1,"ax"
+.loc 1 7
+        .quad zed4
+
+.section .text.2,"ax"
+.loc 1 11
+        .quad zed5

test/ELF/undef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef-debug.s -o %t3.o
 # RUN: llvm-ar rc %t2.a %t2.o
 # RUN: not ld.lld %t.o %t2.a %t3.o -o %t.exe 2>&1 | FileCheck %s
 # RUN: not ld.lld -pie %t.o %t2.a %t3.o -o %t.exe 2>&1 | FileCheck %s
 # CHECK: error: undef.s (.text+0x1): undefined symbol 'foo'
 # CHECK: error: undef.s (.text+0x6): undefined symbol 'bar'
 # CHECK: error: undef.s (.text+0x10): undefined symbol 'foo(int)'
 # CHECK: error: {{.*}}2.a({{.*}}.o) (.text+0x0): undefined symbol 'zed2'
 # CHECK: error: undef-debug.s (3): undefined symbol 'zed3'
+# CHECK: error: undef-debug.s (7): undefined symbol 'zed4'
+# CHECK: error: undef-debug.s (11): undefined symbol 'zed5'
 
 # RUN: not ld.lld %t.o %t2.a -o %t.exe -no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO-DEMANGLE %s
 # NO-DEMANGLE: error: undef.s (.text+0x10): undefined symbol '_Z3fooi'
 
 .file "undef.s"
 
   .globl _start
 _start:
   call foo
   call bar
   call zed1
   call _Z3fooi