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