1 /* libunwind - a platform-independent unwind library 2 Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P. 3 Contributed by David Mosberger-Tang <davidm (at) hpl.hp.com> 4 5 This file is part of libunwind. 6 7 Permission is hereby granted, free of charge, to any person obtaining 8 a copy of this software and associated documentation files (the 9 "Software"), to deal in the Software without restriction, including 10 without limitation the rights to use, copy, modify, merge, publish, 11 distribute, sublicense, and/or sell copies of the Software, and to 12 permit persons to whom the Software is furnished to do so, subject to 13 the following conditions: 14 15 The above copyright notice and this permission notice shall be 16 included in all copies or substantial portions of the Software. 17 18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 25 26 #include "dwarf_i.h" 27 28 static inline int 29 is_cie_id (unw_word_t val, int is_debug_frame) 30 { 31 /* The CIE ID is normally 0xffffffff (for 32-bit ELF) or 32 0xffffffffffffffff (for 64-bit ELF). However, .eh_frame 33 uses 0. */ 34 if (is_debug_frame) 35 /* ANDROID support update. */ 36 return (val == (uint32_t) -1 || val == (unw_word_t) (uint64_t) -1); 37 /* End of ANDROID update. */ 38 else 39 return (val == 0); 40 } 41 42 /* Note: we don't need to keep track of more than the first four 43 characters of the augmentation string, because we (a) ignore any 44 augmentation string contents once we find an unrecognized character 45 and (b) those characters that we do recognize, can't be 46 repeated. */ 47 static inline int 48 parse_cie (unw_addr_space_t as, unw_accessors_t *a, unw_word_t addr, 49 const unw_proc_info_t *pi, struct dwarf_cie_info *dci, 50 unw_word_t base, void *arg) 51 { 52 uint8_t version, ch, augstr[5], fde_encoding, handler_encoding; 53 unw_word_t len, cie_end_addr, aug_size; 54 uint32_t u32val; 55 uint64_t u64val; 56 size_t i; 57 int ret; 58 # define STR2(x) #x 59 # define STR(x) STR2(x) 60 61 /* Pick appropriate default for FDE-encoding. DWARF spec says 62 start-IP (initial_location) and the code-size (address_range) are 63 "address-unit sized constants". The `R' augmentation can be used 64 to override this, but by default, we pick an address-sized unit 65 for fde_encoding. */ 66 switch (dwarf_addr_size (as)) 67 { 68 case 4: fde_encoding = DW_EH_PE_udata4; break; 69 case 8: fde_encoding = DW_EH_PE_udata8; break; 70 default: fde_encoding = DW_EH_PE_omit; break; 71 } 72 73 dci->lsda_encoding = DW_EH_PE_omit; 74 dci->handler = 0; 75 76 if ((ret = dwarf_readu32 (as, a, &addr, &u32val, arg)) < 0) 77 return ret; 78 79 if (u32val != 0xffffffff) 80 { 81 /* the CIE is in the 32-bit DWARF format */ 82 uint32_t cie_id; 83 /* DWARF says CIE id should be 0xffffffff, but in .eh_frame, it's 0 */ 84 const uint32_t expected_id = (base) ? 0xffffffff : 0; 85 86 len = u32val; 87 cie_end_addr = addr + len; 88 if ((ret = dwarf_readu32 (as, a, &addr, &cie_id, arg)) < 0) 89 return ret; 90 if (cie_id != expected_id) 91 { 92 Debug (1, "Unexpected CIE id %x\n", cie_id); 93 return -UNW_EINVAL; 94 } 95 } 96 else 97 { 98 /* the CIE is in the 64-bit DWARF format */ 99 uint64_t cie_id; 100 /* DWARF says CIE id should be 0xffffffffffffffff, but in 101 .eh_frame, it's 0 */ 102 const uint64_t expected_id = (base) ? 0xffffffffffffffffull : 0; 103 104 if ((ret = dwarf_readu64 (as, a, &addr, &u64val, arg)) < 0) 105 return ret; 106 len = u64val; 107 cie_end_addr = addr + len; 108 if ((ret = dwarf_readu64 (as, a, &addr, &cie_id, arg)) < 0) 109 return ret; 110 if (cie_id != expected_id) 111 { 112 Debug (1, "Unexpected CIE id %llx\n", (long long) cie_id); 113 return -UNW_EINVAL; 114 } 115 } 116 dci->cie_instr_end = cie_end_addr; 117 118 if ((ret = dwarf_readu8 (as, a, &addr, &version, arg)) < 0) 119 return ret; 120 121 if (version != 1 && version != DWARF_CIE_VERSION) 122 { 123 Debug (1, "Got CIE version %u, expected version 1 or " 124 STR (DWARF_CIE_VERSION) "\n", version); 125 return -UNW_EBADVERSION; 126 } 127 128 /* read and parse the augmentation string: */ 129 memset (augstr, 0, sizeof (augstr)); 130 for (i = 0;;) 131 { 132 if ((ret = dwarf_readu8 (as, a, &addr, &ch, arg)) < 0) 133 return ret; 134 135 if (!ch) 136 break; /* end of augmentation string */ 137 138 if (i < sizeof (augstr) - 1) 139 augstr[i++] = ch; 140 } 141 142 if ((ret = dwarf_read_uleb128 (as, a, &addr, &dci->code_align, arg)) < 0 143 || (ret = dwarf_read_sleb128 (as, a, &addr, &dci->data_align, arg)) < 0) 144 return ret; 145 146 /* Read the return-address column either as a u8 or as a uleb128. */ 147 if (version == 1) 148 { 149 if ((ret = dwarf_readu8 (as, a, &addr, &ch, arg)) < 0) 150 return ret; 151 dci->ret_addr_column = ch; 152 } 153 else if ((ret = dwarf_read_uleb128 (as, a, &addr, &dci->ret_addr_column, 154 arg)) < 0) 155 return ret; 156 157 i = 0; 158 if (augstr[0] == 'z') 159 { 160 dci->sized_augmentation = 1; 161 if ((ret = dwarf_read_uleb128 (as, a, &addr, &aug_size, arg)) < 0) 162 return ret; 163 i++; 164 } 165 166 for (; i < sizeof (augstr) && augstr[i]; ++i) 167 switch (augstr[i]) 168 { 169 case 'L': 170 /* read the LSDA pointer-encoding format. */ 171 if ((ret = dwarf_readu8 (as, a, &addr, &ch, arg)) < 0) 172 return ret; 173 dci->lsda_encoding = ch; 174 break; 175 176 case 'R': 177 /* read the FDE pointer-encoding format. */ 178 if ((ret = dwarf_readu8 (as, a, &addr, &fde_encoding, arg)) < 0) 179 return ret; 180 break; 181 182 case 'P': 183 /* read the personality-routine pointer-encoding format. */ 184 if ((ret = dwarf_readu8 (as, a, &addr, &handler_encoding, arg)) < 0) 185 return ret; 186 if ((ret = dwarf_read_encoded_pointer (as, a, &addr, handler_encoding, 187 pi, &dci->handler, arg)) < 0) 188 return ret; 189 break; 190 191 case 'S': 192 /* This is a signal frame. */ 193 dci->signal_frame = 1; 194 195 /* Temporarily set it to one so dwarf_parse_fde() knows that 196 it should fetch the actual ABI/TAG pair from the FDE. */ 197 dci->have_abi_marker = 1; 198 break; 199 200 default: 201 Debug (1, "Unexpected augmentation string `%s'\n", augstr); 202 if (dci->sized_augmentation) 203 /* If we have the size of the augmentation body, we can skip 204 over the parts that we don't understand, so we're OK. */ 205 goto done; 206 else 207 return -UNW_EINVAL; 208 } 209 done: 210 dci->fde_encoding = fde_encoding; 211 dci->cie_instr_start = addr; 212 Debug (15, "CIE parsed OK, augmentation = \"%s\", handler=0x%lx\n", 213 augstr, (long) dci->handler); 214 return 0; 215 } 216 217 /* Extract proc-info from the FDE starting at adress ADDR. 218 219 Pass BASE as zero for eh_frame behaviour, or a pointer to 220 debug_frame base for debug_frame behaviour. */ 221 222 HIDDEN int 223 dwarf_extract_proc_info_from_fde (unw_addr_space_t as, unw_accessors_t *a, 224 unw_word_t *addrp, unw_proc_info_t *pi, 225 int need_unwind_info, unw_word_t base, 226 void *arg) 227 { 228 unw_word_t fde_end_addr, cie_addr, cie_offset_addr, aug_end_addr = 0; 229 unw_word_t start_ip, ip_range, aug_size, addr = *addrp; 230 int ret, ip_range_encoding; 231 struct dwarf_cie_info dci; 232 uint64_t u64val; 233 uint32_t u32val; 234 235 Debug (12, "FDE @ 0x%lx\n", (long) addr); 236 237 memset (&dci, 0, sizeof (dci)); 238 239 if ((ret = dwarf_readu32 (as, a, &addr, &u32val, arg)) < 0) 240 return ret; 241 242 if (u32val != 0xffffffff) 243 { 244 int32_t cie_offset; 245 246 /* In some configurations, an FDE with a 0 length indicates the 247 end of the FDE-table. */ 248 if (u32val == 0) 249 return -UNW_ENOINFO; 250 251 /* the FDE is in the 32-bit DWARF format */ 252 253 *addrp = fde_end_addr = addr + u32val; 254 cie_offset_addr = addr; 255 256 if ((ret = dwarf_reads32 (as, a, &addr, &cie_offset, arg)) < 0) 257 return ret; 258 259 if (is_cie_id (cie_offset, base != 0)) 260 /* ignore CIEs (happens during linear searches) */ 261 return 0; 262 263 if (base != 0) 264 cie_addr = base + cie_offset; 265 else 266 /* DWARF says that the CIE_pointer in the FDE is a 267 .debug_frame-relative offset, but the GCC-generated .eh_frame 268 sections instead store a "pcrelative" offset, which is just 269 as fine as it's self-contained. */ 270 cie_addr = cie_offset_addr - cie_offset; 271 } 272 else 273 { 274 int64_t cie_offset; 275 276 /* the FDE is in the 64-bit DWARF format */ 277 278 if ((ret = dwarf_readu64 (as, a, &addr, &u64val, arg)) < 0) 279 return ret; 280 281 *addrp = fde_end_addr = addr + u64val; 282 cie_offset_addr = addr; 283 284 if ((ret = dwarf_reads64 (as, a, &addr, &cie_offset, arg)) < 0) 285 return ret; 286 287 if (is_cie_id (cie_offset, base != 0)) 288 /* ignore CIEs (happens during linear searches) */ 289 return 0; 290 291 if (base != 0) 292 cie_addr = base + cie_offset; 293 else 294 /* DWARF says that the CIE_pointer in the FDE is a 295 .debug_frame-relative offset, but the GCC-generated .eh_frame 296 sections instead store a "pcrelative" offset, which is just 297 as fine as it's self-contained. */ 298 cie_addr = (unw_word_t) ((uint64_t) cie_offset_addr - cie_offset); 299 } 300 301 Debug (15, "looking for CIE at address %lx\n", (long) cie_addr); 302 303 if ((ret = parse_cie (as, a, cie_addr, pi, &dci, base, arg)) < 0) 304 return ret; 305 306 /* IP-range has same encoding as FDE pointers, except that it's 307 always an absolute value: */ 308 ip_range_encoding = dci.fde_encoding & DW_EH_PE_FORMAT_MASK; 309 310 if ((ret = dwarf_read_encoded_pointer (as, a, &addr, dci.fde_encoding, 311 pi, &start_ip, arg)) < 0 312 || (ret = dwarf_read_encoded_pointer (as, a, &addr, ip_range_encoding, 313 pi, &ip_range, arg)) < 0) 314 return ret; 315 pi->start_ip = start_ip; 316 pi->end_ip = start_ip + ip_range; 317 pi->handler = dci.handler; 318 319 if (dci.sized_augmentation) 320 { 321 if ((ret = dwarf_read_uleb128 (as, a, &addr, &aug_size, arg)) < 0) 322 return ret; 323 aug_end_addr = addr + aug_size; 324 } 325 326 if ((ret = dwarf_read_encoded_pointer (as, a, &addr, dci.lsda_encoding, 327 pi, &pi->lsda, arg)) < 0) 328 return ret; 329 330 Debug (15, "FDE covers IP 0x%lx-0x%lx, LSDA=0x%lx\n", 331 (long) pi->start_ip, (long) pi->end_ip, (long) pi->lsda); 332 333 if (need_unwind_info) 334 { 335 pi->format = UNW_INFO_FORMAT_TABLE; 336 pi->unwind_info_size = sizeof (dci); 337 pi->unwind_info = mempool_alloc (&dwarf_cie_info_pool); 338 if (!pi->unwind_info) 339 return -UNW_ENOMEM; 340 341 if (dci.have_abi_marker) 342 { 343 if ((ret = dwarf_readu16 (as, a, &addr, &dci.abi, arg)) < 0 344 || (ret = dwarf_readu16 (as, a, &addr, &dci.tag, arg)) < 0) 345 return ret; 346 Debug (13, "Found ABI marker = (abi=%u, tag=%u)\n", 347 dci.abi, dci.tag); 348 } 349 350 if (dci.sized_augmentation) 351 dci.fde_instr_start = aug_end_addr; 352 else 353 dci.fde_instr_start = addr; 354 dci.fde_instr_end = fde_end_addr; 355 356 memcpy (pi->unwind_info, &dci, sizeof (dci)); 357 } 358 return 0; 359 } 360
