[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

50

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

50

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

43

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

54–58

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

[evgeny777]

Addressed review comments

[ruiu]

LGTM

ELF/InputFiles.cpp

46–47

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

54–55

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

ELF/InputFiles.h

 template <class ELFT>
 llvm::SpecificBumpPtrAllocator<EhInputSection<ELFT>> GAlloc<ELFT>::EHAlloc;
 
 using llvm::object::Archive;
 
 class InputFile;
 class Lazy;
 class SymbolBody;
+template <class ELFT> class ObjectInfo;
 
 // Debugging information helper class. The main purpose is 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.
 template <class ELFT> class DIHelper {
   typedef typename ELFT::uint uintX_t;
 
 public:
-  DIHelper(InputFile *F);
+  DIHelper(elf::ObjectFile<ELFT> *F);
   ~DIHelper();
-  std::string getLineInfo(uintX_t Offset);
+  std::string getLineInfo(InputSectionBase<ELFT> *S, uintX_t Offset);
 
 private:
   std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
+  std::unique_ptr<ObjectInfo<ELFT>> ObjInfo;
 };
 
 // The root class of input files.
 class InputFile {
 public:
   virtual ~InputFile() = default;
 
   enum Kind {

ELF/InputFiles.cpp

 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) {
+// 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.
+template <class ELFT> class elf::ObjectInfo : public LoadedObjectInfo {
+public:
+  ObjectInfo(ObjectFile<ELFT> *F);
+
+  uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override;
+  std::unique_ptr<LoadedObjectInfo> clone() const override;
+
+  DenseMap<StringRef, uint64_t> OffsetMap;
+};
+
+template <class ELFT> elf::ObjectInfo<ELFT>::ObjectInfo(ObjectFile<ELFT> *F) {
+  for (InputSectionBase<ELFT> *S : F->getSections()) {
+    if (!S || S == &InputSectionBase<ELFT>::Discarded)
+      continue;
+
+    OffsetMap.insert({S->Name, S->Offset});
+  }
+}
+
+template <class ELFT>
+uint64_t elf::ObjectInfo<ELFT>::getSectionLoadAddress(
+    const object::SectionRef &Sec) const {
+
+  StringRef Name;
+  if (Sec.getName(Name))
+    return 0;
+
+  auto It = OffsetMap.find(Name);
+  return It == OffsetMap.end() ? 0 : It->second;
+}
+
+template <class ELFT>
+std::unique_ptr<LoadedObjectInfo> elf::ObjectInfo<ELFT>::clone() const {
+  return std::unique_ptr<LoadedObjectInfo>();
+}
+
+template <class ELFT> DIHelper<ELFT>::DIHelper(elf::ObjectFile<ELFT> *F) {
   Expected<std::unique_ptr<object::ObjectFile>> Obj =
       object::ObjectFile::createObjectFile(F->MB);
   if (!Obj)
     return;
 
-  DWARFContextInMemory Dwarf(*Obj.get());
+  ObjInfo.reset(new ObjectInfo<ELFT>(F));
+  DWARFContextInMemory Dwarf(*Obj.get(), ObjInfo.get());
   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