1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/common.h"
27 #include "elf/dwarf2.h"
30 static int have_frame_base
;
31 static int need_base_address
;
33 static unsigned int last_pointer_size
= 0;
34 static int warned_about_missing_comp_units
= FALSE
;
36 static unsigned int num_debug_info_entries
= 0;
37 static debug_info
*debug_information
= NULL
;
38 /* Special value for num_debug_info_entries to indicate
39 that the .debug_info section could not be loaded/parsed. */
40 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
47 int do_debug_pubnames
;
51 int do_debug_frames_interp
;
57 /* Values for do_debug_lines. */
58 #define FLAG_DEBUG_LINES_RAW 1
59 #define FLAG_DEBUG_LINES_DECODED 2
61 dwarf_vma (*byte_get
) (unsigned char *, int);
64 byte_get_little_endian (unsigned char *field
, int size
)
72 return ((unsigned int) (field
[0]))
73 | (((unsigned int) (field
[1])) << 8);
76 return ((unsigned long) (field
[0]))
77 | (((unsigned long) (field
[1])) << 8)
78 | (((unsigned long) (field
[2])) << 16)
79 | (((unsigned long) (field
[3])) << 24);
82 if (sizeof (dwarf_vma
) == 8)
83 return ((dwarf_vma
) (field
[0]))
84 | (((dwarf_vma
) (field
[1])) << 8)
85 | (((dwarf_vma
) (field
[2])) << 16)
86 | (((dwarf_vma
) (field
[3])) << 24)
87 | (((dwarf_vma
) (field
[4])) << 32)
88 | (((dwarf_vma
) (field
[5])) << 40)
89 | (((dwarf_vma
) (field
[6])) << 48)
90 | (((dwarf_vma
) (field
[7])) << 56);
91 else if (sizeof (dwarf_vma
) == 4)
92 /* We want to extract data from an 8 byte wide field and
93 place it into a 4 byte wide field. Since this is a little
94 endian source we can just use the 4 byte extraction code. */
95 return ((unsigned long) (field
[0]))
96 | (((unsigned long) (field
[1])) << 8)
97 | (((unsigned long) (field
[2])) << 16)
98 | (((unsigned long) (field
[3])) << 24);
101 error (_("Unhandled data length: %d\n"), size
);
107 byte_get_big_endian (unsigned char *field
, int size
)
115 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
118 return ((unsigned long) (field
[3]))
119 | (((unsigned long) (field
[2])) << 8)
120 | (((unsigned long) (field
[1])) << 16)
121 | (((unsigned long) (field
[0])) << 24);
124 if (sizeof (dwarf_vma
) == 8)
125 return ((dwarf_vma
) (field
[7]))
126 | (((dwarf_vma
) (field
[6])) << 8)
127 | (((dwarf_vma
) (field
[5])) << 16)
128 | (((dwarf_vma
) (field
[4])) << 24)
129 | (((dwarf_vma
) (field
[3])) << 32)
130 | (((dwarf_vma
) (field
[2])) << 40)
131 | (((dwarf_vma
) (field
[1])) << 48)
132 | (((dwarf_vma
) (field
[0])) << 56);
133 else if (sizeof (dwarf_vma
) == 4)
135 /* Although we are extracing data from an 8 byte wide field,
136 we are returning only 4 bytes of data. */
138 return ((unsigned long) (field
[3]))
139 | (((unsigned long) (field
[2])) << 8)
140 | (((unsigned long) (field
[1])) << 16)
141 | (((unsigned long) (field
[0])) << 24);
145 error (_("Unhandled data length: %d\n"), size
);
151 byte_get_signed (unsigned char *field
, int size
)
153 dwarf_vma x
= byte_get (field
, size
);
158 return (x
^ 0x80) - 0x80;
160 return (x
^ 0x8000) - 0x8000;
162 return (x
^ 0x80000000) - 0x80000000;
171 size_of_encoded_value (int encoding
)
173 switch (encoding
& 0x7)
176 case 0: return eh_addr_size
;
184 get_encoded_value (unsigned char *data
, int encoding
)
186 int size
= size_of_encoded_value (encoding
);
188 if (encoding
& DW_EH_PE_signed
)
189 return byte_get_signed (data
, size
);
191 return byte_get (data
, size
);
194 /* Print a dwarf_vma value (typically an address, offset or length) in
195 hexadecimal format, followed by a space. The length of the value (and
196 hence the precision displayed) is determined by the byte_size parameter. */
199 print_dwarf_vma (dwarf_vma val
, unsigned byte_size
)
201 static char buff
[18];
203 /* Printf does not have a way of specifiying a maximum field width for an
204 integer value, so we print the full value into a buffer and then select
205 the precision we need. */
206 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
208 snprintf (buff
, sizeof (buff
), "%16.16llx ", val
);
210 snprintf (buff
, sizeof (buff
), "%016I64x ", val
);
213 snprintf (buff
, sizeof (buff
), "%16.16lx ", val
);
216 fputs (buff
+ (byte_size
== 4 ? 8 : 0), stdout
);
219 static unsigned long int
220 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
222 unsigned long int result
= 0;
223 unsigned int num_read
= 0;
224 unsigned int shift
= 0;
232 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
239 if (length_return
!= NULL
)
240 *length_return
= num_read
;
242 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
243 result
|= -1L << shift
;
248 typedef struct State_Machine_Registers
250 unsigned long address
;
257 /* This variable hold the number of the last entry seen
258 in the File Table. */
259 unsigned int last_file_entry
;
262 static SMR state_machine_regs
;
265 reset_state_machine (int is_stmt
)
267 state_machine_regs
.address
= 0;
268 state_machine_regs
.file
= 1;
269 state_machine_regs
.line
= 1;
270 state_machine_regs
.column
= 0;
271 state_machine_regs
.is_stmt
= is_stmt
;
272 state_machine_regs
.basic_block
= 0;
273 state_machine_regs
.end_sequence
= 0;
274 state_machine_regs
.last_file_entry
= 0;
277 /* Handled an extend line op.
278 Returns the number of bytes read. */
281 process_extended_line_op (unsigned char *data
, int is_stmt
)
283 unsigned char op_code
;
284 unsigned int bytes_read
;
289 len
= read_leb128 (data
, & bytes_read
, 0);
294 warn (_("badly formed extended line op encountered!\n"));
301 printf (_(" Extended opcode %d: "), op_code
);
305 case DW_LNE_end_sequence
:
306 printf (_("End of Sequence\n\n"));
307 reset_state_machine (is_stmt
);
310 case DW_LNE_set_address
:
311 adr
= byte_get (data
, len
- bytes_read
- 1);
312 printf (_("set Address to 0x%lx\n"), adr
);
313 state_machine_regs
.address
= adr
;
316 case DW_LNE_define_file
:
317 printf (_(" define new File Table entry\n"));
318 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
320 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
322 data
+= strlen ((char *) data
) + 1;
323 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
325 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
327 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
328 printf (_("%s\n\n"), name
);
332 case DW_LNE_HP_negate_is_UV_update
:
333 printf ("DW_LNE_HP_negate_is_UV_update");
335 case DW_LNE_HP_push_context
:
336 printf ("DW_LNE_HP_push_context");
338 case DW_LNE_HP_pop_context
:
339 printf ("DW_LNE_HP_pop_context");
341 case DW_LNE_HP_set_file_line_column
:
342 printf ("DW_LNE_HP_set_file_line_column");
344 case DW_LNE_HP_set_routine_name
:
345 printf ("DW_LNE_HP_set_routine_name");
347 case DW_LNE_HP_set_sequence
:
348 printf ("DW_LNE_HP_set_sequence");
350 case DW_LNE_HP_negate_post_semantics
:
351 printf ("DW_LNE_HP_negate_post_semantics");
353 case DW_LNE_HP_negate_function_exit
:
354 printf ("DW_LNE_HP_negate_function_exit");
356 case DW_LNE_HP_negate_front_end_logical
:
357 printf ("DW_LNE_HP_negate_front_end_logical");
359 case DW_LNE_HP_define_proc
:
360 printf ("DW_LNE_HP_define_proc");
364 if (op_code
>= DW_LNE_lo_user
365 /* The test against DW_LNW_hi_user is redundant due to
366 the limited range of the unsigned char data type used
368 /*&& op_code <= DW_LNE_hi_user*/)
369 printf (_("user defined: length %d\n"), len
- bytes_read
);
371 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
379 fetch_indirect_string (unsigned long offset
)
381 struct dwarf_section
*section
= &debug_displays
[str
].section
;
383 if (section
->start
== NULL
)
384 return _("<no .debug_str section>");
386 /* DWARF sections under Mach-O have non-zero addresses. */
387 offset
-= section
->address
;
388 if (offset
> section
->size
)
390 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
391 return _("<offset is too big>");
394 return (const char *) section
->start
+ offset
;
397 /* FIXME: There are better and more efficient ways to handle
398 these structures. For now though, I just want something that
399 is simple to implement. */
400 typedef struct abbrev_attr
402 unsigned long attribute
;
404 struct abbrev_attr
*next
;
408 typedef struct abbrev_entry
413 struct abbrev_attr
*first_attr
;
414 struct abbrev_attr
*last_attr
;
415 struct abbrev_entry
*next
;
419 static abbrev_entry
*first_abbrev
= NULL
;
420 static abbrev_entry
*last_abbrev
= NULL
;
425 abbrev_entry
*abbrev
;
427 for (abbrev
= first_abbrev
; abbrev
;)
429 abbrev_entry
*next
= abbrev
->next
;
432 for (attr
= abbrev
->first_attr
; attr
;)
434 abbrev_attr
*next
= attr
->next
;
444 last_abbrev
= first_abbrev
= NULL
;
448 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
452 entry
= malloc (sizeof (*entry
));
458 entry
->entry
= number
;
460 entry
->children
= children
;
461 entry
->first_attr
= NULL
;
462 entry
->last_attr
= NULL
;
465 if (first_abbrev
== NULL
)
466 first_abbrev
= entry
;
468 last_abbrev
->next
= entry
;
474 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
478 attr
= malloc (sizeof (*attr
));
484 attr
->attribute
= attribute
;
488 if (last_abbrev
->first_attr
== NULL
)
489 last_abbrev
->first_attr
= attr
;
491 last_abbrev
->last_attr
->next
= attr
;
493 last_abbrev
->last_attr
= attr
;
496 /* Processes the (partial) contents of a .debug_abbrev section.
497 Returns NULL if the end of the section was encountered.
498 Returns the address after the last byte read if the end of
499 an abbreviation set was found. */
501 static unsigned char *
502 process_abbrev_section (unsigned char *start
, unsigned char *end
)
504 if (first_abbrev
!= NULL
)
509 unsigned int bytes_read
;
512 unsigned long attribute
;
515 entry
= read_leb128 (start
, & bytes_read
, 0);
518 /* A single zero is supposed to end the section according
519 to the standard. If there's more, then signal that to
522 return start
== end
? NULL
: start
;
524 tag
= read_leb128 (start
, & bytes_read
, 0);
529 add_abbrev (entry
, tag
, children
);
535 attribute
= read_leb128 (start
, & bytes_read
, 0);
538 form
= read_leb128 (start
, & bytes_read
, 0);
542 add_abbrev_attr (attribute
, form
);
544 while (attribute
!= 0);
551 get_TAG_name (unsigned long tag
)
555 case DW_TAG_padding
: return "DW_TAG_padding";
556 case DW_TAG_array_type
: return "DW_TAG_array_type";
557 case DW_TAG_class_type
: return "DW_TAG_class_type";
558 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
559 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
560 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
561 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
562 case DW_TAG_label
: return "DW_TAG_label";
563 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
564 case DW_TAG_member
: return "DW_TAG_member";
565 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
566 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
567 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
568 case DW_TAG_string_type
: return "DW_TAG_string_type";
569 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
570 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
571 case DW_TAG_typedef
: return "DW_TAG_typedef";
572 case DW_TAG_union_type
: return "DW_TAG_union_type";
573 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
574 case DW_TAG_variant
: return "DW_TAG_variant";
575 case DW_TAG_common_block
: return "DW_TAG_common_block";
576 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
577 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
578 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
579 case DW_TAG_module
: return "DW_TAG_module";
580 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
581 case DW_TAG_set_type
: return "DW_TAG_set_type";
582 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
583 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
584 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
585 case DW_TAG_base_type
: return "DW_TAG_base_type";
586 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
587 case DW_TAG_const_type
: return "DW_TAG_const_type";
588 case DW_TAG_constant
: return "DW_TAG_constant";
589 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
590 case DW_TAG_file_type
: return "DW_TAG_file_type";
591 case DW_TAG_friend
: return "DW_TAG_friend";
592 case DW_TAG_namelist
: return "DW_TAG_namelist";
593 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
594 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
595 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
596 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
597 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
598 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
599 case DW_TAG_try_block
: return "DW_TAG_try_block";
600 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
601 case DW_TAG_variable
: return "DW_TAG_variable";
602 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
603 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
604 case DW_TAG_format_label
: return "DW_TAG_format_label";
605 case DW_TAG_function_template
: return "DW_TAG_function_template";
606 case DW_TAG_class_template
: return "DW_TAG_class_template";
607 /* DWARF 2.1 values. */
608 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
609 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
610 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
611 case DW_TAG_namespace
: return "DW_TAG_namespace";
612 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
613 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
614 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
615 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
617 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
618 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
619 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
622 static char buffer
[100];
624 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
631 get_FORM_name (unsigned long form
)
635 case DW_FORM_addr
: return "DW_FORM_addr";
636 case DW_FORM_block2
: return "DW_FORM_block2";
637 case DW_FORM_block4
: return "DW_FORM_block4";
638 case DW_FORM_data2
: return "DW_FORM_data2";
639 case DW_FORM_data4
: return "DW_FORM_data4";
640 case DW_FORM_data8
: return "DW_FORM_data8";
641 case DW_FORM_string
: return "DW_FORM_string";
642 case DW_FORM_block
: return "DW_FORM_block";
643 case DW_FORM_block1
: return "DW_FORM_block1";
644 case DW_FORM_data1
: return "DW_FORM_data1";
645 case DW_FORM_flag
: return "DW_FORM_flag";
646 case DW_FORM_sdata
: return "DW_FORM_sdata";
647 case DW_FORM_strp
: return "DW_FORM_strp";
648 case DW_FORM_udata
: return "DW_FORM_udata";
649 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
650 case DW_FORM_ref1
: return "DW_FORM_ref1";
651 case DW_FORM_ref2
: return "DW_FORM_ref2";
652 case DW_FORM_ref4
: return "DW_FORM_ref4";
653 case DW_FORM_ref8
: return "DW_FORM_ref8";
654 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
655 case DW_FORM_indirect
: return "DW_FORM_indirect";
658 static char buffer
[100];
660 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
666 static unsigned char *
667 display_block (unsigned char *data
, unsigned long length
)
669 printf (_(" %lu byte block: "), length
);
672 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
678 decode_location_expression (unsigned char * data
,
679 unsigned int pointer_size
,
680 unsigned long length
,
681 unsigned long cu_offset
,
682 struct dwarf_section
* section
)
685 unsigned int bytes_read
;
686 unsigned long uvalue
;
687 unsigned char *end
= data
+ length
;
688 int need_frame_base
= 0;
697 printf ("DW_OP_addr: %lx",
698 (unsigned long) byte_get (data
, pointer_size
));
699 data
+= pointer_size
;
702 printf ("DW_OP_deref");
705 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
708 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
711 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
715 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
719 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
723 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
727 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
728 (unsigned long) byte_get (data
+ 4, 4));
732 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
733 (long) byte_get (data
+ 4, 4));
737 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
741 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
745 printf ("DW_OP_dup");
748 printf ("DW_OP_drop");
751 printf ("DW_OP_over");
754 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
757 printf ("DW_OP_swap");
760 printf ("DW_OP_rot");
763 printf ("DW_OP_xderef");
766 printf ("DW_OP_abs");
769 printf ("DW_OP_and");
772 printf ("DW_OP_div");
775 printf ("DW_OP_minus");
778 printf ("DW_OP_mod");
781 printf ("DW_OP_mul");
784 printf ("DW_OP_neg");
787 printf ("DW_OP_not");
793 printf ("DW_OP_plus");
795 case DW_OP_plus_uconst
:
796 printf ("DW_OP_plus_uconst: %lu",
797 read_leb128 (data
, &bytes_read
, 0));
801 printf ("DW_OP_shl");
804 printf ("DW_OP_shr");
807 printf ("DW_OP_shra");
810 printf ("DW_OP_xor");
813 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
835 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
871 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
906 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
941 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
942 read_leb128 (data
, &bytes_read
, 1));
947 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
952 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
956 uvalue
= read_leb128 (data
, &bytes_read
, 0);
958 printf ("DW_OP_bregx: %lu %ld", uvalue
,
959 read_leb128 (data
, &bytes_read
, 1));
963 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
966 case DW_OP_deref_size
:
967 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
969 case DW_OP_xderef_size
:
970 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
973 printf ("DW_OP_nop");
976 /* DWARF 3 extensions. */
977 case DW_OP_push_object_address
:
978 printf ("DW_OP_push_object_address");
981 /* XXX: Strictly speaking for 64-bit DWARF3 files
982 this ought to be an 8-byte wide computation. */
983 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
987 /* XXX: Strictly speaking for 64-bit DWARF3 files
988 this ought to be an 8-byte wide computation. */
989 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
993 /* XXX: Strictly speaking for 64-bit DWARF3 files
994 this ought to be an 8-byte wide computation. */
995 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
998 case DW_OP_form_tls_address
:
999 printf ("DW_OP_form_tls_address");
1001 case DW_OP_call_frame_cfa
:
1002 printf ("DW_OP_call_frame_cfa");
1004 case DW_OP_bit_piece
:
1005 printf ("DW_OP_bit_piece: ");
1006 printf ("size: %lu ", read_leb128 (data
, &bytes_read
, 0));
1008 printf ("offset: %lu ", read_leb128 (data
, &bytes_read
, 0));
1012 /* GNU extensions. */
1013 case DW_OP_GNU_push_tls_address
:
1014 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1016 case DW_OP_GNU_uninit
:
1017 printf ("DW_OP_GNU_uninit");
1018 /* FIXME: Is there data associated with this OP ? */
1020 case DW_OP_GNU_encoded_addr
:
1026 addr
= get_encoded_value (data
, encoding
);
1027 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1028 addr
+= section
->address
+ (data
- section
->start
);
1029 data
+= size_of_encoded_value (encoding
);
1031 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1032 print_dwarf_vma (addr
, pointer_size
);
1036 /* HP extensions. */
1037 case DW_OP_HP_is_value
:
1038 printf ("DW_OP_HP_is_value");
1039 /* FIXME: Is there data associated with this OP ? */
1041 case DW_OP_HP_fltconst4
:
1042 printf ("DW_OP_HP_fltconst4");
1043 /* FIXME: Is there data associated with this OP ? */
1045 case DW_OP_HP_fltconst8
:
1046 printf ("DW_OP_HP_fltconst8");
1047 /* FIXME: Is there data associated with this OP ? */
1049 case DW_OP_HP_mod_range
:
1050 printf ("DW_OP_HP_mod_range");
1051 /* FIXME: Is there data associated with this OP ? */
1053 case DW_OP_HP_unmod_range
:
1054 printf ("DW_OP_HP_unmod_range");
1055 /* FIXME: Is there data associated with this OP ? */
1058 printf ("DW_OP_HP_tls");
1059 /* FIXME: Is there data associated with this OP ? */
1062 /* PGI (STMicroelectronics) extensions. */
1063 case DW_OP_PGI_omp_thread_num
:
1064 /* Pushes the thread number for the current thread as it would be
1065 returned by the standard OpenMP library function:
1066 omp_get_thread_num(). The "current thread" is the thread for
1067 which the expression is being evaluated. */
1068 printf ("DW_OP_PGI_omp_thread_num");
1072 if (op
>= DW_OP_lo_user
1073 && op
<= DW_OP_hi_user
)
1074 printf (_("(User defined location op)"));
1076 printf (_("(Unknown location op)"));
1077 /* No way to tell where the next op is, so just bail. */
1078 return need_frame_base
;
1081 /* Separate the ops. */
1086 return need_frame_base
;
1089 static unsigned char *
1090 read_and_display_attr_value (unsigned long attribute
,
1092 unsigned char * data
,
1093 unsigned long cu_offset
,
1094 unsigned long pointer_size
,
1095 unsigned long offset_size
,
1097 debug_info
* debug_info_p
,
1099 struct dwarf_section
* section
)
1101 unsigned long uvalue
= 0;
1102 unsigned char *block_start
= NULL
;
1103 unsigned char * orig_data
= data
;
1104 unsigned int bytes_read
;
1111 case DW_FORM_ref_addr
:
1112 if (dwarf_version
== 2)
1114 uvalue
= byte_get (data
, pointer_size
);
1115 data
+= pointer_size
;
1117 else if (dwarf_version
== 3)
1119 uvalue
= byte_get (data
, offset_size
);
1120 data
+= offset_size
;
1124 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1129 uvalue
= byte_get (data
, pointer_size
);
1130 data
+= pointer_size
;
1134 uvalue
= byte_get (data
, offset_size
);
1135 data
+= offset_size
;
1141 uvalue
= byte_get (data
++, 1);
1146 uvalue
= byte_get (data
, 2);
1152 uvalue
= byte_get (data
, 4);
1157 uvalue
= read_leb128 (data
, & bytes_read
, 1);
1161 case DW_FORM_ref_udata
:
1163 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1167 case DW_FORM_indirect
:
1168 form
= read_leb128 (data
, & bytes_read
, 0);
1171 printf (" %s", get_FORM_name (form
));
1172 return read_and_display_attr_value (attribute
, form
, data
,
1173 cu_offset
, pointer_size
,
1174 offset_size
, dwarf_version
,
1175 debug_info_p
, do_loc
,
1181 case DW_FORM_ref_addr
:
1183 printf (" <0x%lx>", uvalue
);
1189 case DW_FORM_ref_udata
:
1191 printf (" <0x%lx>", uvalue
+ cu_offset
);
1197 printf (" 0x%lx", uvalue
);
1206 printf (" %ld", uvalue
);
1213 uvalue
= byte_get (data
, 4);
1214 printf (" 0x%lx", uvalue
);
1215 printf (" 0x%lx", (unsigned long) byte_get (data
+ 4, 4));
1217 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1218 && num_debug_info_entries
== 0)
1220 if (sizeof (uvalue
) == 8)
1221 uvalue
= byte_get (data
, 8);
1223 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1228 case DW_FORM_string
:
1230 printf (" %s", data
);
1231 data
+= strlen ((char *) data
) + 1;
1235 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1236 block_start
= data
+ bytes_read
;
1238 data
= block_start
+ uvalue
;
1240 data
= display_block (block_start
, uvalue
);
1243 case DW_FORM_block1
:
1244 uvalue
= byte_get (data
, 1);
1245 block_start
= data
+ 1;
1247 data
= block_start
+ uvalue
;
1249 data
= display_block (block_start
, uvalue
);
1252 case DW_FORM_block2
:
1253 uvalue
= byte_get (data
, 2);
1254 block_start
= data
+ 2;
1256 data
= block_start
+ uvalue
;
1258 data
= display_block (block_start
, uvalue
);
1261 case DW_FORM_block4
:
1262 uvalue
= byte_get (data
, 4);
1263 block_start
= data
+ 4;
1265 data
= block_start
+ uvalue
;
1267 data
= display_block (block_start
, uvalue
);
1272 printf (_(" (indirect string, offset: 0x%lx): %s"),
1273 uvalue
, fetch_indirect_string (uvalue
));
1276 case DW_FORM_indirect
:
1277 /* Handled above. */
1281 warn (_("Unrecognized form: %lu\n"), form
);
1285 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1286 && num_debug_info_entries
== 0)
1290 case DW_AT_frame_base
:
1291 have_frame_base
= 1;
1292 case DW_AT_location
:
1293 case DW_AT_string_length
:
1294 case DW_AT_return_addr
:
1295 case DW_AT_data_member_location
:
1296 case DW_AT_vtable_elem_location
:
1298 case DW_AT_static_link
:
1299 case DW_AT_use_location
:
1300 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1302 /* Process location list. */
1303 unsigned int max
= debug_info_p
->max_loc_offsets
;
1304 unsigned int num
= debug_info_p
->num_loc_offsets
;
1306 if (max
== 0 || num
>= max
)
1309 debug_info_p
->loc_offsets
1310 = xcrealloc (debug_info_p
->loc_offsets
,
1311 max
, sizeof (*debug_info_p
->loc_offsets
));
1312 debug_info_p
->have_frame_base
1313 = xcrealloc (debug_info_p
->have_frame_base
,
1314 max
, sizeof (*debug_info_p
->have_frame_base
));
1315 debug_info_p
->max_loc_offsets
= max
;
1317 debug_info_p
->loc_offsets
[num
] = uvalue
;
1318 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1319 debug_info_p
->num_loc_offsets
++;
1324 if (need_base_address
)
1325 debug_info_p
->base_address
= uvalue
;
1329 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1331 /* Process range list. */
1332 unsigned int max
= debug_info_p
->max_range_lists
;
1333 unsigned int num
= debug_info_p
->num_range_lists
;
1335 if (max
== 0 || num
>= max
)
1338 debug_info_p
->range_lists
1339 = xcrealloc (debug_info_p
->range_lists
,
1340 max
, sizeof (*debug_info_p
->range_lists
));
1341 debug_info_p
->max_range_lists
= max
;
1343 debug_info_p
->range_lists
[num
] = uvalue
;
1344 debug_info_p
->num_range_lists
++;
1356 /* For some attributes we can display further information. */
1364 case DW_INL_not_inlined
:
1365 printf (_("(not inlined)"));
1367 case DW_INL_inlined
:
1368 printf (_("(inlined)"));
1370 case DW_INL_declared_not_inlined
:
1371 printf (_("(declared as inline but ignored)"));
1373 case DW_INL_declared_inlined
:
1374 printf (_("(declared as inline and inlined)"));
1377 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1382 case DW_AT_language
:
1385 /* Ordered by the numeric value of these constants. */
1386 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1387 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1388 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1389 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1390 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1391 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1392 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1393 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1394 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1395 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1396 /* DWARF 2.1 values. */
1397 case DW_LANG_Java
: printf ("(Java)"); break;
1398 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1399 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1400 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1401 /* DWARF 3 values. */
1402 case DW_LANG_PLI
: printf ("(PLI)"); break;
1403 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1404 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1405 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1406 case DW_LANG_D
: printf ("(D)"); break;
1407 /* MIPS extension. */
1408 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1409 /* UPC extension. */
1410 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1412 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1413 printf ("(implementation defined: %lx)", uvalue
);
1415 printf ("(Unknown: %lx)", uvalue
);
1420 case DW_AT_encoding
:
1423 case DW_ATE_void
: printf ("(void)"); break;
1424 case DW_ATE_address
: printf ("(machine address)"); break;
1425 case DW_ATE_boolean
: printf ("(boolean)"); break;
1426 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1427 case DW_ATE_float
: printf ("(float)"); break;
1428 case DW_ATE_signed
: printf ("(signed)"); break;
1429 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1430 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1431 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1432 /* DWARF 2.1 values: */
1433 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1434 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1435 /* DWARF 3 values: */
1436 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1437 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1438 case DW_ATE_edited
: printf ("(edited)"); break;
1439 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1440 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1441 /* HP extensions: */
1442 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1443 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1444 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1445 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1446 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1447 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1448 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1451 if (uvalue
>= DW_ATE_lo_user
1452 && uvalue
<= DW_ATE_hi_user
)
1453 printf ("(user defined type)");
1455 printf ("(unknown type)");
1460 case DW_AT_accessibility
:
1463 case DW_ACCESS_public
: printf ("(public)"); break;
1464 case DW_ACCESS_protected
: printf ("(protected)"); break;
1465 case DW_ACCESS_private
: printf ("(private)"); break;
1467 printf ("(unknown accessibility)");
1472 case DW_AT_visibility
:
1475 case DW_VIS_local
: printf ("(local)"); break;
1476 case DW_VIS_exported
: printf ("(exported)"); break;
1477 case DW_VIS_qualified
: printf ("(qualified)"); break;
1478 default: printf ("(unknown visibility)"); break;
1482 case DW_AT_virtuality
:
1485 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1486 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1487 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1488 default: printf ("(unknown virtuality)"); break;
1492 case DW_AT_identifier_case
:
1495 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1496 case DW_ID_up_case
: printf ("(up_case)"); break;
1497 case DW_ID_down_case
: printf ("(down_case)"); break;
1498 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1499 default: printf ("(unknown case)"); break;
1503 case DW_AT_calling_convention
:
1506 case DW_CC_normal
: printf ("(normal)"); break;
1507 case DW_CC_program
: printf ("(program)"); break;
1508 case DW_CC_nocall
: printf ("(nocall)"); break;
1510 if (uvalue
>= DW_CC_lo_user
1511 && uvalue
<= DW_CC_hi_user
)
1512 printf ("(user defined)");
1514 printf ("(unknown convention)");
1518 case DW_AT_ordering
:
1521 case -1: printf ("(undefined)"); break;
1522 case 0: printf ("(row major)"); break;
1523 case 1: printf ("(column major)"); break;
1527 case DW_AT_frame_base
:
1528 have_frame_base
= 1;
1529 case DW_AT_location
:
1530 case DW_AT_string_length
:
1531 case DW_AT_return_addr
:
1532 case DW_AT_data_member_location
:
1533 case DW_AT_vtable_elem_location
:
1535 case DW_AT_static_link
:
1536 case DW_AT_use_location
:
1537 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1538 printf (_("(location list)"));
1540 case DW_AT_allocated
:
1541 case DW_AT_associated
:
1542 case DW_AT_data_location
:
1544 case DW_AT_upper_bound
:
1545 case DW_AT_lower_bound
:
1548 int need_frame_base
;
1551 need_frame_base
= decode_location_expression (block_start
,
1554 cu_offset
, section
);
1556 if (need_frame_base
&& !have_frame_base
)
1557 printf (_(" [without DW_AT_frame_base]"));
1563 if (form
== DW_FORM_ref1
1564 || form
== DW_FORM_ref2
1565 || form
== DW_FORM_ref4
)
1566 uvalue
+= cu_offset
;
1568 if (uvalue
>= section
->size
)
1569 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1570 uvalue
, (unsigned long) (orig_data
- section
->start
));
1573 unsigned long abbrev_number
;
1574 abbrev_entry
* entry
;
1576 abbrev_number
= read_leb128 (section
->start
+ uvalue
, NULL
, 0);
1578 printf ("[Abbrev Number: %ld", abbrev_number
);
1579 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
1580 if (entry
->entry
== abbrev_number
)
1583 printf (" (%s)", get_TAG_name (entry
->tag
));
1597 get_AT_name (unsigned long attribute
)
1601 case DW_AT_sibling
: return "DW_AT_sibling";
1602 case DW_AT_location
: return "DW_AT_location";
1603 case DW_AT_name
: return "DW_AT_name";
1604 case DW_AT_ordering
: return "DW_AT_ordering";
1605 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1606 case DW_AT_byte_size
: return "DW_AT_byte_size";
1607 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1608 case DW_AT_bit_size
: return "DW_AT_bit_size";
1609 case DW_AT_element_list
: return "DW_AT_element_list";
1610 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1611 case DW_AT_low_pc
: return "DW_AT_low_pc";
1612 case DW_AT_high_pc
: return "DW_AT_high_pc";
1613 case DW_AT_language
: return "DW_AT_language";
1614 case DW_AT_member
: return "DW_AT_member";
1615 case DW_AT_discr
: return "DW_AT_discr";
1616 case DW_AT_discr_value
: return "DW_AT_discr_value";
1617 case DW_AT_visibility
: return "DW_AT_visibility";
1618 case DW_AT_import
: return "DW_AT_import";
1619 case DW_AT_string_length
: return "DW_AT_string_length";
1620 case DW_AT_common_reference
: return "DW_AT_common_reference";
1621 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1622 case DW_AT_const_value
: return "DW_AT_const_value";
1623 case DW_AT_containing_type
: return "DW_AT_containing_type";
1624 case DW_AT_default_value
: return "DW_AT_default_value";
1625 case DW_AT_inline
: return "DW_AT_inline";
1626 case DW_AT_is_optional
: return "DW_AT_is_optional";
1627 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1628 case DW_AT_producer
: return "DW_AT_producer";
1629 case DW_AT_prototyped
: return "DW_AT_prototyped";
1630 case DW_AT_return_addr
: return "DW_AT_return_addr";
1631 case DW_AT_start_scope
: return "DW_AT_start_scope";
1632 case DW_AT_stride_size
: return "DW_AT_stride_size";
1633 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1634 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1635 case DW_AT_accessibility
: return "DW_AT_accessibility";
1636 case DW_AT_address_class
: return "DW_AT_address_class";
1637 case DW_AT_artificial
: return "DW_AT_artificial";
1638 case DW_AT_base_types
: return "DW_AT_base_types";
1639 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1640 case DW_AT_count
: return "DW_AT_count";
1641 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1642 case DW_AT_decl_column
: return "DW_AT_decl_column";
1643 case DW_AT_decl_file
: return "DW_AT_decl_file";
1644 case DW_AT_decl_line
: return "DW_AT_decl_line";
1645 case DW_AT_declaration
: return "DW_AT_declaration";
1646 case DW_AT_discr_list
: return "DW_AT_discr_list";
1647 case DW_AT_encoding
: return "DW_AT_encoding";
1648 case DW_AT_external
: return "DW_AT_external";
1649 case DW_AT_frame_base
: return "DW_AT_frame_base";
1650 case DW_AT_friend
: return "DW_AT_friend";
1651 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1652 case DW_AT_macro_info
: return "DW_AT_macro_info";
1653 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1654 case DW_AT_priority
: return "DW_AT_priority";
1655 case DW_AT_segment
: return "DW_AT_segment";
1656 case DW_AT_specification
: return "DW_AT_specification";
1657 case DW_AT_static_link
: return "DW_AT_static_link";
1658 case DW_AT_type
: return "DW_AT_type";
1659 case DW_AT_use_location
: return "DW_AT_use_location";
1660 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1661 case DW_AT_virtuality
: return "DW_AT_virtuality";
1662 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1663 /* DWARF 2.1 values. */
1664 case DW_AT_allocated
: return "DW_AT_allocated";
1665 case DW_AT_associated
: return "DW_AT_associated";
1666 case DW_AT_data_location
: return "DW_AT_data_location";
1667 case DW_AT_stride
: return "DW_AT_stride";
1668 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1669 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1670 case DW_AT_extension
: return "DW_AT_extension";
1671 case DW_AT_ranges
: return "DW_AT_ranges";
1672 case DW_AT_trampoline
: return "DW_AT_trampoline";
1673 case DW_AT_call_column
: return "DW_AT_call_column";
1674 case DW_AT_call_file
: return "DW_AT_call_file";
1675 case DW_AT_call_line
: return "DW_AT_call_line";
1676 case DW_AT_description
: return "DW_AT_description";
1677 case DW_AT_binary_scale
: return "DW_AT_binary_scale";
1678 case DW_AT_decimal_scale
: return "DW_AT_decimal_scale";
1679 case DW_AT_small
: return "DW_AT_small";
1680 case DW_AT_decimal_sign
: return "DW_AT_decimal_sign";
1681 case DW_AT_digit_count
: return "DW_AT_digit_count";
1682 case DW_AT_picture_string
: return "DW_AT_picture_string";
1683 case DW_AT_mutable
: return "DW_AT_mutable";
1684 case DW_AT_threads_scaled
: return "DW_AT_threads_scaled";
1685 case DW_AT_explicit
: return "DW_AT_explicit";
1686 case DW_AT_object_pointer
: return "DW_AT_object_pointer";
1687 case DW_AT_endianity
: return "DW_AT_endianity";
1688 case DW_AT_elemental
: return "DW_AT_elemental";
1689 case DW_AT_pure
: return "DW_AT_pure";
1690 case DW_AT_recursive
: return "DW_AT_recursive";
1692 /* HP and SGI/MIPS extensions. */
1693 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1694 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1695 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1696 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1697 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
1698 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1699 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1700 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1701 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1702 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1704 /* HP Extensions. */
1705 case DW_AT_HP_block_index
: return "DW_AT_HP_block_index";
1706 case DW_AT_HP_actuals_stmt_list
: return "DW_AT_HP_actuals_stmt_list";
1707 case DW_AT_HP_proc_per_section
: return "DW_AT_HP_proc_per_section";
1708 case DW_AT_HP_raw_data_ptr
: return "DW_AT_HP_raw_data_ptr";
1709 case DW_AT_HP_pass_by_reference
: return "DW_AT_HP_pass_by_reference";
1710 case DW_AT_HP_opt_level
: return "DW_AT_HP_opt_level";
1711 case DW_AT_HP_prof_version_id
: return "DW_AT_HP_prof_version_id";
1712 case DW_AT_HP_opt_flags
: return "DW_AT_HP_opt_flags";
1713 case DW_AT_HP_cold_region_low_pc
: return "DW_AT_HP_cold_region_low_pc";
1714 case DW_AT_HP_cold_region_high_pc
: return "DW_AT_HP_cold_region_high_pc";
1715 case DW_AT_HP_all_variables_modifiable
: return "DW_AT_HP_all_variables_modifiable";
1716 case DW_AT_HP_linkage_name
: return "DW_AT_HP_linkage_name";
1717 case DW_AT_HP_prof_flags
: return "DW_AT_HP_prof_flags";
1719 /* One value is shared by the MIPS and HP extensions: */
1720 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1722 /* GNU extensions. */
1723 case DW_AT_sf_names
: return "DW_AT_sf_names";
1724 case DW_AT_src_info
: return "DW_AT_src_info";
1725 case DW_AT_mac_info
: return "DW_AT_mac_info";
1726 case DW_AT_src_coords
: return "DW_AT_src_coords";
1727 case DW_AT_body_begin
: return "DW_AT_body_begin";
1728 case DW_AT_body_end
: return "DW_AT_body_end";
1729 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1731 /* UPC extension. */
1732 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1734 /* PGI (STMicroelectronics) extensions. */
1735 case DW_AT_PGI_lbase
: return "DW_AT_PGI_lbase";
1736 case DW_AT_PGI_soffset
: return "DW_AT_PGI_soffset";
1737 case DW_AT_PGI_lstride
: return "DW_AT_PGI_lstride";
1741 static char buffer
[100];
1743 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1750 static unsigned char *
1751 read_and_display_attr (unsigned long attribute
,
1753 unsigned char * data
,
1754 unsigned long cu_offset
,
1755 unsigned long pointer_size
,
1756 unsigned long offset_size
,
1758 debug_info
* debug_info_p
,
1760 struct dwarf_section
* section
)
1763 printf (" %-18s:", get_AT_name (attribute
));
1764 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1765 pointer_size
, offset_size
,
1766 dwarf_version
, debug_info_p
,
1774 /* Process the contents of a .debug_info section. If do_loc is non-zero
1775 then we are scanning for location lists and we do not want to display
1776 anything to the user. */
1779 process_debug_info (struct dwarf_section
*section
,
1783 unsigned char *start
= section
->start
;
1784 unsigned char *end
= start
+ section
->size
;
1785 unsigned char *section_begin
;
1787 unsigned int num_units
= 0;
1789 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1790 && num_debug_info_entries
== 0)
1792 unsigned long length
;
1794 /* First scan the section to get the number of comp units. */
1795 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1798 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1799 will be the length. For a 64-bit DWARF section, it'll be
1800 the escape code 0xffffffff followed by an 8 byte length. */
1801 length
= byte_get (section_begin
, 4);
1803 if (length
== 0xffffffff)
1805 length
= byte_get (section_begin
+ 4, 8);
1806 section_begin
+= length
+ 12;
1808 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
1810 warn (_("Reserved length value (%lx) found in section %s\n"), length
, section
->name
);
1814 section_begin
+= length
+ 4;
1816 /* Negative values are illegal, they may even cause infinite
1817 looping. This can happen if we can't accurately apply
1818 relocations to an object file. */
1819 if ((signed long) length
<= 0)
1821 warn (_("Corrupt unit length (%lx) found in section %s\n"), length
, section
->name
);
1828 error (_("No comp units in %s section ?"), section
->name
);
1832 /* Then allocate an array to hold the information. */
1833 debug_information
= cmalloc (num_units
,
1834 sizeof (* debug_information
));
1835 if (debug_information
== NULL
)
1837 error (_("Not enough memory for a debug info array of %u entries"),
1845 printf (_("Contents of the %s section:\n\n"), section
->name
);
1847 load_debug_section (str
, file
);
1850 load_debug_section (abbrev
, file
);
1851 if (debug_displays
[abbrev
].section
.start
== NULL
)
1853 warn (_("Unable to locate %s section!\n"),
1854 debug_displays
[abbrev
].section
.name
);
1858 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1860 DWARF2_Internal_CompUnit compunit
;
1861 unsigned char *hdrptr
;
1862 unsigned char *cu_abbrev_offset_ptr
;
1863 unsigned char *tags
;
1865 unsigned long cu_offset
;
1867 int initial_length_size
;
1871 compunit
.cu_length
= byte_get (hdrptr
, 4);
1874 if (compunit
.cu_length
== 0xffffffff)
1876 compunit
.cu_length
= byte_get (hdrptr
, 8);
1879 initial_length_size
= 12;
1884 initial_length_size
= 4;
1887 compunit
.cu_version
= byte_get (hdrptr
, 2);
1890 cu_offset
= start
- section_begin
;
1892 cu_abbrev_offset_ptr
= hdrptr
;
1893 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
1894 hdrptr
+= offset_size
;
1896 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
1898 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1899 && num_debug_info_entries
== 0)
1901 debug_information
[unit
].cu_offset
= cu_offset
;
1902 debug_information
[unit
].pointer_size
1903 = compunit
.cu_pointer_size
;
1904 debug_information
[unit
].base_address
= 0;
1905 debug_information
[unit
].loc_offsets
= NULL
;
1906 debug_information
[unit
].have_frame_base
= NULL
;
1907 debug_information
[unit
].max_loc_offsets
= 0;
1908 debug_information
[unit
].num_loc_offsets
= 0;
1909 debug_information
[unit
].range_lists
= NULL
;
1910 debug_information
[unit
].max_range_lists
= 0;
1911 debug_information
[unit
].num_range_lists
= 0;
1916 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
1917 printf (_(" Length: 0x%lx (%s)\n"), compunit
.cu_length
,
1918 initial_length_size
== 8 ? "64-bit" : "32-bit");
1919 printf (_(" Version: %d\n"), compunit
.cu_version
);
1920 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
1921 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
1924 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
1927 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1928 cu_offset
, compunit
.cu_length
);
1932 start
+= compunit
.cu_length
+ initial_length_size
;
1934 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
1936 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1937 cu_offset
, compunit
.cu_version
);
1943 /* Process the abbrevs used by this compilation unit. DWARF
1944 sections under Mach-O have non-zero addresses. */
1945 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev
].section
.size
)
1946 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1947 (unsigned long) compunit
.cu_abbrev_offset
,
1948 (unsigned long) debug_displays
[abbrev
].section
.size
);
1950 process_abbrev_section
1951 ((unsigned char *) debug_displays
[abbrev
].section
.start
1952 + compunit
.cu_abbrev_offset
- debug_displays
[abbrev
].section
.address
,
1953 (unsigned char *) debug_displays
[abbrev
].section
.start
1954 + debug_displays
[abbrev
].section
.size
);
1957 while (tags
< start
)
1959 unsigned int bytes_read
;
1960 unsigned long abbrev_number
;
1961 unsigned long die_offset
;
1962 abbrev_entry
*entry
;
1965 die_offset
= tags
- section_begin
;
1967 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
1970 /* A null DIE marks the end of a list of siblings. */
1971 if (abbrev_number
== 0)
1976 static unsigned num_bogus_warns
= 0;
1978 if (num_bogus_warns
< 3)
1980 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1983 if (num_bogus_warns
== 3)
1984 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1991 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1992 level
, die_offset
, abbrev_number
);
1994 /* Scan through the abbreviation list until we reach the
1996 for (entry
= first_abbrev
;
1997 entry
&& entry
->entry
!= abbrev_number
;
1998 entry
= entry
->next
)
2008 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2009 die_offset
, abbrev_number
);
2014 printf (_(" (%s)\n"), get_TAG_name (entry
->tag
));
2019 need_base_address
= 0;
2021 case DW_TAG_compile_unit
:
2022 need_base_address
= 1;
2024 case DW_TAG_entry_point
:
2025 case DW_TAG_subprogram
:
2026 need_base_address
= 0;
2027 /* Assuming that there is no DW_AT_frame_base. */
2028 have_frame_base
= 0;
2032 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2035 /* Show the offset from where the tag was extracted. */
2036 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
2038 tags
= read_and_display_attr (attr
->attribute
,
2041 compunit
.cu_pointer_size
,
2043 compunit
.cu_version
,
2044 debug_information
+ unit
,
2048 if (entry
->children
)
2053 /* Set num_debug_info_entries here so that it can be used to check if
2054 we need to process .debug_loc and .debug_ranges sections. */
2055 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2056 && num_debug_info_entries
== 0)
2057 num_debug_info_entries
= num_units
;
2067 /* Locate and scan the .debug_info section in the file and record the pointer
2068 sizes and offsets for the compilation units in it. Usually an executable
2069 will have just one pointer size, but this is not guaranteed, and so we try
2070 not to make any assumptions. Returns zero upon failure, or the number of
2071 compilation units upon success. */
2074 load_debug_info (void * file
)
2076 /* Reset the last pointer size so that we can issue correct error
2077 messages if we are displaying the contents of more than one section. */
2078 last_pointer_size
= 0;
2079 warned_about_missing_comp_units
= FALSE
;
2081 /* If we have already tried and failed to load the .debug_info
2082 section then do not bother to repear the task. */
2083 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2086 /* If we already have the information there is nothing else to do. */
2087 if (num_debug_info_entries
> 0)
2088 return num_debug_info_entries
;
2090 if (load_debug_section (info
, file
)
2091 && process_debug_info (&debug_displays
[info
].section
, file
, 1))
2092 return num_debug_info_entries
;
2094 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2099 display_debug_lines_raw (struct dwarf_section
*section
,
2100 unsigned char *data
,
2103 unsigned char *start
= section
->start
;
2105 printf (_("Raw dump of debug contents of section %s:\n\n"),
2110 DWARF2_Internal_LineInfo info
;
2111 unsigned char *standard_opcodes
;
2112 unsigned char *end_of_sequence
;
2113 unsigned char *hdrptr
;
2114 unsigned long hdroff
;
2115 int initial_length_size
;
2120 hdroff
= hdrptr
- start
;
2122 /* Check the length of the block. */
2123 info
.li_length
= byte_get (hdrptr
, 4);
2126 if (info
.li_length
== 0xffffffff)
2128 /* This section is 64-bit DWARF 3. */
2129 info
.li_length
= byte_get (hdrptr
, 8);
2132 initial_length_size
= 12;
2137 initial_length_size
= 4;
2140 if (info
.li_length
+ initial_length_size
> section
->size
)
2143 (_("The line info appears to be corrupt - the section is too small\n"));
2147 /* Check its version number. */
2148 info
.li_version
= byte_get (hdrptr
, 2);
2150 if (info
.li_version
!= 2 && info
.li_version
!= 3)
2152 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2156 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2157 hdrptr
+= offset_size
;
2158 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
2160 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2162 info
.li_line_base
= byte_get (hdrptr
, 1);
2164 info
.li_line_range
= byte_get (hdrptr
, 1);
2166 info
.li_opcode_base
= byte_get (hdrptr
, 1);
2169 /* Sign extend the line base field. */
2170 info
.li_line_base
<<= 24;
2171 info
.li_line_base
>>= 24;
2173 printf (_(" Offset: 0x%lx\n"), hdroff
);
2174 printf (_(" Length: %ld\n"), info
.li_length
);
2175 printf (_(" DWARF Version: %d\n"), info
.li_version
);
2176 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
2177 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
2178 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
2179 printf (_(" Line Base: %d\n"), info
.li_line_base
);
2180 printf (_(" Line Range: %d\n"), info
.li_line_range
);
2181 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
2183 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
2185 reset_state_machine (info
.li_default_is_stmt
);
2187 /* Display the contents of the Opcodes table. */
2188 standard_opcodes
= hdrptr
;
2190 printf (_("\n Opcodes:\n"));
2192 for (i
= 1; i
< info
.li_opcode_base
; i
++)
2193 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2195 /* Display the contents of the Directory table. */
2196 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
2199 printf (_("\n The Directory Table is empty.\n"));
2202 printf (_("\n The Directory Table:\n"));
2206 printf (_(" %s\n"), data
);
2208 data
+= strlen ((char *) data
) + 1;
2212 /* Skip the NUL at the end of the table. */
2215 /* Display the contents of the File Name table. */
2217 printf (_("\n The File Name Table is empty.\n"));
2220 printf (_("\n The File Name Table:\n"));
2221 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2225 unsigned char *name
;
2226 unsigned int bytes_read
;
2228 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
2231 data
+= strlen ((char *) data
) + 1;
2233 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2235 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2237 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2239 printf (_("%s\n"), name
);
2243 /* Skip the NUL at the end of the table. */
2246 /* Now display the statements. */
2247 printf (_("\n Line Number Statements:\n"));
2249 while (data
< end_of_sequence
)
2251 unsigned char op_code
;
2253 unsigned long int uladv
;
2254 unsigned int bytes_read
;
2258 if (op_code
>= info
.li_opcode_base
)
2260 op_code
-= info
.li_opcode_base
;
2261 uladv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
2262 state_machine_regs
.address
+= uladv
;
2263 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2264 op_code
, uladv
, state_machine_regs
.address
);
2265 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
2266 state_machine_regs
.line
+= adv
;
2267 printf (_(" and Line by %d to %d\n"),
2268 adv
, state_machine_regs
.line
);
2270 else switch (op_code
)
2272 case DW_LNS_extended_op
:
2273 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
);
2277 printf (_(" Copy\n"));
2280 case DW_LNS_advance_pc
:
2281 uladv
= read_leb128 (data
, & bytes_read
, 0);
2282 uladv
*= info
.li_min_insn_length
;
2284 state_machine_regs
.address
+= uladv
;
2285 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
2286 state_machine_regs
.address
);
2289 case DW_LNS_advance_line
:
2290 adv
= read_leb128 (data
, & bytes_read
, 1);
2292 state_machine_regs
.line
+= adv
;
2293 printf (_(" Advance Line by %d to %d\n"), adv
,
2294 state_machine_regs
.line
);
2297 case DW_LNS_set_file
:
2298 adv
= read_leb128 (data
, & bytes_read
, 0);
2300 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2302 state_machine_regs
.file
= adv
;
2305 case DW_LNS_set_column
:
2306 uladv
= read_leb128 (data
, & bytes_read
, 0);
2308 printf (_(" Set column to %lu\n"), uladv
);
2309 state_machine_regs
.column
= uladv
;
2312 case DW_LNS_negate_stmt
:
2313 adv
= state_machine_regs
.is_stmt
;
2315 printf (_(" Set is_stmt to %d\n"), adv
);
2316 state_machine_regs
.is_stmt
= adv
;
2319 case DW_LNS_set_basic_block
:
2320 printf (_(" Set basic block\n"));
2321 state_machine_regs
.basic_block
= 1;
2324 case DW_LNS_const_add_pc
:
2325 uladv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
2326 * info
.li_min_insn_length
);
2327 state_machine_regs
.address
+= uladv
;
2328 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2329 state_machine_regs
.address
);
2332 case DW_LNS_fixed_advance_pc
:
2333 uladv
= byte_get (data
, 2);
2335 state_machine_regs
.address
+= uladv
;
2336 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2337 uladv
, state_machine_regs
.address
);
2340 case DW_LNS_set_prologue_end
:
2341 printf (_(" Set prologue_end to true\n"));
2344 case DW_LNS_set_epilogue_begin
:
2345 printf (_(" Set epilogue_begin to true\n"));
2348 case DW_LNS_set_isa
:
2349 uladv
= read_leb128 (data
, & bytes_read
, 0);
2351 printf (_(" Set ISA to %lu\n"), uladv
);
2355 printf (_(" Unknown opcode %d with operands: "), op_code
);
2357 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2359 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2360 i
== 1 ? "" : ", ");
2375 unsigned char *name
;
2376 unsigned int directory_index
;
2377 unsigned int modification_date
;
2378 unsigned int length
;
2381 /* Output a decoded representation of the .debug_line section. */
2384 display_debug_lines_decoded (struct dwarf_section
*section
,
2385 unsigned char *data
,
2388 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2393 /* This loop amounts to one iteration per compilation unit. */
2394 DWARF2_Internal_LineInfo info
;
2395 unsigned char *standard_opcodes
;
2396 unsigned char *end_of_sequence
;
2397 unsigned char *hdrptr
;
2398 int initial_length_size
;
2401 File_Entry
*file_table
= NULL
;
2402 unsigned char **directory_table
= NULL
;
2403 unsigned int prev_line
= 0;
2407 /* Extract information from the Line Number Program Header.
2408 (section 6.2.4 in the Dwarf3 doc). */
2410 /* Get the length of this CU's line number information block. */
2411 info
.li_length
= byte_get (hdrptr
, 4);
2414 if (info
.li_length
== 0xffffffff)
2416 /* This section is 64-bit DWARF 3. */
2417 info
.li_length
= byte_get (hdrptr
, 8);
2420 initial_length_size
= 12;
2425 initial_length_size
= 4;
2428 if (info
.li_length
+ initial_length_size
> section
->size
)
2430 warn (_("The line info appears to be corrupt - "
2431 "the section is too small\n"));
2435 /* Get this CU's Line Number Block version number. */
2436 info
.li_version
= byte_get (hdrptr
, 2);
2438 if (info
.li_version
!= 2 && info
.li_version
!= 3)
2440 warn (_("Only DWARF version 2 and 3 line info is currently "
2445 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2446 hdrptr
+= offset_size
;
2447 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
2449 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2451 info
.li_line_base
= byte_get (hdrptr
, 1);
2453 info
.li_line_range
= byte_get (hdrptr
, 1);
2455 info
.li_opcode_base
= byte_get (hdrptr
, 1);
2458 /* Sign extend the line base field. */
2459 info
.li_line_base
<<= 24;
2460 info
.li_line_base
>>= 24;
2462 /* Find the end of this CU's Line Number Information Block. */
2463 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
2465 reset_state_machine (info
.li_default_is_stmt
);
2467 /* Save a pointer to the contents of the Opcodes table. */
2468 standard_opcodes
= hdrptr
;
2470 /* Traverse the Directory table just to count entries. */
2471 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
2474 unsigned int n_directories
= 0;
2475 unsigned char *ptr_directory_table
= data
;
2480 data
+= strlen ((char *) data
) + 1;
2484 /* Go through the directory table again to save the directories. */
2485 directory_table
= xmalloc (n_directories
* sizeof (unsigned char *));
2488 while (*ptr_directory_table
!= 0)
2490 directory_table
[i
] = ptr_directory_table
;
2491 ptr_directory_table
+= strlen ((char *) ptr_directory_table
) + 1;
2495 /* Skip the NUL at the end of the table. */
2498 /* Traverse the File Name table just to count the entries. */
2501 unsigned int n_files
= 0;
2502 unsigned char *ptr_file_name_table
= data
;
2507 unsigned int bytes_read
;
2509 /* Skip Name, directory index, last modification time and length
2511 data
+= strlen ((char *) data
) + 1;
2512 read_leb128 (data
, & bytes_read
, 0);
2514 read_leb128 (data
, & bytes_read
, 0);
2516 read_leb128 (data
, & bytes_read
, 0);
2522 /* Go through the file table again to save the strings. */
2523 file_table
= xmalloc (n_files
* sizeof (File_Entry
));
2526 while (*ptr_file_name_table
!= 0)
2528 unsigned int bytes_read
;
2530 file_table
[i
].name
= ptr_file_name_table
;
2531 ptr_file_name_table
+= strlen ((char *) ptr_file_name_table
) + 1;
2533 /* We are not interested in directory, time or size. */
2534 file_table
[i
].directory_index
= read_leb128 (ptr_file_name_table
,
2536 ptr_file_name_table
+= bytes_read
;
2537 file_table
[i
].modification_date
= read_leb128 (ptr_file_name_table
,
2539 ptr_file_name_table
+= bytes_read
;
2540 file_table
[i
].length
= read_leb128 (ptr_file_name_table
, & bytes_read
, 0);
2541 ptr_file_name_table
+= bytes_read
;
2546 /* Print the Compilation Unit's name and a header. */
2547 if (directory_table
== NULL
)
2549 printf (_("CU: %s:\n"), file_table
[0].name
);
2550 printf (_("File name Line number Starting address\n"));
2554 if (do_wide
|| strlen ((char *) directory_table
[0]) < 76)
2556 printf (_("CU: %s/%s:\n"), directory_table
[0],
2557 file_table
[0].name
);
2561 printf (_("%s:\n"), file_table
[0].name
);
2563 printf (_("File name Line number Starting address\n"));
2567 /* Skip the NUL at the end of the table. */
2570 /* This loop iterates through the Dwarf Line Number Program. */
2571 while (data
< end_of_sequence
)
2573 unsigned char op_code
;
2575 unsigned long int uladv
;
2576 unsigned int bytes_read
;
2577 int is_special_opcode
= 0;
2580 prev_line
= state_machine_regs
.line
;
2582 if (op_code
>= info
.li_opcode_base
)
2584 op_code
-= info
.li_opcode_base
;
2585 uladv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
2586 state_machine_regs
.address
+= uladv
;
2588 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
2589 state_machine_regs
.line
+= adv
;
2590 is_special_opcode
= 1;
2592 else switch (op_code
)
2594 case DW_LNS_extended_op
:
2596 unsigned int ext_op_code_len
;
2597 unsigned int bytes_read
;
2598 unsigned char ext_op_code
;
2599 unsigned char *op_code_data
= data
;
2601 ext_op_code_len
= read_leb128 (op_code_data
, &bytes_read
, 0);
2602 op_code_data
+= bytes_read
;
2604 if (ext_op_code_len
== 0)
2606 warn (_("badly formed extended line op encountered!\n"));
2609 ext_op_code_len
+= bytes_read
;
2610 ext_op_code
= *op_code_data
++;
2612 switch (ext_op_code
)
2614 case DW_LNE_end_sequence
:
2615 reset_state_machine (info
.li_default_is_stmt
);
2617 case DW_LNE_set_address
:
2618 state_machine_regs
.address
=
2619 byte_get (op_code_data
, ext_op_code_len
- bytes_read
- 1);
2621 case DW_LNE_define_file
:
2623 unsigned int dir_index
= 0;
2625 ++state_machine_regs
.last_file_entry
;
2626 op_code_data
+= strlen ((char *) op_code_data
) + 1;
2627 dir_index
= read_leb128 (op_code_data
, & bytes_read
, 0);
2628 op_code_data
+= bytes_read
;
2629 read_leb128 (op_code_data
, & bytes_read
, 0);
2630 op_code_data
+= bytes_read
;
2631 read_leb128 (op_code_data
, & bytes_read
, 0);
2633 printf (_("%s:\n"), directory_table
[dir_index
]);
2637 printf (_("UNKNOWN: length %d\n"), ext_op_code_len
- bytes_read
);
2640 data
+= ext_op_code_len
;
2646 case DW_LNS_advance_pc
:
2647 uladv
= read_leb128 (data
, & bytes_read
, 0);
2648 uladv
*= info
.li_min_insn_length
;
2650 state_machine_regs
.address
+= uladv
;
2653 case DW_LNS_advance_line
:
2654 adv
= read_leb128 (data
, & bytes_read
, 1);
2656 state_machine_regs
.line
+= adv
;
2659 case DW_LNS_set_file
:
2660 adv
= read_leb128 (data
, & bytes_read
, 0);
2662 state_machine_regs
.file
= adv
;
2663 if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
2665 /* If directory index is 0, that means current directory. */
2666 printf (_("\n./%s:[++]\n"),
2667 file_table
[state_machine_regs
.file
- 1].name
);
2671 /* The directory index starts counting at 1. */
2672 printf (_("\n%s/%s:\n"),
2673 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
2674 file_table
[state_machine_regs
.file
- 1].name
);
2678 case DW_LNS_set_column
:
2679 uladv
= read_leb128 (data
, & bytes_read
, 0);
2681 state_machine_regs
.column
= uladv
;
2684 case DW_LNS_negate_stmt
:
2685 adv
= state_machine_regs
.is_stmt
;
2687 state_machine_regs
.is_stmt
= adv
;
2690 case DW_LNS_set_basic_block
:
2691 state_machine_regs
.basic_block
= 1;
2694 case DW_LNS_const_add_pc
:
2695 uladv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
2696 * info
.li_min_insn_length
);
2697 state_machine_regs
.address
+= uladv
;
2700 case DW_LNS_fixed_advance_pc
:
2701 uladv
= byte_get (data
, 2);
2703 state_machine_regs
.address
+= uladv
;
2706 case DW_LNS_set_prologue_end
:
2709 case DW_LNS_set_epilogue_begin
:
2712 case DW_LNS_set_isa
:
2713 uladv
= read_leb128 (data
, & bytes_read
, 0);
2715 printf (_(" Set ISA to %lu\n"), uladv
);
2719 printf (_(" Unknown opcode %d with operands: "), op_code
);
2721 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2723 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2724 i
== 1 ? "" : ", ");
2731 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2732 to the DWARF address/line matrix. */
2733 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
2734 || (op_code
== DW_LNS_copy
))
2736 const unsigned int MAX_FILENAME_LENGTH
= 35;
2737 char *fileName
= (char *)file_table
[state_machine_regs
.file
- 1].name
;
2738 char *newFileName
= NULL
;
2739 size_t fileNameLength
= strlen (fileName
);
2741 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
2743 newFileName
= xmalloc (MAX_FILENAME_LENGTH
+ 1);
2744 /* Truncate file name */
2745 strncpy (newFileName
,
2746 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
2747 MAX_FILENAME_LENGTH
+ 1);
2751 newFileName
= xmalloc (fileNameLength
+ 1);
2752 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
2755 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
2757 printf (_("%-35s %11d %#18lx\n"), newFileName
,
2758 state_machine_regs
.line
, state_machine_regs
.address
);
2762 printf (_("%s %11d %#18lx\n"), newFileName
,
2763 state_machine_regs
.line
, state_machine_regs
.address
);
2766 if (op_code
== DW_LNE_end_sequence
)
2774 free (directory_table
);
2775 directory_table
= NULL
;
2783 display_debug_lines (struct dwarf_section
*section
, void *file
)
2785 unsigned char *data
= section
->start
;
2786 unsigned char *end
= data
+ section
->size
;
2788 int retValDecoded
= 1;
2790 if (load_debug_info (file
) == 0)
2792 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2797 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
2798 retValRaw
= display_debug_lines_raw (section
, data
, end
);
2800 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
2801 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
2803 if (!retValRaw
|| !retValDecoded
)
2810 find_debug_info_for_offset (unsigned long offset
)
2814 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2817 for (i
= 0; i
< num_debug_info_entries
; i
++)
2818 if (debug_information
[i
].cu_offset
== offset
)
2819 return debug_information
+ i
;
2825 display_debug_pubnames (struct dwarf_section
*section
,
2826 void *file ATTRIBUTE_UNUSED
)
2828 DWARF2_Internal_PubNames pubnames
;
2829 unsigned char *start
= section
->start
;
2830 unsigned char *end
= start
+ section
->size
;
2832 /* It does not matter if this load fails,
2833 we test for that later on. */
2834 load_debug_info (file
);
2836 printf (_("Contents of the %s section:\n\n"), section
->name
);
2840 unsigned char *data
;
2841 unsigned long offset
;
2842 int offset_size
, initial_length_size
;
2846 pubnames
.pn_length
= byte_get (data
, 4);
2848 if (pubnames
.pn_length
== 0xffffffff)
2850 pubnames
.pn_length
= byte_get (data
, 8);
2853 initial_length_size
= 12;
2858 initial_length_size
= 4;
2861 pubnames
.pn_version
= byte_get (data
, 2);
2864 pubnames
.pn_offset
= byte_get (data
, offset_size
);
2865 data
+= offset_size
;
2867 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
2868 && num_debug_info_entries
> 0
2869 && find_debug_info_for_offset (pubnames
.pn_offset
) == NULL
)
2870 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2871 pubnames
.pn_offset
, section
->name
);
2873 pubnames
.pn_size
= byte_get (data
, offset_size
);
2874 data
+= offset_size
;
2876 start
+= pubnames
.pn_length
+ initial_length_size
;
2878 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
2880 static int warned
= 0;
2884 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2891 printf (_(" Length: %ld\n"),
2892 pubnames
.pn_length
);
2893 printf (_(" Version: %d\n"),
2894 pubnames
.pn_version
);
2895 printf (_(" Offset into .debug_info section: 0x%lx\n"),
2896 pubnames
.pn_offset
);
2897 printf (_(" Size of area in .debug_info section: %ld\n"),
2900 printf (_("\n Offset\tName\n"));
2904 offset
= byte_get (data
, offset_size
);
2908 data
+= offset_size
;
2909 printf (" %-6lx\t%s\n", offset
, data
);
2910 data
+= strlen ((char *) data
) + 1;
2913 while (offset
!= 0);
2921 display_debug_macinfo (struct dwarf_section
*section
,
2922 void *file ATTRIBUTE_UNUSED
)
2924 unsigned char *start
= section
->start
;
2925 unsigned char *end
= start
+ section
->size
;
2926 unsigned char *curr
= start
;
2927 unsigned int bytes_read
;
2928 enum dwarf_macinfo_record_type op
;
2930 printf (_("Contents of the %s section:\n\n"), section
->name
);
2934 unsigned int lineno
;
2942 case DW_MACINFO_start_file
:
2944 unsigned int filenum
;
2946 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2948 filenum
= read_leb128 (curr
, & bytes_read
, 0);
2951 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2956 case DW_MACINFO_end_file
:
2957 printf (_(" DW_MACINFO_end_file\n"));
2960 case DW_MACINFO_define
:
2961 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2963 string
= (char *) curr
;
2964 curr
+= strlen (string
) + 1;
2965 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2969 case DW_MACINFO_undef
:
2970 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2972 string
= (char *) curr
;
2973 curr
+= strlen (string
) + 1;
2974 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2978 case DW_MACINFO_vendor_ext
:
2980 unsigned int constant
;
2982 constant
= read_leb128 (curr
, & bytes_read
, 0);
2984 string
= (char *) curr
;
2985 curr
+= strlen (string
) + 1;
2986 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2997 display_debug_abbrev (struct dwarf_section
*section
,
2998 void *file ATTRIBUTE_UNUSED
)
3000 abbrev_entry
*entry
;
3001 unsigned char *start
= section
->start
;
3002 unsigned char *end
= start
+ section
->size
;
3004 printf (_("Contents of the %s section:\n\n"), section
->name
);
3010 start
= process_abbrev_section (start
, end
);
3012 if (first_abbrev
== NULL
)
3015 printf (_(" Number TAG\n"));
3017 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
3021 printf (_(" %ld %s [%s]\n"),
3023 get_TAG_name (entry
->tag
),
3024 entry
->children
? _("has children") : _("no children"));
3026 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
3027 printf (_(" %-18s %s\n"),
3028 get_AT_name (attr
->attribute
),
3029 get_FORM_name (attr
->form
));
3040 display_debug_loc (struct dwarf_section
*section
, void *file
)
3042 unsigned char *start
= section
->start
;
3043 unsigned char *section_end
;
3044 unsigned long bytes
;
3045 unsigned char *section_begin
= start
;
3046 unsigned int num_loc_list
= 0;
3047 unsigned long last_offset
= 0;
3048 unsigned int first
= 0;
3051 int seen_first_offset
= 0;
3052 int use_debug_info
= 1;
3053 unsigned char *next
;
3055 bytes
= section
->size
;
3056 section_end
= start
+ bytes
;
3060 printf (_("\nThe %s section is empty.\n"), section
->name
);
3064 if (load_debug_info (file
) == 0)
3066 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3071 /* Check the order of location list in .debug_info section. If
3072 offsets of location lists are in the ascending order, we can
3073 use `debug_information' directly. */
3074 for (i
= 0; i
< num_debug_info_entries
; i
++)
3078 num
= debug_information
[i
].num_loc_offsets
;
3079 num_loc_list
+= num
;
3081 /* Check if we can use `debug_information' directly. */
3082 if (use_debug_info
&& num
!= 0)
3084 if (!seen_first_offset
)
3086 /* This is the first location list. */
3087 last_offset
= debug_information
[i
].loc_offsets
[0];
3089 seen_first_offset
= 1;
3095 for (; j
< num
; j
++)
3098 debug_information
[i
].loc_offsets
[j
])
3103 last_offset
= debug_information
[i
].loc_offsets
[j
];
3108 if (!use_debug_info
)
3109 /* FIXME: Should we handle this case? */
3110 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3112 if (!seen_first_offset
)
3113 error (_("No location lists in .debug_info section!\n"));
3115 /* DWARF sections under Mach-O have non-zero addresses. */
3116 if (debug_information
[first
].num_loc_offsets
> 0
3117 && debug_information
[first
].loc_offsets
[0] != section
->address
)
3118 warn (_("Location lists in %s section start at 0x%lx\n"),
3119 section
->name
, debug_information
[first
].loc_offsets
[0]);
3121 printf (_("Contents of the %s section:\n\n"), section
->name
);
3122 printf (_(" Offset Begin End Expression\n"));
3124 seen_first_offset
= 0;
3125 for (i
= first
; i
< num_debug_info_entries
; i
++)
3129 unsigned short length
;
3130 unsigned long offset
;
3131 unsigned int pointer_size
;
3132 unsigned long cu_offset
;
3133 unsigned long base_address
;
3134 int need_frame_base
;
3137 pointer_size
= debug_information
[i
].pointer_size
;
3138 cu_offset
= debug_information
[i
].cu_offset
;
3140 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
3142 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
3143 /* DWARF sections under Mach-O have non-zero addresses. */
3144 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
3145 next
= section_begin
+ offset
;
3146 base_address
= debug_information
[i
].base_address
;
3148 if (!seen_first_offset
)
3149 seen_first_offset
= 1;
3153 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3154 (unsigned long) (start
- section_begin
),
3155 (unsigned long) (next
- section_begin
));
3156 else if (start
> next
)
3157 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3158 (unsigned long) (start
- section_begin
),
3159 (unsigned long) (next
- section_begin
));
3163 if (offset
>= bytes
)
3165 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3172 if (start
+ 2 * pointer_size
> section_end
)
3174 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3179 /* Note: we use sign extension here in order to be sure that
3180 we can detect the -1 escape value. Sign extension into the
3181 top 32 bits of a 32-bit address will not affect the values
3182 that we display since we always show hex values, and always
3183 the bottom 32-bits. */
3184 begin
= byte_get_signed (start
, pointer_size
);
3185 start
+= pointer_size
;
3186 end
= byte_get_signed (start
, pointer_size
);
3187 start
+= pointer_size
;
3189 printf (" %8.8lx ", offset
);
3191 if (begin
== 0 && end
== 0)
3193 printf (_("<End of list>\n"));
3197 /* Check base address specifiers. */
3198 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3201 print_dwarf_vma (begin
, pointer_size
);
3202 print_dwarf_vma (end
, pointer_size
);
3203 printf (_("(base address)\n"));
3207 if (start
+ 2 > section_end
)
3209 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3214 length
= byte_get (start
, 2);
3217 if (start
+ length
> section_end
)
3219 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3224 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3225 print_dwarf_vma (end
+ base_address
, pointer_size
);
3228 need_frame_base
= decode_location_expression (start
,
3231 cu_offset
, section
);
3234 if (need_frame_base
&& !has_frame_base
)
3235 printf (_(" [without DW_AT_frame_base]"));
3238 fputs (_(" (start == end)"), stdout
);
3239 else if (begin
> end
)
3240 fputs (_(" (start > end)"), stdout
);
3249 if (start
< section_end
)
3250 warn (_("There are %ld unused bytes at the end of section %s\n"),
3251 (long) (section_end
- start
), section
->name
);
3256 display_debug_str (struct dwarf_section
*section
,
3257 void *file ATTRIBUTE_UNUSED
)
3259 unsigned char *start
= section
->start
;
3260 unsigned long bytes
= section
->size
;
3261 dwarf_vma addr
= section
->address
;
3265 printf (_("\nThe %s section is empty.\n"), section
->name
);
3269 printf (_("Contents of the %s section:\n\n"), section
->name
);
3277 lbytes
= (bytes
> 16 ? 16 : bytes
);
3279 printf (" 0x%8.8lx ", (unsigned long) addr
);
3281 for (j
= 0; j
< 16; j
++)
3284 printf ("%2.2x", start
[j
]);
3292 for (j
= 0; j
< lbytes
; j
++)
3295 if (k
>= ' ' && k
< 0x80)
3314 display_debug_info (struct dwarf_section
*section
, void *file
)
3316 return process_debug_info (section
, file
, 0);
3321 display_debug_aranges (struct dwarf_section
*section
,
3322 void *file ATTRIBUTE_UNUSED
)
3324 unsigned char *start
= section
->start
;
3325 unsigned char *end
= start
+ section
->size
;
3327 printf (_("Contents of the %s section:\n\n"), section
->name
);
3329 /* It does not matter if this load fails,
3330 we test for that later on. */
3331 load_debug_info (file
);
3335 unsigned char *hdrptr
;
3336 DWARF2_Internal_ARange arange
;
3337 unsigned char *ranges
;
3340 unsigned char address_size
;
3343 int initial_length_size
;
3347 arange
.ar_length
= byte_get (hdrptr
, 4);
3350 if (arange
.ar_length
== 0xffffffff)
3352 arange
.ar_length
= byte_get (hdrptr
, 8);
3355 initial_length_size
= 12;
3360 initial_length_size
= 4;
3363 arange
.ar_version
= byte_get (hdrptr
, 2);
3366 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
3367 hdrptr
+= offset_size
;
3369 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3370 && num_debug_info_entries
> 0
3371 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
3372 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3373 arange
.ar_info_offset
, section
->name
);
3375 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
3378 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
3381 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
3383 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3387 printf (_(" Length: %ld\n"), arange
.ar_length
);
3388 printf (_(" Version: %d\n"), arange
.ar_version
);
3389 printf (_(" Offset into .debug_info: 0x%lx\n"), arange
.ar_info_offset
);
3390 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
3391 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
3393 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
3395 /* The DWARF spec does not require that the address size be a power
3396 of two, but we do. This will have to change if we ever encounter
3397 an uneven architecture. */
3398 if ((address_size
& (address_size
- 1)) != 0)
3400 warn (_("Pointer size + Segment size is not a power of two.\n"));
3404 if (address_size
> 4)
3405 printf (_("\n Address Length\n"));
3407 printf (_("\n Address Length\n"));
3411 /* Must pad to an alignment boundary that is twice the address size. */
3412 excess
= (hdrptr
- start
) % (2 * address_size
);
3414 ranges
+= (2 * address_size
) - excess
;
3416 start
+= arange
.ar_length
+ initial_length_size
;
3418 while (ranges
+ 2 * address_size
<= start
)
3420 address
= byte_get (ranges
, address_size
);
3422 ranges
+= address_size
;
3424 length
= byte_get (ranges
, address_size
);
3426 ranges
+= address_size
;
3429 print_dwarf_vma (address
, address_size
);
3430 print_dwarf_vma (length
, address_size
);
3441 display_debug_ranges (struct dwarf_section
*section
,
3442 void *file ATTRIBUTE_UNUSED
)
3444 unsigned char *start
= section
->start
;
3445 unsigned char *section_end
;
3446 unsigned long bytes
;
3447 unsigned char *section_begin
= start
;
3448 unsigned int num_range_list
= 0;
3449 unsigned long last_offset
= 0;
3450 unsigned int first
= 0;
3453 int seen_first_offset
= 0;
3454 int use_debug_info
= 1;
3455 unsigned char *next
;
3457 bytes
= section
->size
;
3458 section_end
= start
+ bytes
;
3462 printf (_("\nThe %s section is empty.\n"), section
->name
);
3466 if (load_debug_info (file
) == 0)
3468 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3473 /* Check the order of range list in .debug_info section. If
3474 offsets of range lists are in the ascending order, we can
3475 use `debug_information' directly. */
3476 for (i
= 0; i
< num_debug_info_entries
; i
++)
3480 num
= debug_information
[i
].num_range_lists
;
3481 num_range_list
+= num
;
3483 /* Check if we can use `debug_information' directly. */
3484 if (use_debug_info
&& num
!= 0)
3486 if (!seen_first_offset
)
3488 /* This is the first range list. */
3489 last_offset
= debug_information
[i
].range_lists
[0];
3491 seen_first_offset
= 1;
3497 for (; j
< num
; j
++)
3500 debug_information
[i
].range_lists
[j
])
3505 last_offset
= debug_information
[i
].range_lists
[j
];
3510 if (!use_debug_info
)
3511 /* FIXME: Should we handle this case? */
3512 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
3514 if (!seen_first_offset
)
3515 error (_("No range lists in .debug_info section!\n"));
3517 /* DWARF sections under Mach-O have non-zero addresses. */
3518 if (debug_information
[first
].num_range_lists
> 0
3519 && debug_information
[first
].range_lists
[0] != section
->address
)
3520 warn (_("Range lists in %s section start at 0x%lx\n"),
3521 section
->name
, debug_information
[first
].range_lists
[0]);
3523 printf (_("Contents of the %s section:\n\n"), section
->name
);
3524 printf (_(" Offset Begin End\n"));
3526 seen_first_offset
= 0;
3527 for (i
= first
; i
< num_debug_info_entries
; i
++)
3531 unsigned long offset
;
3532 unsigned int pointer_size
;
3533 unsigned long base_address
;
3535 pointer_size
= debug_information
[i
].pointer_size
;
3537 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
3539 /* DWARF sections under Mach-O have non-zero addresses. */
3540 offset
= debug_information
[i
].range_lists
[j
] - section
->address
;
3541 next
= section_begin
+ offset
;
3542 base_address
= debug_information
[i
].base_address
;
3544 if (!seen_first_offset
)
3545 seen_first_offset
= 1;
3549 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3550 (unsigned long) (start
- section_begin
),
3551 (unsigned long) (next
- section_begin
), section
->name
);
3552 else if (start
> next
)
3553 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3554 (unsigned long) (start
- section_begin
),
3555 (unsigned long) (next
- section_begin
), section
->name
);
3561 /* Note: we use sign extension here in order to be sure that
3562 we can detect the -1 escape value. Sign extension into the
3563 top 32 bits of a 32-bit address will not affect the values
3564 that we display since we always show hex values, and always
3565 the bottom 32-bits. */
3566 begin
= byte_get_signed (start
, pointer_size
);
3567 start
+= pointer_size
;
3568 end
= byte_get_signed (start
, pointer_size
);
3569 start
+= pointer_size
;
3571 printf (" %8.8lx ", offset
);
3573 if (begin
== 0 && end
== 0)
3575 printf (_("<End of list>\n"));
3579 print_dwarf_vma (begin
, pointer_size
);
3580 print_dwarf_vma (end
, pointer_size
);
3582 /* Check base address specifiers. */
3583 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3586 printf ("(base address)\n");
3591 fputs (_("(start == end)"), stdout
);
3592 else if (begin
> end
)
3593 fputs (_("(start > end)"), stdout
);
3603 typedef struct Frame_Chunk
3605 struct Frame_Chunk
*next
;
3606 unsigned char *chunk_start
;
3608 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3609 short int *col_type
;
3612 unsigned int code_factor
;
3614 unsigned long pc_begin
;
3615 unsigned long pc_range
;
3619 unsigned char fde_encoding
;
3620 unsigned char cfa_exp
;
3624 /* A marker for a col_type that means this column was never referenced
3625 in the frame info. */
3626 #define DW_CFA_unreferenced (-1)
3629 frame_need_space (Frame_Chunk
*fc
, int reg
)
3631 int prev
= fc
->ncols
;
3633 if (reg
< fc
->ncols
)
3636 fc
->ncols
= reg
+ 1;
3637 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
3638 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
3640 while (prev
< fc
->ncols
)
3642 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
3643 fc
->col_offset
[prev
] = 0;
3648 static const char *const dwarf_regnames_i386
[] =
3650 "eax", "ecx", "edx", "ebx",
3651 "esp", "ebp", "esi", "edi",
3652 "eip", "eflags", NULL
,
3653 "st0", "st1", "st2", "st3",
3654 "st4", "st5", "st6", "st7",
3656 "xmm0", "xmm1", "xmm2", "xmm3",
3657 "xmm4", "xmm5", "xmm6", "xmm7",
3658 "mm0", "mm1", "mm2", "mm3",
3659 "mm4", "mm5", "mm6", "mm7",
3660 "fcw", "fsw", "mxcsr",
3661 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3665 static const char *const dwarf_regnames_x86_64
[] =
3667 "rax", "rdx", "rcx", "rbx",
3668 "rsi", "rdi", "rbp", "rsp",
3669 "r8", "r9", "r10", "r11",
3670 "r12", "r13", "r14", "r15",
3672 "xmm0", "xmm1", "xmm2", "xmm3",
3673 "xmm4", "xmm5", "xmm6", "xmm7",
3674 "xmm8", "xmm9", "xmm10", "xmm11",
3675 "xmm12", "xmm13", "xmm14", "xmm15",
3676 "st0", "st1", "st2", "st3",
3677 "st4", "st5", "st6", "st7",
3678 "mm0", "mm1", "mm2", "mm3",
3679 "mm4", "mm5", "mm6", "mm7",
3681 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3682 "fs.base", "gs.base", NULL
, NULL
,
3684 "mxcsr", "fcw", "fsw"
3687 static const char *const *dwarf_regnames
;
3688 static unsigned int dwarf_regnames_count
;
3691 init_dwarf_regnames (unsigned int e_machine
)
3697 dwarf_regnames
= dwarf_regnames_i386
;
3698 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
3702 dwarf_regnames
= dwarf_regnames_x86_64
;
3703 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
3712 regname (unsigned int regno
, int row
)
3714 static char reg
[64];
3716 && regno
< dwarf_regnames_count
3717 && dwarf_regnames
[regno
] != NULL
)
3720 return dwarf_regnames
[regno
];
3721 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
3722 dwarf_regnames
[regno
]);
3725 snprintf (reg
, sizeof (reg
), "r%d", regno
);
3730 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
3735 if (*max_regs
< fc
->ncols
)
3736 *max_regs
= fc
->ncols
;
3738 if (*need_col_headers
)
3740 static const char *loc
= " LOC";
3742 *need_col_headers
= 0;
3744 printf ("%-*s CFA ", eh_addr_size
* 2, loc
);
3746 for (r
= 0; r
< *max_regs
; r
++)
3747 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
3752 printf ("%-5s ", regname (r
, 1));
3758 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
3760 strcpy (tmp
, "exp");
3762 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
3763 printf ("%-8s ", tmp
);
3765 for (r
= 0; r
< fc
->ncols
; r
++)
3767 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
3769 switch (fc
->col_type
[r
])
3771 case DW_CFA_undefined
:
3774 case DW_CFA_same_value
:
3778 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
3780 case DW_CFA_val_offset
:
3781 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
3783 case DW_CFA_register
:
3784 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
3786 case DW_CFA_expression
:
3787 strcpy (tmp
, "exp");
3789 case DW_CFA_val_expression
:
3790 strcpy (tmp
, "vexp");
3793 strcpy (tmp
, "n/a");
3796 printf ("%-5s ", tmp
);
3802 #define GET(N) byte_get (start, N); start += N
3803 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3804 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3807 display_debug_frames (struct dwarf_section
*section
,
3808 void *file ATTRIBUTE_UNUSED
)
3810 unsigned char *start
= section
->start
;
3811 unsigned char *end
= start
+ section
->size
;
3812 unsigned char *section_start
= start
;
3813 Frame_Chunk
*chunks
= 0;
3814 Frame_Chunk
*remembered_state
= 0;
3816 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
3817 unsigned int length_return
;
3820 printf (_("Contents of the %s section:\n"), section
->name
);
3824 unsigned char *saved_start
;
3825 unsigned char *block_end
;
3826 unsigned long length
;
3827 unsigned long cie_id
;
3830 int need_col_headers
= 1;
3831 unsigned char *augmentation_data
= NULL
;
3832 unsigned long augmentation_data_len
= 0;
3833 int encoded_ptr_size
= eh_addr_size
;
3835 int initial_length_size
;
3837 saved_start
= start
;
3838 length
= byte_get (start
, 4); start
+= 4;
3842 printf ("\n%08lx ZERO terminator\n\n",
3843 (unsigned long)(saved_start
- section_start
));
3847 if (length
== 0xffffffff)
3849 length
= byte_get (start
, 8);
3852 initial_length_size
= 12;
3857 initial_length_size
= 4;
3860 block_end
= saved_start
+ length
+ initial_length_size
;
3861 if (block_end
> end
)
3863 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3864 length
, (unsigned long)(saved_start
- section_start
));
3867 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
3869 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
3873 fc
= xmalloc (sizeof (Frame_Chunk
));
3874 memset (fc
, 0, sizeof (Frame_Chunk
));
3878 fc
->chunk_start
= saved_start
;
3880 fc
->col_type
= xmalloc (sizeof (short int));
3881 fc
->col_offset
= xmalloc (sizeof (int));
3882 frame_need_space (fc
, max_regs
- 1);
3886 fc
->augmentation
= (char *) start
;
3887 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
3889 if (fc
->augmentation
[0] == 'z')
3891 fc
->code_factor
= LEB ();
3892 fc
->data_factor
= SLEB ();
3901 augmentation_data_len
= LEB ();
3902 augmentation_data
= start
;
3903 start
+= augmentation_data_len
;
3905 else if (strcmp (fc
->augmentation
, "eh") == 0)
3907 start
+= eh_addr_size
;
3908 fc
->code_factor
= LEB ();
3909 fc
->data_factor
= SLEB ();
3921 fc
->code_factor
= LEB ();
3922 fc
->data_factor
= SLEB ();
3934 if (do_debug_frames_interp
)
3935 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3936 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3937 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
3941 printf ("\n%08lx %08lx %08lx CIE\n",
3942 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
3943 printf (" Version: %d\n", version
);
3944 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
3945 printf (" Code alignment factor: %u\n", fc
->code_factor
);
3946 printf (" Data alignment factor: %d\n", fc
->data_factor
);
3947 printf (" Return address column: %d\n", fc
->ra
);
3949 if (augmentation_data_len
)
3952 printf (" Augmentation data: ");
3953 for (i
= 0; i
< augmentation_data_len
; ++i
)
3954 printf (" %02x", augmentation_data
[i
]);
3960 if (augmentation_data_len
)
3962 unsigned char *p
, *q
;
3963 p
= (unsigned char *) fc
->augmentation
+ 1;
3964 q
= augmentation_data
;
3971 q
+= 1 + size_of_encoded_value (*q
);
3973 fc
->fde_encoding
= *q
++;
3979 if (fc
->fde_encoding
)
3980 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3983 frame_need_space (fc
, fc
->ra
);
3987 unsigned char *look_for
;
3988 static Frame_Chunk fde_fc
;
3991 memset (fc
, 0, sizeof (Frame_Chunk
));
3993 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
3995 for (cie
= chunks
; cie
; cie
= cie
->next
)
3996 if (cie
->chunk_start
== look_for
)
4001 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4002 cie_id
, (unsigned long)(saved_start
- section_start
));
4004 fc
->col_type
= xmalloc (sizeof (short int));
4005 fc
->col_offset
= xmalloc (sizeof (int));
4006 frame_need_space (fc
, max_regs
- 1);
4008 fc
->augmentation
= "";
4009 fc
->fde_encoding
= 0;
4013 fc
->ncols
= cie
->ncols
;
4014 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
4015 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
4016 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
4017 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
4018 fc
->augmentation
= cie
->augmentation
;
4019 fc
->code_factor
= cie
->code_factor
;
4020 fc
->data_factor
= cie
->data_factor
;
4021 fc
->cfa_reg
= cie
->cfa_reg
;
4022 fc
->cfa_offset
= cie
->cfa_offset
;
4024 frame_need_space (fc
, max_regs
- 1);
4025 fc
->fde_encoding
= cie
->fde_encoding
;
4028 if (fc
->fde_encoding
)
4029 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4031 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
4032 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4033 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
4034 start
+= encoded_ptr_size
;
4035 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
4036 start
+= encoded_ptr_size
;
4038 if (cie
->augmentation
[0] == 'z')
4040 augmentation_data_len
= LEB ();
4041 augmentation_data
= start
;
4042 start
+= augmentation_data_len
;
4045 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4046 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4047 (unsigned long)(cie
->chunk_start
- section_start
),
4048 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
4049 if (! do_debug_frames_interp
&& augmentation_data_len
)
4053 printf (" Augmentation data: ");
4054 for (i
= 0; i
< augmentation_data_len
; ++i
)
4055 printf (" %02x", augmentation_data
[i
]);
4061 /* At this point, fc is the current chunk, cie (if any) is set, and
4062 we're about to interpret instructions for the chunk. */
4063 /* ??? At present we need to do this always, since this sizes the
4064 fc->col_type and fc->col_offset arrays, which we write into always.
4065 We should probably split the interpreted and non-interpreted bits
4066 into two different routines, since there's so much that doesn't
4067 really overlap between them. */
4068 if (1 || do_debug_frames_interp
)
4070 /* Start by making a pass over the chunk, allocating storage
4071 and taking note of what registers are used. */
4072 unsigned char *tmp
= start
;
4074 while (start
< block_end
)
4077 unsigned long reg
, tmp
;
4084 /* Warning: if you add any more cases to this switch, be
4085 sure to add them to the corresponding switch below. */
4088 case DW_CFA_advance_loc
:
4092 frame_need_space (fc
, opa
);
4093 fc
->col_type
[opa
] = DW_CFA_undefined
;
4095 case DW_CFA_restore
:
4096 frame_need_space (fc
, opa
);
4097 fc
->col_type
[opa
] = DW_CFA_undefined
;
4099 case DW_CFA_set_loc
:
4100 start
+= encoded_ptr_size
;
4102 case DW_CFA_advance_loc1
:
4105 case DW_CFA_advance_loc2
:
4108 case DW_CFA_advance_loc4
:
4111 case DW_CFA_offset_extended
:
4112 case DW_CFA_val_offset
:
4113 reg
= LEB (); LEB ();
4114 frame_need_space (fc
, reg
);
4115 fc
->col_type
[reg
] = DW_CFA_undefined
;
4117 case DW_CFA_restore_extended
:
4119 frame_need_space (fc
, reg
);
4120 fc
->col_type
[reg
] = DW_CFA_undefined
;
4122 case DW_CFA_undefined
:
4124 frame_need_space (fc
, reg
);
4125 fc
->col_type
[reg
] = DW_CFA_undefined
;
4127 case DW_CFA_same_value
:
4129 frame_need_space (fc
, reg
);
4130 fc
->col_type
[reg
] = DW_CFA_undefined
;
4132 case DW_CFA_register
:
4133 reg
= LEB (); LEB ();
4134 frame_need_space (fc
, reg
);
4135 fc
->col_type
[reg
] = DW_CFA_undefined
;
4137 case DW_CFA_def_cfa
:
4140 case DW_CFA_def_cfa_register
:
4143 case DW_CFA_def_cfa_offset
:
4146 case DW_CFA_def_cfa_expression
:
4150 case DW_CFA_expression
:
4151 case DW_CFA_val_expression
:
4155 frame_need_space (fc
, reg
);
4156 fc
->col_type
[reg
] = DW_CFA_undefined
;
4158 case DW_CFA_offset_extended_sf
:
4159 case DW_CFA_val_offset_sf
:
4160 reg
= LEB (); SLEB ();
4161 frame_need_space (fc
, reg
);
4162 fc
->col_type
[reg
] = DW_CFA_undefined
;
4164 case DW_CFA_def_cfa_sf
:
4167 case DW_CFA_def_cfa_offset_sf
:
4170 case DW_CFA_MIPS_advance_loc8
:
4173 case DW_CFA_GNU_args_size
:
4176 case DW_CFA_GNU_negative_offset_extended
:
4177 reg
= LEB (); LEB ();
4178 frame_need_space (fc
, reg
);
4179 fc
->col_type
[reg
] = DW_CFA_undefined
;
4188 /* Now we know what registers are used, make a second pass over
4189 the chunk, this time actually printing out the info. */
4191 while (start
< block_end
)
4194 unsigned long ul
, reg
, roffs
;
4203 /* Warning: if you add any more cases to this switch, be
4204 sure to add them to the corresponding switch above. */
4207 case DW_CFA_advance_loc
:
4208 if (do_debug_frames_interp
)
4209 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4211 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4212 opa
* fc
->code_factor
,
4213 fc
->pc_begin
+ opa
* fc
->code_factor
);
4214 fc
->pc_begin
+= opa
* fc
->code_factor
;
4219 if (! do_debug_frames_interp
)
4220 printf (" DW_CFA_offset: %s at cfa%+ld\n",
4221 regname (opa
, 0), roffs
* fc
->data_factor
);
4222 fc
->col_type
[opa
] = DW_CFA_offset
;
4223 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
4226 case DW_CFA_restore
:
4227 if (! do_debug_frames_interp
)
4228 printf (" DW_CFA_restore: %s\n", regname (opa
, 0));
4229 fc
->col_type
[opa
] = cie
->col_type
[opa
];
4230 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
4233 case DW_CFA_set_loc
:
4234 vma
= get_encoded_value (start
, fc
->fde_encoding
);
4235 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4236 vma
+= section
->address
+ (start
- section_start
);
4237 start
+= encoded_ptr_size
;
4238 if (do_debug_frames_interp
)
4239 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4241 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
4245 case DW_CFA_advance_loc1
:
4246 ofs
= byte_get (start
, 1); start
+= 1;
4247 if (do_debug_frames_interp
)
4248 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4250 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4251 ofs
* fc
->code_factor
,
4252 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4253 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4256 case DW_CFA_advance_loc2
:
4257 ofs
= byte_get (start
, 2); start
+= 2;
4258 if (do_debug_frames_interp
)
4259 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4261 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4262 ofs
* fc
->code_factor
,
4263 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4264 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4267 case DW_CFA_advance_loc4
:
4268 ofs
= byte_get (start
, 4); start
+= 4;
4269 if (do_debug_frames_interp
)
4270 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4272 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4273 ofs
* fc
->code_factor
,
4274 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4275 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4278 case DW_CFA_offset_extended
:
4281 if (! do_debug_frames_interp
)
4282 printf (" DW_CFA_offset_extended: %s at cfa%+ld\n",
4283 regname (reg
, 0), roffs
* fc
->data_factor
);
4284 fc
->col_type
[reg
] = DW_CFA_offset
;
4285 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4288 case DW_CFA_val_offset
:
4291 if (! do_debug_frames_interp
)
4292 printf (" DW_CFA_val_offset: %s at cfa%+ld\n",
4293 regname (reg
, 0), roffs
* fc
->data_factor
);
4294 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4295 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4298 case DW_CFA_restore_extended
:
4300 if (! do_debug_frames_interp
)
4301 printf (" DW_CFA_restore_extended: %s\n",
4303 fc
->col_type
[reg
] = cie
->col_type
[reg
];
4304 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
4307 case DW_CFA_undefined
:
4309 if (! do_debug_frames_interp
)
4310 printf (" DW_CFA_undefined: %s\n", regname (reg
, 0));
4311 fc
->col_type
[reg
] = DW_CFA_undefined
;
4312 fc
->col_offset
[reg
] = 0;
4315 case DW_CFA_same_value
:
4317 if (! do_debug_frames_interp
)
4318 printf (" DW_CFA_same_value: %s\n", regname (reg
, 0));
4319 fc
->col_type
[reg
] = DW_CFA_same_value
;
4320 fc
->col_offset
[reg
] = 0;
4323 case DW_CFA_register
:
4326 if (! do_debug_frames_interp
)
4328 printf (" DW_CFA_register: %s in ",
4330 puts (regname (roffs
, 0));
4332 fc
->col_type
[reg
] = DW_CFA_register
;
4333 fc
->col_offset
[reg
] = roffs
;
4336 case DW_CFA_remember_state
:
4337 if (! do_debug_frames_interp
)
4338 printf (" DW_CFA_remember_state\n");
4339 rs
= xmalloc (sizeof (Frame_Chunk
));
4340 rs
->ncols
= fc
->ncols
;
4341 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
4342 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
4343 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
4344 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
4345 rs
->next
= remembered_state
;
4346 remembered_state
= rs
;
4349 case DW_CFA_restore_state
:
4350 if (! do_debug_frames_interp
)
4351 printf (" DW_CFA_restore_state\n");
4352 rs
= remembered_state
;
4355 remembered_state
= rs
->next
;
4356 frame_need_space (fc
, rs
->ncols
- 1);
4357 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
4358 memcpy (fc
->col_offset
, rs
->col_offset
,
4359 rs
->ncols
* sizeof (int));
4360 free (rs
->col_type
);
4361 free (rs
->col_offset
);
4364 else if (do_debug_frames_interp
)
4365 printf ("Mismatched DW_CFA_restore_state\n");
4368 case DW_CFA_def_cfa
:
4369 fc
->cfa_reg
= LEB ();
4370 fc
->cfa_offset
= LEB ();
4372 if (! do_debug_frames_interp
)
4373 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4374 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4377 case DW_CFA_def_cfa_register
:
4378 fc
->cfa_reg
= LEB ();
4380 if (! do_debug_frames_interp
)
4381 printf (" DW_CFA_def_cfa_register: %s\n",
4382 regname (fc
->cfa_reg
, 0));
4385 case DW_CFA_def_cfa_offset
:
4386 fc
->cfa_offset
= LEB ();
4387 if (! do_debug_frames_interp
)
4388 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
4392 if (! do_debug_frames_interp
)
4393 printf (" DW_CFA_nop\n");
4396 case DW_CFA_def_cfa_expression
:
4398 if (! do_debug_frames_interp
)
4400 printf (" DW_CFA_def_cfa_expression (");
4401 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4409 case DW_CFA_expression
:
4412 if (! do_debug_frames_interp
)
4414 printf (" DW_CFA_expression: %s (",
4416 decode_location_expression (start
, eh_addr_size
,
4420 fc
->col_type
[reg
] = DW_CFA_expression
;
4424 case DW_CFA_val_expression
:
4427 if (! do_debug_frames_interp
)
4429 printf (" DW_CFA_val_expression: %s (",
4431 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4435 fc
->col_type
[reg
] = DW_CFA_val_expression
;
4439 case DW_CFA_offset_extended_sf
:
4442 frame_need_space (fc
, reg
);
4443 if (! do_debug_frames_interp
)
4444 printf (" DW_CFA_offset_extended_sf: %s at cfa%+ld\n",
4445 regname (reg
, 0), l
* fc
->data_factor
);
4446 fc
->col_type
[reg
] = DW_CFA_offset
;
4447 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4450 case DW_CFA_val_offset_sf
:
4453 frame_need_space (fc
, reg
);
4454 if (! do_debug_frames_interp
)
4455 printf (" DW_CFA_val_offset_sf: %s at cfa%+ld\n",
4456 regname (reg
, 0), l
* fc
->data_factor
);
4457 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4458 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4461 case DW_CFA_def_cfa_sf
:
4462 fc
->cfa_reg
= LEB ();
4463 fc
->cfa_offset
= SLEB ();
4464 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4466 if (! do_debug_frames_interp
)
4467 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4468 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4471 case DW_CFA_def_cfa_offset_sf
:
4472 fc
->cfa_offset
= SLEB ();
4473 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4474 if (! do_debug_frames_interp
)
4475 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
4478 case DW_CFA_MIPS_advance_loc8
:
4479 ofs
= byte_get (start
, 8); start
+= 8;
4480 if (do_debug_frames_interp
)
4481 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4483 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4484 ofs
* fc
->code_factor
,
4485 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4486 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4489 case DW_CFA_GNU_window_save
:
4490 if (! do_debug_frames_interp
)
4491 printf (" DW_CFA_GNU_window_save\n");
4494 case DW_CFA_GNU_args_size
:
4496 if (! do_debug_frames_interp
)
4497 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
4500 case DW_CFA_GNU_negative_offset_extended
:
4503 frame_need_space (fc
, reg
);
4504 if (! do_debug_frames_interp
)
4505 printf (" DW_CFA_GNU_negative_offset_extended: %s at cfa%+ld\n",
4506 regname (reg
, 0), l
* fc
->data_factor
);
4507 fc
->col_type
[reg
] = DW_CFA_offset
;
4508 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4512 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
4513 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
4515 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
4520 if (do_debug_frames_interp
)
4521 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4536 display_debug_not_supported (struct dwarf_section
*section
,
4537 void *file ATTRIBUTE_UNUSED
)
4539 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4546 cmalloc (size_t nmemb
, size_t size
)
4548 /* Check for overflow. */
4549 if (nmemb
>= ~(size_t) 0 / size
)
4552 return malloc (nmemb
* size
);
4556 xcmalloc (size_t nmemb
, size_t size
)
4558 /* Check for overflow. */
4559 if (nmemb
>= ~(size_t) 0 / size
)
4562 return xmalloc (nmemb
* size
);
4566 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
4568 /* Check for overflow. */
4569 if (nmemb
>= ~(size_t) 0 / size
)
4572 return xrealloc (ptr
, nmemb
* size
);
4576 error (const char *message
, ...)
4580 va_start (args
, message
);
4581 fprintf (stderr
, _("%s: Error: "), program_name
);
4582 vfprintf (stderr
, message
, args
);
4587 warn (const char *message
, ...)
4591 va_start (args
, message
);
4592 fprintf (stderr
, _("%s: Warning: "), program_name
);
4593 vfprintf (stderr
, message
, args
);
4598 free_debug_memory (void)
4600 enum dwarf_section_display_enum i
;
4604 for (i
= 0; i
< max
; i
++)
4605 free_debug_section (i
);
4607 if (debug_information
!= NULL
)
4609 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
4611 for (i
= 0; i
< num_debug_info_entries
; i
++)
4613 if (!debug_information
[i
].max_loc_offsets
)
4615 free (debug_information
[i
].loc_offsets
);
4616 free (debug_information
[i
].have_frame_base
);
4618 if (!debug_information
[i
].max_range_lists
)
4619 free (debug_information
[i
].range_lists
);
4623 free (debug_information
);
4624 debug_information
= NULL
;
4625 num_debug_info_entries
= 0;
4630 dwarf_select_sections_by_names (const char *names
)
4634 const char * option
;
4638 debug_dump_long_opts
;
4640 static const debug_dump_long_opts opts_table
[] =
4642 /* Please keep this table alpha- sorted. */
4643 { "Ranges", & do_debug_ranges
, 1 },
4644 { "abbrev", & do_debug_abbrevs
, 1 },
4645 { "aranges", & do_debug_aranges
, 1 },
4646 { "frames", & do_debug_frames
, 1 },
4647 { "frames-interp", & do_debug_frames_interp
, 1 },
4648 { "info", & do_debug_info
, 1 },
4649 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
4650 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
4651 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
4652 { "loc", & do_debug_loc
, 1 },
4653 { "macro", & do_debug_macinfo
, 1 },
4654 { "pubnames", & do_debug_pubnames
, 1 },
4655 /* This entry is for compatability
4656 with earlier versions of readelf. */
4657 { "ranges", & do_debug_aranges
, 1 },
4658 { "str", & do_debug_str
, 1 },
4667 const debug_dump_long_opts
* entry
;
4669 for (entry
= opts_table
; entry
->option
; entry
++)
4671 size_t len
= strlen (entry
->option
);
4673 if (strncmp (p
, entry
->option
, len
) == 0
4674 && (p
[len
] == ',' || p
[len
] == '\0'))
4676 * entry
->variable
|= entry
->val
;
4678 /* The --debug-dump=frames-interp option also
4679 enables the --debug-dump=frames option. */
4680 if (do_debug_frames_interp
)
4681 do_debug_frames
= 1;
4688 if (entry
->option
== NULL
)
4690 warn (_("Unrecognized debug option '%s'\n"), p
);
4691 p
= strchr (p
, ',');
4702 dwarf_select_sections_by_letters (const char *letters
)
4704 unsigned int index
= 0;
4706 while (letters
[index
])
4707 switch (letters
[index
++])
4714 do_debug_abbrevs
= 1;
4718 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4722 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
4726 do_debug_pubnames
= 1;
4730 do_debug_aranges
= 1;
4734 do_debug_ranges
= 1;
4738 do_debug_frames_interp
= 1;
4740 do_debug_frames
= 1;
4744 do_debug_macinfo
= 1;
4756 warn (_("Unrecognized debug option '%s'\n"), optarg
);
4762 dwarf_select_sections_all (void)
4765 do_debug_abbrevs
= 1;
4766 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
4767 do_debug_pubnames
= 1;
4768 do_debug_aranges
= 1;
4769 do_debug_ranges
= 1;
4770 do_debug_frames
= 1;
4771 do_debug_macinfo
= 1;
4776 struct dwarf_section_display debug_displays
[] =
4778 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0 },
4779 display_debug_abbrev
, &do_debug_abbrevs
, 0, 0 },
4780 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0 },
4781 display_debug_aranges
, &do_debug_aranges
, 0, 0 },
4782 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0 },
4783 display_debug_frames
, &do_debug_frames
, 1, 0 },
4784 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0 },
4785 display_debug_info
, &do_debug_info
, 1, 0 },
4786 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0 },
4787 display_debug_lines
, &do_debug_lines
, 0, 0 },
4788 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0 },
4789 display_debug_pubnames
, &do_debug_pubnames
, 0, 0 },
4790 { { ".eh_frame", "", NULL
, NULL
, 0, 0 },
4791 display_debug_frames
, &do_debug_frames
, 1, 1 },
4792 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0 },
4793 display_debug_macinfo
, &do_debug_macinfo
, 0, 0 },
4794 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0 },
4795 display_debug_str
, &do_debug_str
, 0, 0 },
4796 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0 },
4797 display_debug_loc
, &do_debug_loc
, 0, 0 },
4798 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0 },
4799 display_debug_pubnames
, &do_debug_pubnames
, 0, 0 },
4800 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0 },
4801 display_debug_ranges
, &do_debug_ranges
, 0, 0 },
4802 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0 },
4803 display_debug_not_supported
, NULL
, 0, 0 },
4804 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0 },
4805 display_debug_not_supported
, NULL
, 0, 0 },
4806 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0 },
4807 display_debug_not_supported
, NULL
, 0, 0 },
4808 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0 },
4809 display_debug_not_supported
, NULL
, 0, 0 }