[DWARF] Introduce RefHandler to parse external refs in frame data

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/Support/Error.h"
+#include <functional>
 #include <map>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
public:
   DWARFDebugFrame(Triple::ArchType Arch,
                   bool IsEH = false, uint64_t EHFrameAddress = 0);
   ~DWARFDebugFrame();
 
   /// Dump the section data into the given stream.
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
             Optional<uint64_t> Offset) const;
 
+  using RefHandlerType =
+    std::function<void(uint64_t, uint64_t, uint64_t)>;
+
   /// Parse the section from raw data. \p Data is assumed to contain the whole
   /// frame section contents to be parsed.
-  Error parse(DWARFDataExtractor Data);
+  /// If non-null RefHandler is passed, call it for every encountered external
+  /// reference in frame data. The expected signature is:
+  ///
+  ///   void RefHandler(uint64_t Value, uint64_t Offset, uint64_t Type);
+  ///
+  /// where Value is a value of the reference, Offset - is an offset into the
+  /// frame data at which the reference occured, and Type is a DWARF encoding
+  /// type of the reference.
+  Error parse(DWARFDataExtractor Data, RefHandlerType RefHandler= nullptr);
 
   /// Return whether the section has any entries.
   bool empty() const { return Entries.empty(); }
 
   /// DWARF Frame entries accessors
   iterator begin() const { return Entries.begin(); }
   iterator end() const { return Entries.end(); }
   iterator_range<iterator> entries() const {

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
   errs() << "DUMP: ";
   for (int i = 0; i < Length; ++i) {
     uint8_t c = Data.getU8(&Offset);
     errs().write_hex(c); errs() << " ";
   }
   errs() << "\n";
 }
 
-Error DWARFDebugFrame::parse(DWARFDataExtractor Data) {
+Error DWARFDebugFrame::parse(DWARFDataExtractor Data,
+                             RefHandlerType RefHandler) {
   uint64_t Offset = 0;
   DenseMap<uint64_t, CIE *> CIEs;
 
   while (Data.isValidOffset(Offset)) {
     uint64_t StartOffset = Offset;
 
     uint64_t Length;
     DwarfFormat Format;
if (Id == getCIEId(IsDWARF64, IsEH)) {
             if (Personality)
               return createStringError(
                   errc::invalid_argument,
                   "duplicate personality in entry at 0x%" PRIx64, StartOffset);
             PersonalityEncoding = Data.getU8(&Offset);
             Personality = Data.getEncodedPointer(
                 &Offset, *PersonalityEncoding,
                 EHFrameAddress ? EHFrameAddress + Offset : 0);
+            if (RefHandler)
+              RefHandler(*Personality, Offset, *PersonalityEncoding);
             break;
           }
           case 'R':
             FDEPointerEncoding = Data.getU8(&Offset);
             break;
           case 'S':
             // Current frame is a signal trampoline.
             break;
if (Id == getCIEId(IsDWARF64, IsEH)) {
                                    "parsing FDE data at 0x%" PRIx64
                                    " failed due to missing CIE",
                                    StartOffset);
         if (auto Val =
                 Data.getEncodedPointer(&Offset, Cie->getFDEPointerEncoding(),
                                        EHFrameAddress + Offset)) {
           InitialLocation = *Val;
         }
+        if (RefHandler)
+          RefHandler(InitialLocation, Offset, Cie->getFDEPointerEncoding());
         if (auto Val = Data.getEncodedPointer(
                 &Offset, Cie->getFDEPointerEncoding(), 0)) {
           AddressRange = *Val;
         }
 
         StringRef AugmentationString = Cie->getAugmentationString();
         if (!AugmentationString.empty()) {
           // Parse the augmentation length and data for this FDE.
           uint64_t AugmentationLength = Data.getULEB128(&Offset);
 
           uint64_t EndAugmentationOffset = Offset + AugmentationLength;
 
           // Decode the LSDA if the CIE augmentation string said we should.
           if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit) {
             LSDAAddress = Data.getEncodedPointer(
                 &Offset, Cie->getLSDAPointerEncoding(),
                 EHFrameAddress ? Offset + EHFrameAddress : 0);
+            if (RefHandler)
+              RefHandler(*LSDAAddress, Offset, Cie->getLSDAPointerEncoding());
           }
 
           if (Offset != EndAugmentationOffset)
             return createStringError(errc::invalid_argument,
                                      "parsing augmentation data at 0x%" PRIx64
                                      " failed",
                                      StartOffset);
         }