1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <_libelf.h>
28 #include <dwarf.h>
29 #include <stdio.h>
30 #include <unistd.h>
31 #include <errno.h>
32 #include <strings.h>
33 #include <debug.h>
34 #include <conv.h>
35 #include <msg.h>
36 #include <_elfdump.h>
37
38
39 /*
40 * Data from eh_frame section used by dump_cfi()
41 */
42 typedef struct {
43 Half e_machine; /* ehdr->e_machine */
44 uchar_t *e_ident; /* ehdr->e_ident */
45 uint64_t sh_addr; /* Address of eh_frame section */
46 int do_swap; /* True if object and system byte */
47 /* order differs */
48 int cieRflag; /* R flag from current CIE */
49 uint64_t ciecalign; /* CIE code align factor */
50 int64_t ciedalign; /* CIE data align factor */
51 uint64_t fdeinitloc; /* FDE initial location */
52 uint64_t gotaddr; /* Address of the GOT */
53 } dump_cfi_state_t;
54
55
56 /*
57 * Extract an unsigned integer value from an .eh_frame section, converting it
58 * from its native byte order to that of the running machine if necessary.
59 *
60 * entry:
61 * data - Base address from which to extract datum
62 * ndx - Address of variable giving index to start byte in data.
63 * size - # of bytes in datum. Must be one of: 1, 2, 4, 8
64 * do_swap - True if the data is in a different byte order than that
65 * of the host system.
66 *
67 * exit:
68 * *ndx is incremented by the size of the extracted datum.
69 *
70 * The requested datum is extracted, byte swapped if necessary,
71 * and returned.
72 */
73 static uint64_t
74 dwarf_extract_uint(uchar_t *data, uint64_t *ndx, int size, int do_swap)
75 {
76 switch (size) {
77 case 1:
78 return (data[(*ndx)++]);
79 case 2:
80 {
81 Half r;
82 uchar_t *p = (uchar_t *)&r;
83
84 data += *ndx;
85 if (do_swap)
86 UL_ASSIGN_BSWAP_HALF(p, data);
87 else
88 UL_ASSIGN_HALF(p, data);
89
90 (*ndx) += 2;
91 return (r);
92 }
93 case 4:
94 {
95 Word r;
96 uchar_t *p = (uchar_t *)&r;
97
98 data += *ndx;
99 if (do_swap)
100 UL_ASSIGN_BSWAP_WORD(p, data);
101 else
102 UL_ASSIGN_WORD(p, data);
103
104 (*ndx) += 4;
105 return (r);
106 }
107
108 case 8:
109 {
110 uint64_t r;
111 uchar_t *p = (uchar_t *)&r;
112
113 data += *ndx;
114 if (do_swap)
115 UL_ASSIGN_BSWAP_LWORD(p, data);
116 else
117 UL_ASSIGN_LWORD(p, data);
118
119 (*ndx) += 8;
120 return (r);
121 }
122 }
123
124 /* If here, an invalid size was specified */
125 assert(0);
126 return (0);
127 }
128
129 /*
130 * Map a DWARF register constant to the machine register name it
131 * corresponds to, formatting the result into buf.
132 *
133 * The assignment of DWARF register numbers is part of the system
134 * specific ABI for each platform.
135 *
136 * entry:
137 * regno - DWARF register number
138 * mach - ELF machine code for platform
139 * buf, bufsize - Buffer to receive the formatted result string
140 *
141 * exit:
142 * The results are formatted into buf, and buf is returned.
143 * If the generated output would exceed the size of the buffer
144 * provided, it will be clipped to fit.
145 */
146 static const char *
147 dwarf_regname(Half mach, int regno, char *buf, size_t bufsize)
148 {
149 Conv_inv_buf_t inv_buf;
150 const char *name;
151 int good_name;
152
153 name = conv_dwarf_regname(mach, regno, 0, &good_name, &inv_buf);
154
155 /*
156 * If there is a good mnemonic machine name for the register,
157 * format the result as 'r# (mnemonic)'. If there is no good
158 * name for it, then simply format the dwarf name as 'r#'.
159 */
160 if (good_name)
161 (void) snprintf(buf, bufsize, MSG_ORIG(MSG_REG_FMT_NAME),
162 regno, name);
163 else
164 (void) snprintf(buf, bufsize, MSG_ORIG(MSG_REG_FMT_BASIC),
165 regno);
166
167 return (buf);
168 }
169
170
171 /*
172 * Decode eh_frame Call Frame Instructions, printing each one on a
173 * separate line.
174 *
175 * entry:
176 * data - Address of base of eh_frame section being processed
177 * off - Offset of current FDE within eh_frame
178 * ndx - Index of current position within current FDE
179 * len - Length of eh_frame section
180 * state - Object, CIE, and FDE state for current request
181 * msg - Header message to issue before producing output.
182 * indent - # of indentation characters issued for each line of output.
183 *
184 * exit:
185 * The Call Frame Instructions have been decoded and printed.
186 *
187 * *ndx has been incremented to contain the index of the next
188 * byte of data to be processed in eh_frame.
189 *
190 * note:
191 * The format of Call Frame Instructions in .eh_frame sections is based
192 * on the DWARF specification.
193 */
194 static void
195 dump_cfi(uchar_t *data, uint64_t off, uint64_t *ndx, uint_t len,
196 dump_cfi_state_t *state, const char *msg, int indent)
197 {
198 /*
199 * We use %*s%s to insert leading whitespace and the op name.
200 * PREFIX supplies these arguments.
201 */
202 #define PREFIX indent, MSG_ORIG(MSG_STR_EMPTY), opname
203
204 /* Hide boilerplate clutter in calls to dwarf_regname() */
205 #define REGNAME(_rnum, _buf) \
206 dwarf_regname(state->e_machine, _rnum, _buf, sizeof (_buf))
207
208 /* Extract the lower 6 bits from an op code */
209 #define LOW_OP(_op) (_op & 0x3f)
210
211 char rbuf1[32], rbuf2[32];
212 Conv_inv_buf_t inv_buf;
213 uchar_t op;
214 const char *opname;
215 uint64_t oper1, oper2, cur_pc;
216 int64_t soper;
217 const char *loc_str;
218 int i;
219
220 dbg_print(0, msg);
221
222 /*
223 * In a CIE/FDE, the length field does not include it's own
224 * size. Hence, the value passed in is 4 less than the index
225 * of the actual final location.
226 */
227 len += 4;
228
229 /*
230 * There is a concept of the 'current location', which is the PC
231 * to which the current item applies. It starts out set to the
232 * FDE initial location, and can be set or incremented by
233 * various OP codes. cur_pc is used to track this.
234 *
235 * We want to use 'initloc' in the output the first time the location
236 * is referenced, and then switch to 'loc' for subsequent references.
237 * loc_str is used to manage that.
238 */
239 cur_pc = state->fdeinitloc;
240 loc_str = MSG_ORIG(MSG_STR_INITLOC);
241
242 while (*ndx < len) {
243 /*
244 * The first byte contains the primary op code in the top
245 * 2 bits, so there are 4 of them. Primary OP code
246 * 0 uses the lower 6 bits to specify a sub-opcode, allowing
247 * for 64 of them. The other 3 primary op codes use the
248 * lower 6 bits to hold an operand (a register #, or value).
249 *
250 * Check the primary OP code. If it's 1-3, handle it
251 * and move to the next loop iteration. For OP code 0,
252 * fall through to decode the sub-code.
253 */
254 op = data[off + (*ndx)++];
255 opname = conv_dwarf_cfa(op, 0, &inv_buf);
256 switch (op >> 6) {
257 case 0x1: /* v2: DW_CFA_advance_loc, delta */
258 oper1 = state->ciecalign * LOW_OP(op);
259 cur_pc += oper1;
260 dbg_print(0, MSG_ORIG(MSG_CFA_ADV_LOC), PREFIX,
261 loc_str, EC_XWORD(oper1), EC_XWORD(cur_pc));
262 loc_str = MSG_ORIG(MSG_STR_LOC);
263 continue;
264
265 case 0x2: /* v2: DW_CFA_offset, reg, offset */
266 soper = uleb_extract(&data[off], ndx) *
267 state->ciedalign;
268 dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX,
269 REGNAME(LOW_OP(op), rbuf1), EC_SXWORD(soper));
270 continue;
271
272 case 0x3: /* v2: DW_CFA_restore, reg */
273 dbg_print(0, MSG_ORIG(MSG_CFA_REG), PREFIX,
274 REGNAME(LOW_OP(op), rbuf1));
275 continue;
276 }
277
278 /*
279 * If we're here, the high order 2 bits are 0. The low 6 bits
280 * specify a sub-opcode defining the operation.
281 */
282 switch (op) {
283 case 0x00: /* v2: DW_CFA_nop */
284 /*
285 * No-ops are used to fill unused space required
286 * for alignment. It is common for there to be
287 * multiple adjacent nops. It saves space to report
288 * them all with a single line of output.
289 */
290 for (i = 1;
291 (*ndx < len) && (data[off + *ndx] == 0);
292 i++, (*ndx)++)
293 ;
294 dbg_print(0, MSG_ORIG(MSG_CFA_SIMPLEREP), PREFIX, i);
295 break;
296
297 case 0x0a: /* v2: DW_CFA_remember_state */
298 case 0x0b: /* v2: DW_CFA_restore_state */
299 case 0x2d: /* GNU: DW_CFA_GNU_window_save */
300 dbg_print(0, MSG_ORIG(MSG_CFA_SIMPLE), PREFIX);
301 break;
302
303 case 0x01: /* v2: DW_CFA_set_loc, address */
304 cur_pc = dwarf_ehe_extract(&data[off], ndx,
305 state->cieRflag, state->e_ident, B_FALSE,
306 state->sh_addr, off + *ndx, state->gotaddr);
307 dbg_print(0, MSG_ORIG(MSG_CFA_CFASET), PREFIX,
308 EC_XWORD(cur_pc));
309 break;
310
311 case 0x02: /* v2: DW_CFA_advance_loc_1, 1-byte delta */
312 case 0x03: /* v2: DW_CFA_advance_loc_2, 2-byte delta */
313 case 0x04: /* v2: DW_CFA_advance_loc_4, 4-byte delta */
314 /*
315 * Since the codes are contiguous, and the sizes are
316 * powers of 2, we can compute the word width from
317 * the code.
318 */
319 i = 1 << (op - 0x02);
320 oper1 = dwarf_extract_uint(data + off, ndx, i,
321 state->do_swap) * state->ciecalign;
322 cur_pc += oper1;
323 dbg_print(0, MSG_ORIG(MSG_CFA_ADV_LOC), PREFIX,
324 loc_str, EC_XWORD(oper1), EC_XWORD(cur_pc));
325 loc_str = MSG_ORIG(MSG_STR_LOC);
326 break;
327
328 case 0x05: /* v2: DW_CFA_offset_extended,reg,off */
329 oper1 = uleb_extract(&data[off], ndx);
330 soper = uleb_extract(&data[off], ndx) *
331 state->ciedalign;
332 dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX,
333 REGNAME(oper1, rbuf1), EC_SXWORD(soper));
334 break;
335
336 case 0x06: /* v2: DW_CFA_restore_extended, reg */
337 case 0x0d: /* v2: DW_CFA_def_cfa_register, reg */
338 case 0x08: /* v2: DW_CFA_same_value, reg */
339 case 0x07: /* v2: DW_CFA_undefined, reg */
340 oper1 = uleb_extract(&data[off], ndx);
341 dbg_print(0, MSG_ORIG(MSG_CFA_REG), PREFIX,
342 REGNAME(oper1, rbuf1));
343 break;
344
345
346 case 0x09: /* v2: DW_CFA_register, reg, reg */
347 oper1 = uleb_extract(&data[off], ndx);
348 oper2 = uleb_extract(&data[off], ndx);
349 dbg_print(0, MSG_ORIG(MSG_CFA_REG_REG), PREFIX,
350 REGNAME(oper1, rbuf1), REGNAME(oper2, rbuf2));
351 break;
352
353 case 0x0c: /* v2: DW_CFA_def_cfa, reg, offset */
354 oper1 = uleb_extract(&data[off], ndx);
355 oper2 = uleb_extract(&data[off], ndx);
356 dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLU), PREFIX,
357 REGNAME(oper1, rbuf1), EC_XWORD(oper2));
358 break;
359
360 case 0x0e: /* v2: DW_CFA_def_cfa_offset, offset */
361 oper1 = uleb_extract(&data[off], ndx);
362 dbg_print(0, MSG_ORIG(MSG_CFA_LLU), PREFIX,
363 EC_XWORD(oper1));
364 break;
365
366 case 0x0f: /* v3: DW_CFA_def_cfa_expression, blk */
367 oper1 = uleb_extract(&data[off], ndx);
368 dbg_print(0, MSG_ORIG(MSG_CFA_EBLK), PREFIX,
369 EC_XWORD(oper1));
370 /* We currently do not decode the expression block */
371 *ndx += oper1;
372 break;
373
374 case 0x10: /* v3: DW_CFA_expression, reg, blk */
375 case 0x16: /* v3: DW_CFA_val_expression,reg,blk */
376 oper1 = uleb_extract(&data[off], ndx);
377 oper2 = uleb_extract(&data[off], ndx);
378 dbg_print(0, MSG_ORIG(MSG_CFA_REG_EBLK), PREFIX,
379 REGNAME(oper1, rbuf1), EC_XWORD(oper2));
380 /* We currently do not decode the expression block */
381 *ndx += oper2;
382 break;
383
384 case 0x11: /* v3: DW_CFA_offset_extended_sf, reg, off */
385 oper1 = uleb_extract(&data[off], ndx);
386 soper = sleb_extract(&data[off], ndx) *
387 state->ciedalign;
388 dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX,
389 REGNAME(oper1, rbuf1), EC_SXWORD(soper));
390 break;
391
392 case 0x12: /* v3: DW_CFA_def_cfa_sf, reg, offset */
393 oper1 = uleb_extract(&data[off], ndx);
394 soper = sleb_extract(&data[off], ndx) *
395 state->ciedalign;
396 dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLD), PREFIX,
397 REGNAME(oper1, rbuf1), EC_SXWORD(soper));
398 break;
399
400 case 0x13: /* DW_CFA_def_cfa_offset_sf, offset */
401 soper = sleb_extract(&data[off], ndx) *
402 state->ciedalign;
403 dbg_print(0, MSG_ORIG(MSG_CFA_LLD), PREFIX,
404 EC_SXWORD(soper));
405 break;
406
407 case 0x14: /* v3: DW_CFA_val_offset, reg, offset */
408 oper1 = uleb_extract(&data[off], ndx);
409 soper = uleb_extract(&data[off], ndx) *
410 state->ciedalign;
411 dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLD), PREFIX,
412 REGNAME(oper1, rbuf1), EC_SXWORD(soper));
413 break;
414
415 case 0x15: /* v3: DW_CFA_val_offset_sf, reg, offset */
416 oper1 = uleb_extract(&data[off], ndx);
417 soper = sleb_extract(&data[off], ndx) *
418 state->ciedalign;
419 dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLD), PREFIX,
420 REGNAME(oper1, rbuf1), EC_SXWORD(soper));
421 break;
422
423 case 0x1d: /* GNU: DW_CFA_MIPS_advance_loc8, delta */
424 oper1 = dwarf_extract_uint(data + off, ndx, i,
425 state->do_swap) * state->ciecalign;
426 cur_pc += oper1;
427 dbg_print(0, MSG_ORIG(MSG_CFA_ADV_LOC), PREFIX,
428 loc_str, EC_XWORD(oper1), EC_XWORD(cur_pc));
429 loc_str = MSG_ORIG(MSG_STR_LOC);
430 break;
431
432 case 0x2e: /* GNU: DW_CFA_GNU_args_size, size */
433 oper1 = uleb_extract(&data[off], ndx);
434 dbg_print(0, MSG_ORIG(MSG_CFA_LLU), PREFIX,
435 EC_XWORD(oper1));
436
437 break;
438
439 case 0x2f: /* GNU:DW_CFA_GNU_negative_offset_extended,reg,off */
440 oper1 = uleb_extract(&data[off], ndx);
441 soper = -uleb_extract(&data[off], ndx) *
442 state->ciedalign;
443 dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX,
444 REGNAME(oper1, rbuf1), EC_SXWORD(soper));
445 break;
446
447 default:
448 /*
449 * Unrecognized OP code: DWARF data is variable length,
450 * so we don't know how many bytes to skip in order to
451 * advance to the next item. We cannot decode beyond
452 * this point, so dump the remainder in hex.
453 */
454 (*ndx)--; /* Back up to unrecognized opcode */
455 dump_hex_bytes(data + off + *ndx, len - *ndx,
456 indent, 8, 1);
457 (*ndx) = len;
458 break;
459 }
460 }
461
462 #undef PREFIX
463 #undef REGNAME
464 #undef LOW_OP
465 }
466
467 void
468 dump_eh_frame(uchar_t *data, size_t datasize, uint64_t sh_addr,
469 Half e_machine, uchar_t *e_ident, uint64_t gotaddr)
470 {
471 Conv_dwarf_ehe_buf_t dwarf_ehe_buf;
472 dump_cfi_state_t cfi_state;
473 uint64_t off, ndx;
474 uint_t cieid, cielength, cieversion, cieretaddr;
475 int ciePflag, cieZflag, cieLflag, cieLflag_present;
476 uint_t cieaugndx, length, id;
477 char *cieaugstr;
478
479 cfi_state.e_machine = e_machine;
480 cfi_state.e_ident = e_ident;
481 cfi_state.sh_addr = sh_addr;
482 cfi_state.do_swap = _elf_sys_encoding() != e_ident[EI_DATA];
483 cfi_state.gotaddr = gotaddr;
484
485 off = 0;
486 while (off < datasize) {
487 ndx = 0;
488
489 /*
490 * Extract length in native format. A zero length indicates
491 * that this CIE is a terminator and that processing for this
492 * unwind information should end. However, skip this entry and
493 * keep processing, just in case there is any other information
494 * remaining in this section. Note, ld(1) will terminate the
495 * processing of the .eh_frame contents for this file after a
496 * zero length CIE, thus any information that does follow is
497 * ignored by ld(1), and is therefore questionable.
498 */
499 length = (uint_t)dwarf_extract_uint(data + off, &ndx,
500 4, cfi_state.do_swap);
501 if (length == 0) {
502 dbg_print(0, MSG_ORIG(MSG_UNW_ZEROTERM));
503 off += 4;
504 continue;
505 }
506
507 /*
508 * extract CIE id in native format
509 */
510 id = (uint_t)dwarf_extract_uint(data + off, &ndx,
511 4, cfi_state.do_swap);
512
513 /*
514 * A CIE record has an id of '0', otherwise this is a
515 * FDE entry and the 'id' is the CIE pointer.
516 */
517 if (id == 0) {
518 uint64_t persVal, ndx_save;
519 uint_t axsize;
520
521 cielength = length;
522 cieid = id;
523 ciePflag = cfi_state.cieRflag = cieZflag = 0;
524 cieLflag = cieLflag_present = 0;
525
526 dbg_print(0, MSG_ORIG(MSG_UNW_CIE),
527 EC_XWORD(sh_addr + off));
528 dbg_print(0, MSG_ORIG(MSG_UNW_CIELNGTH),
529 cielength, cieid);
530
531 cieversion = data[off + ndx];
532 ndx += 1;
533 cieaugstr = (char *)(&data[off + ndx]);
534 ndx += strlen(cieaugstr) + 1;
535
536 dbg_print(0, MSG_ORIG(MSG_UNW_CIEVERS),
537 cieversion, cieaugstr);
538
539 cfi_state.ciecalign = uleb_extract(&data[off], &ndx);
540 cfi_state.ciedalign = sleb_extract(&data[off], &ndx);
541 cieretaddr = data[off + ndx];
542 ndx += 1;
543
544 dbg_print(0, MSG_ORIG(MSG_UNW_CIECALGN),
545 EC_XWORD(cfi_state.ciecalign),
546 EC_XWORD(cfi_state.ciedalign), cieretaddr);
547
548 if (cieaugstr[0])
549 dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXVAL));
550
551 for (cieaugndx = 0; cieaugstr[cieaugndx]; cieaugndx++) {
552 switch (cieaugstr[cieaugndx]) {
553 case 'z':
554 axsize = uleb_extract(&data[off], &ndx);
555 dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXSIZ),
556 axsize);
557 cieZflag = 1;
558 /*
559 * The auxiliary section can contain
560 * unused padding bytes at the end, so
561 * save the current index. Along with
562 * axsize, we will use it to set ndx to
563 * the proper continuation index after
564 * the aux data has been processed.
565 */
566 ndx_save = ndx;
567 break;
568 case 'P':
569 ciePflag = data[off + ndx];
570 ndx += 1;
571
572 persVal = dwarf_ehe_extract(&data[off],
573 &ndx, ciePflag, e_ident, B_FALSE,
574 sh_addr, off + ndx, gotaddr);
575 dbg_print(0,
576 MSG_ORIG(MSG_UNW_CIEAXPERS));
577 dbg_print(0,
578 MSG_ORIG(MSG_UNW_CIEAXPERSENC),
579 ciePflag, conv_dwarf_ehe(ciePflag,
580 &dwarf_ehe_buf));
581 dbg_print(0,
582 MSG_ORIG(MSG_UNW_CIEAXPERSRTN),
583 EC_XWORD(persVal));
584 break;
585 case 'R':
586 cfi_state.cieRflag = data[off + ndx];
587 ndx += 1;
588 dbg_print(0,
589 MSG_ORIG(MSG_UNW_CIEAXCENC),
590 cfi_state.cieRflag,
591 conv_dwarf_ehe(cfi_state.cieRflag,
592 &dwarf_ehe_buf));
593 break;
594 case 'L':
595 cieLflag_present = 1;
596 cieLflag = data[off + ndx];
597 ndx += 1;
598 dbg_print(0,
599 MSG_ORIG(MSG_UNW_CIEAXLSDA),
600 cieLflag, conv_dwarf_ehe(
601 cieLflag, &dwarf_ehe_buf));
602 break;
603 default:
604 dbg_print(0,
605 MSG_ORIG(MSG_UNW_CIEAXUNEC),
606 cieaugstr[cieaugndx]);
607 break;
608 }
609 }
610
611 /*
612 * If the z flag was present, reposition ndx using the
613 * length given. This will safely move us past any
614 * unaccessed padding bytes in the auxiliary section.
615 */
616 if (cieZflag)
617 ndx = ndx_save + axsize;
618
619 /*
620 * Any remaining data are Call Frame Instructions
621 */
622 if ((cielength + 4) > ndx)
623 dump_cfi(data, off, &ndx, cielength, &cfi_state,
624 MSG_ORIG(MSG_UNW_CIECFI), 3);
625 off += cielength + 4;
626
627 } else {
628 uint_t fdelength = length;
629 int fdecieptr = id;
630 uint64_t fdeaddrrange;
631
632 dbg_print(0, MSG_ORIG(MSG_UNW_FDE),
633 EC_XWORD(sh_addr + off));
634 dbg_print(0, MSG_ORIG(MSG_UNW_FDELNGTH),
635 fdelength, fdecieptr);
636
637 cfi_state.fdeinitloc = dwarf_ehe_extract(&data[off],
638 &ndx, cfi_state.cieRflag, e_ident, B_FALSE,
639 sh_addr, off + ndx, gotaddr);
640 fdeaddrrange = dwarf_ehe_extract(&data[off], &ndx,
641 (cfi_state.cieRflag & ~DW_EH_PE_pcrel),
642 e_ident, B_FALSE, sh_addr, off + ndx, gotaddr);
643
644 dbg_print(0, MSG_ORIG(MSG_UNW_FDEINITLOC),
645 EC_XWORD(cfi_state.fdeinitloc),
646 EC_XWORD(fdeaddrrange),
647 EC_XWORD(cfi_state.fdeinitloc + fdeaddrrange - 1));
648
649 if (cieaugstr[0])
650 dbg_print(0, MSG_ORIG(MSG_UNW_FDEAXVAL));
651 if (cieZflag) {
652 uint64_t val;
653 uint64_t lndx;
654
655 val = uleb_extract(&data[off], &ndx);
656 lndx = ndx;
657 ndx += val;
658 dbg_print(0, MSG_ORIG(MSG_UNW_FDEAXSIZE),
659 EC_XWORD(val));
660 if (val && cieLflag_present) {
661 uint64_t lsda;
662
663 lsda = dwarf_ehe_extract(&data[off],
664 &lndx, cieLflag, e_ident,
665 B_FALSE, sh_addr, off + lndx,
666 gotaddr);
667 dbg_print(0,
668 MSG_ORIG(MSG_UNW_FDEAXLSDA),
669 EC_XWORD(lsda));
670 }
671 }
672 if ((fdelength + 4) > ndx)
673 dump_cfi(data, off, &ndx, fdelength, &cfi_state,
674 MSG_ORIG(MSG_UNW_FDECFI), 6);
675 off += fdelength + 4;
676 }
677 }
678 }