Reduce number of classes by merging DIHelper with ObjectFile.

[ruiu]

Summary

DIHelper is a class having only one member, and ObjectFile has
a unique pointer to a DIHelper. So we can directly have ObjectFile
have the member.

[evgeny777]

LGTM

ELF/InputFiles.cpp

81

This comment should be changed (there is no DIHelper anymore)

ELF/InputFiles.h

 namespace elf {
 
 using llvm::object::Archive;
 
 class InputFile;
 class Lazy;
 class SymbolBody;
 
-// 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();
-  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:
   enum Kind {
     ObjectKind,
     SharedKind,
     LazyObjectKind,
     ArchiveKind,
public:
   template <typename RelT>
   SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
 
-  // DI helper allows manipilating debugging information for this
-  // object file. Used for error reporting.
-  DIHelper<ELFT> *getDIHelper();
+  // Returns source line information for a given offset.
+  // If no information is available, returns "".
+  std::string getLineInfo(InputSectionBase<ELFT> *S, uintX_t Offset);
 
   // Get 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 getMipsGp0() const;
 
   // The number is the offset in the string table. It will be used as the
   // st_name of the symbol.
   std::vector<std::pair<const DefinedRegular<ELFT> *, unsigned>> KeptLocalSyms;
 
   // 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 initializeReverseDependencies();
+  void initializeDWARFDebugLine();
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec,
                                              StringRef SectionStringTable);
 
   bool shouldMerge(const Elf_Shdr &Sec);
   SymbolBody *createSymbolBody(const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
   std::vector<InputSectionBase<ELFT> *> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
   // MIPS .reginfo section defined by this file.
   std::unique_ptr<MipsReginfoInputSection<ELFT>> MipsReginfo;
   // MIPS .MIPS.options section defined by this file.
   std::unique_ptr<MipsOptionsInputSection<ELFT>> MipsOptions;
   // MIPS .MIPS.abiflags section defined by this file.
   std::unique_ptr<MipsAbiFlagsInputSection<ELFT>> MipsAbiFlags;
 
-  std::unique_ptr<DIHelper<ELFT>> DIH;
+  // 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;
 };
 
 // LazyObjectFile is analogous to ArchiveFile in the sense that
 // the file contains lazy symbols. The difference is that
 // LazyObjectFile wraps a single file instead of multiple files.
 //
 // This class is used for --start-lib and --end-lib options which
 // instruct the linker to link object files between them with the

ELF/InputFiles.cpp

 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys::fs;
 
 using namespace lld;
 using namespace lld::elf;
 
-
 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 {
     return static_cast<const ELFSectionRef &>(Sec).getOffset();
   }
   std::unique_ptr<LoadedObjectInfo> clone() const override {
     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;
+template <class ELFT> void ObjectFile<ELFT>::initializeDWARFDebugLine() {
+  std::unique_ptr<object::ObjectFile> Obj =
+      check(object::ObjectFile::createObjectFile(this->MB),
+            "createObjectFile failed");
 
   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() {}
-
+// Returns source line information for a given offset
+// using DWARF debug info.
 template <class ELFT>
-std::string DIHelper<ELFT>::getLineInfo(InputSectionBase<ELFT> *S,
+std::string ObjectFile<ELFT>::getLineInfo(InputSectionBase<ELFT> *S,
                                           uintX_t Offset) {
   if (!DwarfLine)
-    return "";
+    initializeDWARFDebugLine();
 
-  DILineInfo LineInfo;
-  DILineInfoSpecifier Spec;
   // The offset to CU is 0 (see DIHelper constructor).
-  const DWARFDebugLine::LineTable *LineTbl = DwarfLine->getLineTable(0);
-  if (!LineTbl)
+  const DWARFDebugLine::LineTable *Tbl = DwarfLine->getLineTable(0);
+  if (!Tbl)
     return "";
 
   // 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) + ")"
-             : "";
+  // section. See comments for ObjectInfo class.
+  DILineInfo Info;
+  DILineInfoSpecifier Spec;
+  Tbl->getFileLineInfoForAddress(S->Offset + Offset, nullptr, Spec.FLIKind,
+                                 Info);
+  if (Info.Line == 0)
+    return "";
+  return Info.FileName + " (" + std::to_string(Info.Line) + ")";
 }
 
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
 std::string elf::getFilename(const InputFile *F) {
   if (!F)
     return "(internal)";
   if (!F->ArchiveName.empty())
     return (F->ArchiveName + "(" + F->getName() + ")").str();

 
 template <class ELFT>
 ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getSymbols() {
   if (!this->Symtab)
     return this->SymbolBodies;
   return makeArrayRef(this->SymbolBodies).slice(1);
 }
 
-template <class ELFT> DIHelper<ELFT> *elf::ObjectFile<ELFT>::getDIHelper() {
-  if (!DIH)
-    DIH.reset(new DIHelper<ELFT>(this));
-
-  return DIH.get();
-}
-
 template <class ELFT> uint32_t elf::ObjectFile<ELFT>::getMipsGp0() const {
   if (ELFT::Is64Bits && MipsOptions && MipsOptions->Reginfo)
     return MipsOptions->Reginfo->ri_gp_value;
   if (!ELFT::Is64Bits && MipsReginfo && MipsReginfo->Reginfo)
     return MipsReginfo->Reginfo->ri_gp_value;
   return 0;
 }
 

 template class elf::SharedFile<ELF32BE>;
 template class elf::SharedFile<ELF64LE>;
 template class elf::SharedFile<ELF64BE>;
 
 template void BinaryFile::parse<ELF32LE>();
 template void BinaryFile::parse<ELF32BE>();
 template void BinaryFile::parse<ELF64LE>();
 template void BinaryFile::parse<ELF64BE>();
-
-template class elf::DIHelper<ELF32LE>;
-template class elf::DIHelper<ELF32BE>;
-template class elf::DIHelper<ELF64LE>;
-template class elf::DIHelper<ELF64BE>;

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(&S, Offset);
+  std::string LineInfo = File->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);