libunwind/src/EHHeaderParser.hpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //
   8 //  Parses ELF .eh_frame_hdr sections.
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #ifndef __EHHEADERPARSER_HPP__
  13 #define __EHHEADERPARSER_HPP__
  14
  15 #include "libunwind.h"
  16
  17 #include "DwarfParser.hpp"
  18
  19 namespace libunwind {
  20
  21 /// \brief EHHeaderParser does basic parsing of an ELF .eh_frame_hdr section.
  22 ///
  23 /// See DWARF spec for details:
  24 ///    http://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
  25 ///
  26 template <typename A> class EHHeaderParser {
  27 public:
  28   typedef typename A::pint_t pint_t;
  29
  30   /// Information encoded in the EH frame header.
  31   struct EHHeaderInfo {
  32     pint_t eh_frame_ptr;
  33     size_t fde_count;
  34     pint_t table;
  35     uint8_t table_enc;
  36   };
  37
  38   static bool decodeEHHdr(A &addressSpace, pint_t ehHdrStart, pint_t ehHdrEnd,
  39                           EHHeaderInfo &ehHdrInfo);
  40   static bool findFDE(A &addressSpace, pint_t pc, pint_t ehHdrStart,
  41                       uint32_t sectionLength,
  42                       typename CFI_Parser<A>::FDE_Info *fdeInfo,
  43                       typename CFI_Parser<A>::CIE_Info *cieInfo);
  44
  45 private:
  46   static bool decodeTableEntry(A &addressSpace, pint_t &tableEntry,
  47                                pint_t ehHdrStart, pint_t ehHdrEnd,
  48                                uint8_t tableEnc,
  49                                typename CFI_Parser<A>::FDE_Info *fdeInfo,
  50                                typename CFI_Parser<A>::CIE_Info *cieInfo);
  51   static size_t getTableEntrySize(uint8_t tableEnc);
  52 };
  53
  54 template <typename A>
  55 bool EHHeaderParser<A>::decodeEHHdr(A &addressSpace, pint_t ehHdrStart,
  56                                     pint_t ehHdrEnd, EHHeaderInfo &ehHdrInfo) {
  57   pint_t p = ehHdrStart;
  58
  59   // Ensure that we don't read data beyond the end of .eh_frame_hdr
  60   if (ehHdrEnd - ehHdrStart < 4) {
  61     // Don't print a message for an empty .eh_frame_hdr (this can happen if
  62     // the linker script defines symbols for it even in the empty case).
  63     if (ehHdrEnd == ehHdrStart)
  64       return false;
  65     _LIBUNWIND_LOG("unsupported .eh_frame_hdr at %" PRIx64
  66                    ": need at least 4 bytes of data but only got %zd",
  67                    static_cast<uint64_t>(ehHdrStart),
  68                    static_cast<size_t>(ehHdrEnd - ehHdrStart));
  69     return false;
  70   }
  71   uint8_t version = addressSpace.get8(p++);
  72   if (version != 1) {
  73     _LIBUNWIND_LOG("unsupported .eh_frame_hdr version: %" PRIu8 " at %" PRIx64,
  74                    version, static_cast<uint64_t>(ehHdrStart));
  75     return false;
  76   }
  77
  78   uint8_t eh_frame_ptr_enc = addressSpace.get8(p++);
  79   uint8_t fde_count_enc = addressSpace.get8(p++);
  80   ehHdrInfo.table_enc = addressSpace.get8(p++);
  81
  82   ehHdrInfo.eh_frame_ptr =
  83       addressSpace.getEncodedP(p, ehHdrEnd, eh_frame_ptr_enc, ehHdrStart);
  84   ehHdrInfo.fde_count =
  85       fde_count_enc == DW_EH_PE_omit
  86           ? 0
  87           : addressSpace.getEncodedP(p, ehHdrEnd, fde_count_enc, ehHdrStart);
  88   ehHdrInfo.table = p;
  89
  90   return true;
  91 }
  92
  93 template <typename A>
  94 bool EHHeaderParser<A>::decodeTableEntry(
  95     A &addressSpace, pint_t &tableEntry, pint_t ehHdrStart, pint_t ehHdrEnd,
  96     uint8_t tableEnc, typename CFI_Parser<A>::FDE_Info *fdeInfo,
  97     typename CFI_Parser<A>::CIE_Info *cieInfo) {
  98   // Have to decode the whole FDE for the PC range anyway, so just throw away
  99   // the PC start.
 100   addressSpace.getEncodedP(tableEntry, ehHdrEnd, tableEnc, ehHdrStart);
 101   pint_t fde =
 102       addressSpace.getEncodedP(tableEntry, ehHdrEnd, tableEnc, ehHdrStart);
 103   const char *message =
 104       CFI_Parser<A>::decodeFDE(addressSpace, fde, fdeInfo, cieInfo);
 105   if (message != NULL) {
 106     _LIBUNWIND_DEBUG_LOG("EHHeaderParser::decodeTableEntry: bad fde: %s",
 107                          message);
 108     return false;
 109   }
 110
 111   return true;
 112 }
 113
 114 template <typename A>
 115 bool EHHeaderParser<A>::findFDE(A &addressSpace, pint_t pc, pint_t ehHdrStart,
 116                                 uint32_t sectionLength,
 117                                 typename CFI_Parser<A>::FDE_Info *fdeInfo,
 118                                 typename CFI_Parser<A>::CIE_Info *cieInfo) {
 119   pint_t ehHdrEnd = ehHdrStart + sectionLength;
 120
 121   EHHeaderParser<A>::EHHeaderInfo hdrInfo;
 122   if (!EHHeaderParser<A>::decodeEHHdr(addressSpace, ehHdrStart, ehHdrEnd,
 123                                       hdrInfo))
 124     return false;
 125
 126   if (hdrInfo.fde_count == 0) return false;
 127
 128   size_t tableEntrySize = getTableEntrySize(hdrInfo.table_enc);
 129   pint_t tableEntry;
 130
 131   size_t low = 0;
 132   for (size_t len = hdrInfo.fde_count; len > 1;) {
 133     size_t mid = low + (len / 2);
 134     tableEntry = hdrInfo.table + mid * tableEntrySize;
 135     pint_t start = addressSpace.getEncodedP(tableEntry, ehHdrEnd,
 136                                             hdrInfo.table_enc, ehHdrStart);
 137
 138     if (start == pc) {
 139       low = mid;
 140       break;
 141     } else if (start < pc) {
 142       low = mid;
 143       len -= (len / 2);
 144     } else {
 145       len /= 2;
 146     }
 147   }
 148
 149   tableEntry = hdrInfo.table + low * tableEntrySize;
 150   if (decodeTableEntry(addressSpace, tableEntry, ehHdrStart, ehHdrEnd,
 151                        hdrInfo.table_enc, fdeInfo, cieInfo)) {
 152     if (pc >= fdeInfo->pcStart && pc < fdeInfo->pcEnd)
 153       return true;
 154   }
 155
 156   return false;
 157 }
 158
 159 template <typename A>
 160 size_t EHHeaderParser<A>::getTableEntrySize(uint8_t tableEnc) {
 161   switch (tableEnc & 0x0f) {
 162   case DW_EH_PE_sdata2:
 163   case DW_EH_PE_udata2:
 164     return 4;
 165   case DW_EH_PE_sdata4:
 166   case DW_EH_PE_udata4:
 167     return 8;
 168   case DW_EH_PE_sdata8:
 169   case DW_EH_PE_udata8:
 170     return 16;
 171   case DW_EH_PE_sleb128:
 172   case DW_EH_PE_uleb128:
 173     _LIBUNWIND_ABORT("Can't binary search on variable length encoded data.");
 174   case DW_EH_PE_omit:
 175     return 0;
 176   default:
 177     _LIBUNWIND_ABORT("Unknown DWARF encoding for search table.");
 178   }
 179 }
 180
 181 }
 182
 183 #endif