xref: /freebsd/contrib/llvm-project/libunwind/src/EHHeaderParser.hpp (revision f976241773df2260e6170317080761d1c5814fe5)
1 //===------------------------- EHHeaderParser.hpp -------------------------===//
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   uint8_t version = addressSpace.get8(p++);
59   if (version != 1) {
60     _LIBUNWIND_LOG0("Unsupported .eh_frame_hdr version");
61     return false;
62   }
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       fde_count_enc == DW_EH_PE_omit
72           ? 0
73           : addressSpace.getEncodedP(p, ehHdrEnd, fde_count_enc, ehHdrStart);
74   ehHdrInfo.table = p;
75 
76   return true;
77 }
78 
79 template <typename A>
80 bool EHHeaderParser<A>::decodeTableEntry(
81     A &addressSpace, pint_t &tableEntry, pint_t ehHdrStart, pint_t ehHdrEnd,
82     uint8_t tableEnc, typename CFI_Parser<A>::FDE_Info *fdeInfo,
83     typename CFI_Parser<A>::CIE_Info *cieInfo) {
84   // Have to decode the whole FDE for the PC range anyway, so just throw away
85   // the PC start.
86   addressSpace.getEncodedP(tableEntry, ehHdrEnd, tableEnc, ehHdrStart);
87   pint_t fde =
88       addressSpace.getEncodedP(tableEntry, ehHdrEnd, tableEnc, ehHdrStart);
89   const char *message =
90       CFI_Parser<A>::decodeFDE(addressSpace, fde, fdeInfo, cieInfo);
91   if (message != NULL) {
92     _LIBUNWIND_DEBUG_LOG("EHHeaderParser::decodeTableEntry: bad fde: %s",
93                          message);
94     return false;
95   }
96 
97   return true;
98 }
99 
100 template <typename A>
101 bool EHHeaderParser<A>::findFDE(A &addressSpace, pint_t pc, pint_t ehHdrStart,
102                                 uint32_t sectionLength,
103                                 typename CFI_Parser<A>::FDE_Info *fdeInfo,
104                                 typename CFI_Parser<A>::CIE_Info *cieInfo) {
105   pint_t ehHdrEnd = ehHdrStart + sectionLength;
106 
107   EHHeaderParser<A>::EHHeaderInfo hdrInfo;
108   if (!EHHeaderParser<A>::decodeEHHdr(addressSpace, ehHdrStart, ehHdrEnd,
109                                       hdrInfo))
110     return false;
111 
112   size_t tableEntrySize = getTableEntrySize(hdrInfo.table_enc);
113   pint_t tableEntry;
114 
115   size_t low = 0;
116   for (size_t len = hdrInfo.fde_count; len > 1;) {
117     size_t mid = low + (len / 2);
118     tableEntry = hdrInfo.table + mid * tableEntrySize;
119     pint_t start = addressSpace.getEncodedP(tableEntry, ehHdrEnd,
120                                             hdrInfo.table_enc, ehHdrStart);
121 
122     if (start == pc) {
123       low = mid;
124       break;
125     } else if (start < pc) {
126       low = mid;
127       len -= (len / 2);
128     } else {
129       len /= 2;
130     }
131   }
132 
133   tableEntry = hdrInfo.table + low * tableEntrySize;
134   if (decodeTableEntry(addressSpace, tableEntry, ehHdrStart, ehHdrEnd,
135                        hdrInfo.table_enc, fdeInfo, cieInfo)) {
136     if (pc >= fdeInfo->pcStart && pc < fdeInfo->pcEnd)
137       return true;
138   }
139 
140   return false;
141 }
142 
143 template <typename A>
144 size_t EHHeaderParser<A>::getTableEntrySize(uint8_t tableEnc) {
145   switch (tableEnc & 0x0f) {
146   case DW_EH_PE_sdata2:
147   case DW_EH_PE_udata2:
148     return 4;
149   case DW_EH_PE_sdata4:
150   case DW_EH_PE_udata4:
151     return 8;
152   case DW_EH_PE_sdata8:
153   case DW_EH_PE_udata8:
154     return 16;
155   case DW_EH_PE_sleb128:
156   case DW_EH_PE_uleb128:
157     _LIBUNWIND_ABORT("Can't binary search on variable length encoded data.");
158   case DW_EH_PE_omit:
159     return 0;
160   default:
161     _LIBUNWIND_ABORT("Unknown DWARF encoding for search table.");
162   }
163 }
164 
165 }
166 
167 #endif
168