]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/llvm/projects/libunwind/src/EHHeaderParser.hpp
Merge compiler-rt release_38 branch r258968.
[FreeBSD/FreeBSD.git] / contrib / llvm / projects / libunwind / src / EHHeaderParser.hpp
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
21 namespace 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 ///
28 template <typename A> class EHHeaderParser {
29 public:
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
47 private:
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
56 template <typename A>
57 void 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
75 template <typename A>
76 bool 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
96 template <typename A>
97 bool 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
137 template <typename A>
138 size_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