1//===------------------------- EHHeaderParser.hpp -------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//
9//  Parses ELF .eh_frame_hdr sections.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef __EHHEADERPARSER_HPP__
14#define __EHHEADERPARSER_HPP__
15
16#include "libunwind.h"
17
18#include "AddressSpace.hpp"
19#include "DwarfParser.hpp"
20
21namespace libunwind {
22
23/// \brief EHHeaderParser does basic parsing of an ELF .eh_frame_hdr section.
24///
25/// See DWARF spec for details:
26///    http://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
27///
28template <typename A> class EHHeaderParser {
29public:
30  typedef typename A::pint_t pint_t;
31
32  /// Information encoded in the EH frame header.
33  struct EHHeaderInfo {
34    pint_t eh_frame_ptr;
35    size_t fde_count;
36    pint_t table;
37    uint8_t table_enc;
38  };
39
40  static void decodeEHHdr(A &addressSpace, pint_t ehHdrStart, pint_t ehHdrEnd,
41                          EHHeaderInfo &ehHdrInfo);
42  static bool findFDE(A &addressSpace, pint_t pc, pint_t ehHdrStart,
43                      uint32_t sectionLength,
44                      typename CFI_Parser<A>::FDE_Info *fdeInfo,
45                      typename CFI_Parser<A>::CIE_Info *cieInfo);
46
47private:
48  static bool decodeTableEntry(A &addressSpace, pint_t &tableEntry,
49                               pint_t ehHdrStart, pint_t ehHdrEnd,
50                               uint8_t tableEnc,
51                               typename CFI_Parser<A>::FDE_Info *fdeInfo,
52                               typename CFI_Parser<A>::CIE_Info *cieInfo);
53  static size_t getTableEntrySize(uint8_t tableEnc);
54};
55
56template <typename A>
57void EHHeaderParser<A>::decodeEHHdr(A &addressSpace, pint_t ehHdrStart,
58                                    pint_t ehHdrEnd, EHHeaderInfo &ehHdrInfo) {
59  pint_t p = ehHdrStart;
60  uint8_t version = addressSpace.get8(p++);
61  if (version != 1)
62    _LIBUNWIND_ABORT("Unsupported .eh_frame_hdr version");
63
64  uint8_t eh_frame_ptr_enc = addressSpace.get8(p++);
65  uint8_t fde_count_enc = addressSpace.get8(p++);
66  ehHdrInfo.table_enc = addressSpace.get8(p++);
67
68  ehHdrInfo.eh_frame_ptr =
69      addressSpace.getEncodedP(p, ehHdrEnd, eh_frame_ptr_enc, ehHdrStart);
70  ehHdrInfo.fde_count =
71      addressSpace.getEncodedP(p, ehHdrEnd, fde_count_enc, ehHdrStart);
72  ehHdrInfo.table = p;
73}
74
75template <typename A>
76bool EHHeaderParser<A>::decodeTableEntry(
77    A &addressSpace, pint_t &tableEntry, pint_t ehHdrStart, pint_t ehHdrEnd,
78    uint8_t tableEnc, typename CFI_Parser<A>::FDE_Info *fdeInfo,
79    typename CFI_Parser<A>::CIE_Info *cieInfo) {
80  // Have to decode the whole FDE for the PC range anyway, so just throw away
81  // the PC start.
82  addressSpace.getEncodedP(tableEntry, ehHdrEnd, tableEnc, ehHdrStart);
83  pint_t fde =
84      addressSpace.getEncodedP(tableEntry, ehHdrEnd, tableEnc, ehHdrStart);
85  const char *message =
86      CFI_Parser<A>::decodeFDE(addressSpace, fde, fdeInfo, cieInfo);
87  if (message != NULL) {
88    _LIBUNWIND_DEBUG_LOG("EHHeaderParser::decodeTableEntry: bad fde: %s\n",
89                         message);
90    return false;
91  }
92
93  return true;
94}
95
96template <typename A>
97bool EHHeaderParser<A>::findFDE(A &addressSpace, pint_t pc, pint_t ehHdrStart,
98                                uint32_t sectionLength,
99                                typename CFI_Parser<A>::FDE_Info *fdeInfo,
100                                typename CFI_Parser<A>::CIE_Info *cieInfo) {
101  pint_t ehHdrEnd = ehHdrStart + sectionLength;
102
103  EHHeaderParser<A>::EHHeaderInfo hdrInfo;
104  EHHeaderParser<A>::decodeEHHdr(addressSpace, ehHdrStart, ehHdrEnd, hdrInfo);
105
106  size_t tableEntrySize = getTableEntrySize(hdrInfo.table_enc);
107  pint_t tableEntry;
108
109  size_t low = 0;
110  for (size_t len = hdrInfo.fde_count; len > 1;) {
111    size_t mid = low + (len / 2);
112    tableEntry = hdrInfo.table + mid * tableEntrySize;
113    pint_t start = addressSpace.getEncodedP(tableEntry, ehHdrEnd,
114                                            hdrInfo.table_enc, ehHdrStart);
115
116    if (start == pc) {
117      low = mid;
118      break;
119    } else if (start < pc) {
120      low = mid;
121      len -= (len / 2);
122    } else {
123      len /= 2;
124    }
125  }
126
127  tableEntry = hdrInfo.table + low * tableEntrySize;
128  if (decodeTableEntry(addressSpace, tableEntry, ehHdrStart, ehHdrEnd,
129                       hdrInfo.table_enc, fdeInfo, cieInfo)) {
130    if (pc >= fdeInfo->pcStart && pc < fdeInfo->pcEnd)
131      return true;
132  }
133
134  return false;
135}
136
137template <typename A>
138size_t EHHeaderParser<A>::getTableEntrySize(uint8_t tableEnc) {
139  switch (tableEnc & 0x0f) {
140  case DW_EH_PE_sdata2:
141  case DW_EH_PE_udata2:
142    return 4;
143  case DW_EH_PE_sdata4:
144  case DW_EH_PE_udata4:
145    return 8;
146  case DW_EH_PE_sdata8:
147  case DW_EH_PE_udata8:
148    return 16;
149  case DW_EH_PE_sleb128:
150  case DW_EH_PE_uleb128:
151    _LIBUNWIND_ABORT("Can't binary search on variable length encoded data.");
152  case DW_EH_PE_omit:
153    return 0;
154  default:
155    _LIBUNWIND_ABORT("Unknown DWARF encoding for search table.");
156  }
157}
158
159}
160
161#endif
162