[DWARF] - Add API to allow DWARFContextInMemory to delegate relocations handling to client.

[grimar]

Summary

Previously DWARFContextInMemory handled relocations by itself.
(or used pre-relocated section content via another API)
This patch adds way to delegate relocations handling to client for each
relocation section.

I am using it in patch for LLD to speedup .gdb_index building, will
upload it and add dependency to this one really soon.

That allows to do some custom things, for example when building .gdb_index
looks we do not need to perform relocations computations for .debug_ranges,
all we need is to scan relocations to find the section indexes for futher use.

[grimar]

LLD patch where it is used is: D35005.

This patch also may be useful if client wants just to skip relocations proccessing for
particular sections. For example we do not need to proccess relocations for .debug_line when building
.gdb_index, patch allows to ignore this section.

[dblaikie]

include/llvm/DebugInfo/DIContext.h

225–231

Three slashes for a doxy comment?

232

Probably call this 'gatherRelocations' (since it doesn't actually modify the section, etc - but puts the relocations in the RelocAddrMap)

233

Looks like 'Map' should be taken by reference rather than pointer (since it's never null)

[grimar]

D35005 was abandoned.

include/llvm/DebugInfo/DIContext.h

 // debug information data.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DICONTEXT_H
 #define LLVM_DEBUGINFO_DICONTEXT_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Object/ObjectFile.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 
public:
   /// local (unrelocated) object file and applied on the fly. Note that this method
   /// is used purely for optimzation purposes in the common case of JITting in the
   /// local address space, so returning false should always be correct.
   virtual bool getLoadedSectionContents(const object::SectionRef &Sec,
                                         StringRef &Data) const {
     return false;
   }
 
+  // Client may overload this method to perform relocations on its side.
+  //
+  // RelSec is a relocation section, client code is responsible for filling Map
+  // with relocated values. It that case method should return true, to say that
+  // client proccessed relocations and nothing else should be done on parser
+  // side. If method returns false (default), parser is responsible for
+  // performing relocations.
+  virtual bool relocate(const object::SectionRef &RelSec,
+                        RelocAddrMap *Map) const {
+    return false;
+  }
+
   /// Obtain a copy of this LoadedObjectInfo.
   ///
   /// The caller is responsible for deallocation once the copy is no longer required.
   virtual std::unique_ptr<LoadedObjectInfo> clone() const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DICONTEXT_H

lib/DebugInfo/DWARF/DWARFContext.cpp

if (!Map) {
         Map = &TypesDWOSections[*RelocatedSection].Relocs;
       else
         continue;
     }
 
     if (Section.relocation_begin() == Section.relocation_end())
       continue;
 
+    if (L && L->relocate(Section, Map))
+      continue;
+
     // Symbol to [address, section index] cache mapping.
     std::map<SymbolRef, SymInfo> AddrCache;
     for (const RelocationRef &Reloc : Section.relocations()) {
       // FIXME: it's not clear how to correctly handle scattered
       // relocations.
       if (isRelocScattered(Obj, Reloc))
         continue;