[LLD] [COFF] Use the local dwarf code instead of Symbolizer for resolving code locations. NFC.

[mstorsjo]

Summary

As we now have code that parses the dwarf info for variable locations, we can use that instead of relying on the higher level Symbolizer library, reducing the previous two different dwarf codepaths into one.

[ruiu]

LGTM

lld/COFF/CMakeLists.txt

add_lld_library(lldCOFF
   DebugInfoPDB
   Demangle
   LibDriver
   LTO
   MC
   Object
   Option
   Support
-  Symbolize
   WindowsManifest
 
   LINK_LIBS
   lldCommon
   ${LLVM_PTHREAD_LIB}
 
   DEPENDS
   COFFOptionsTableGen
   ${tablegen_deps}
   )

lld/COFF/Config.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/CachePruning.h"
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 
-namespace llvm {
-namespace symbolize {
-class LLVMSymbolizer;
-}
-} // namespace llvm
-
 namespace lld {
 namespace coff {
 
 using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 using llvm::COFF::WindowsSubsystem;
 using llvm::StringRef;
 class DefinedAbsolute;
 class DefinedRelative;
struct Configuration {
   bool incremental = true;
   bool integrityCheck = false;
   bool killAt = false;
   bool repro = false;
   bool swaprunCD = false;
   bool swaprunNet = false;
   bool thinLTOEmitImportsFiles;
   bool thinLTOIndexOnly;
-
-  llvm::symbolize::LLVMSymbolizer *symbolizer = nullptr;
 };
 
 extern Configuration *config;
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/InputFiles.h

 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>
 
 namespace llvm {
+struct DILineInfo;
 namespace pdb {
 class DbiModuleDescriptorBuilder;
 }
 }
 
 namespace lld {
 namespace coff {
 
public:
   TpiSource *debugTypesObj = nullptr;
 
   // The .debug$T stream if there's one.
   llvm::Optional<llvm::codeview::CVTypeArray> debugTypes;
 
   llvm::Optional<std::pair<StringRef, uint32_t>>
   getVariableLocation(StringRef var);
 
+  llvm::Optional<llvm::DILineInfo> getDILineInfo(uint32_t offset,
+                                                 uint32_t sectionIndex);
+
 private:
   const coff_section* getSection(uint32_t i);
   const coff_section *getSection(COFFSymbolRef sym) {
     return getSection(sym.getSectionNumber());
   }
 
   void initializeChunks();
   void initializeSymbols();

lld/COFF/InputFiles.cpp

ObjFile::getVariableLocation(StringRef var) {
   if (config->machine == I386)
     var.consume_front("_");
   Optional<std::pair<std::string, unsigned>> ret = dwarf->getVariableLoc(var);
   if (!ret)
     return None;
   return std::make_pair(saver.save(ret->first), ret->second);
 }
 
+// Used only for DWARF debug info, which is not common (except in MinGW
+// environments).
+Optional<DILineInfo> ObjFile::getDILineInfo(uint32_t offset,
+                                            uint32_t sectionIndex) {
+  if (!dwarf) {
+    dwarf = make<DWARFCache>(DWARFContext::create(*getCOFFObj()));
+    if (!dwarf)
+      return None;
+  }
+
+  return dwarf->getDILineInfo(offset, sectionIndex);
+}
+
 StringRef ltrim1(StringRef s, const char *chars) {
   if (!s.empty() && strchr(chars, s[0]))
     return s.substr(1);
   return s;
 }
 
 void ImportFile::parse() {
   const char *buf = mb.getBufferStart();

lld/COFF/SymbolTable.cpp

static std::vector<std::string> getSymbolLocations(BitcodeFile *file) {
   if (!source.empty())
     res += source.str() + "\n>>>               ";
   res += toString(file);
   return {res};
 }
 
 static Optional<std::pair<StringRef, uint32_t>>
 getFileLineDwarf(const SectionChunk *c, uint32_t addr) {
-  if (!config->symbolizer)
-    config->symbolizer = make<symbolize::LLVMSymbolizer>();
-  Expected<DILineInfo> expectedLineInfo = config->symbolizer->symbolizeCode(
-      *c->file->getCOFFObj(), {addr, c->getSectionNumber() - 1});
-  if (!expectedLineInfo)
+  Optional<DILineInfo> optionalLineInfo =
+      c->file->getDILineInfo(addr, c->getSectionNumber() - 1);
+  if (!optionalLineInfo)
     return None;
-  const DILineInfo &lineInfo = *expectedLineInfo;
+  const DILineInfo &lineInfo = *optionalLineInfo;
   if (lineInfo.FileName == DILineInfo::BadString)
     return None;
   return std::make_pair(saver.save(lineInfo.FileName), lineInfo.Line);
 }
 
 static Optional<std::pair<StringRef, uint32_t>>
 getFileLine(const SectionChunk *c, uint32_t addr) {
   // MinGW can optionally use codeview, even if the default is dwarf.