1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010
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"
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
;
48 int do_debug_pubtypes
;
52 int do_debug_frames_interp
;
61 /* Values for do_debug_lines. */
62 #define FLAG_DEBUG_LINES_RAW 1
63 #define FLAG_DEBUG_LINES_DECODED 2
65 dwarf_vma (*byte_get
) (unsigned char *, int);
68 byte_get_little_endian (unsigned char *field
, int size
)
76 return ((unsigned int) (field
[0]))
77 | (((unsigned int) (field
[1])) << 8);
80 return ((unsigned long) (field
[0]))
81 | (((unsigned long) (field
[1])) << 8)
82 | (((unsigned long) (field
[2])) << 16);
85 return ((unsigned long) (field
[0]))
86 | (((unsigned long) (field
[1])) << 8)
87 | (((unsigned long) (field
[2])) << 16)
88 | (((unsigned long) (field
[3])) << 24);
91 if (sizeof (dwarf_vma
) == 8)
92 return ((dwarf_vma
) (field
[0]))
93 | (((dwarf_vma
) (field
[1])) << 8)
94 | (((dwarf_vma
) (field
[2])) << 16)
95 | (((dwarf_vma
) (field
[3])) << 24)
96 | (((dwarf_vma
) (field
[4])) << 32)
97 | (((dwarf_vma
) (field
[5])) << 40)
98 | (((dwarf_vma
) (field
[6])) << 48)
99 | (((dwarf_vma
) (field
[7])) << 56);
100 else if (sizeof (dwarf_vma
) == 4)
101 /* We want to extract data from an 8 byte wide field and
102 place it into a 4 byte wide field. Since this is a little
103 endian source we can just use the 4 byte extraction code. */
104 return ((unsigned long) (field
[0]))
105 | (((unsigned long) (field
[1])) << 8)
106 | (((unsigned long) (field
[2])) << 16)
107 | (((unsigned long) (field
[3])) << 24);
110 error (_("Unhandled data length: %d\n"), size
);
116 byte_get_big_endian (unsigned char *field
, int size
)
124 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
127 return ((unsigned long) (field
[2]))
128 | (((unsigned long) (field
[1])) << 8)
129 | (((unsigned long) (field
[0])) << 16);
132 return ((unsigned long) (field
[3]))
133 | (((unsigned long) (field
[2])) << 8)
134 | (((unsigned long) (field
[1])) << 16)
135 | (((unsigned long) (field
[0])) << 24);
138 if (sizeof (dwarf_vma
) == 8)
139 return ((dwarf_vma
) (field
[7]))
140 | (((dwarf_vma
) (field
[6])) << 8)
141 | (((dwarf_vma
) (field
[5])) << 16)
142 | (((dwarf_vma
) (field
[4])) << 24)
143 | (((dwarf_vma
) (field
[3])) << 32)
144 | (((dwarf_vma
) (field
[2])) << 40)
145 | (((dwarf_vma
) (field
[1])) << 48)
146 | (((dwarf_vma
) (field
[0])) << 56);
147 else if (sizeof (dwarf_vma
) == 4)
149 /* Although we are extracing data from an 8 byte wide field,
150 we are returning only 4 bytes of data. */
152 return ((unsigned long) (field
[3]))
153 | (((unsigned long) (field
[2])) << 8)
154 | (((unsigned long) (field
[1])) << 16)
155 | (((unsigned long) (field
[0])) << 24);
159 error (_("Unhandled data length: %d\n"), size
);
165 byte_get_signed (unsigned char *field
, int size
)
167 dwarf_vma x
= byte_get (field
, size
);
172 return (x
^ 0x80) - 0x80;
174 return (x
^ 0x8000) - 0x8000;
176 return (x
^ 0x80000000) - 0x80000000;
185 size_of_encoded_value (int encoding
)
187 switch (encoding
& 0x7)
190 case 0: return eh_addr_size
;
198 get_encoded_value (unsigned char *data
, int encoding
)
200 int size
= size_of_encoded_value (encoding
);
202 if (encoding
& DW_EH_PE_signed
)
203 return byte_get_signed (data
, size
);
205 return byte_get (data
, size
);
208 /* Print a dwarf_vma value (typically an address, offset or length) in
209 hexadecimal format, followed by a space. The length of the value (and
210 hence the precision displayed) is determined by the byte_size parameter. */
213 print_dwarf_vma (dwarf_vma val
, unsigned byte_size
)
215 static char buff
[18];
217 /* Printf does not have a way of specifiying a maximum field width for an
218 integer value, so we print the full value into a buffer and then select
219 the precision we need. */
220 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
222 snprintf (buff
, sizeof (buff
), "%16.16llx ", val
);
224 snprintf (buff
, sizeof (buff
), "%016I64x ", val
);
227 snprintf (buff
, sizeof (buff
), "%16.16lx ", val
);
230 fputs (buff
+ (byte_size
== 4 ? 8 : 0), stdout
);
234 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
236 unsigned long int result
= 0;
237 unsigned int num_read
= 0;
238 unsigned int shift
= 0;
246 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
253 if (length_return
!= NULL
)
254 *length_return
= num_read
;
256 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
257 result
|= -1L << shift
;
262 typedef struct State_Machine_Registers
264 unsigned long address
;
270 unsigned char op_index
;
271 unsigned char end_sequence
;
272 /* This variable hold the number of the last entry seen
273 in the File Table. */
274 unsigned int last_file_entry
;
277 static SMR state_machine_regs
;
280 reset_state_machine (int is_stmt
)
282 state_machine_regs
.address
= 0;
283 state_machine_regs
.op_index
= 0;
284 state_machine_regs
.file
= 1;
285 state_machine_regs
.line
= 1;
286 state_machine_regs
.column
= 0;
287 state_machine_regs
.is_stmt
= is_stmt
;
288 state_machine_regs
.basic_block
= 0;
289 state_machine_regs
.end_sequence
= 0;
290 state_machine_regs
.last_file_entry
= 0;
293 /* Handled an extend line op.
294 Returns the number of bytes read. */
297 process_extended_line_op (unsigned char *data
, int is_stmt
)
299 unsigned char op_code
;
300 unsigned int bytes_read
;
305 len
= read_leb128 (data
, & bytes_read
, 0);
310 warn (_("badly formed extended line op encountered!\n"));
317 printf (_(" Extended opcode %d: "), op_code
);
321 case DW_LNE_end_sequence
:
322 printf (_("End of Sequence\n\n"));
323 reset_state_machine (is_stmt
);
326 case DW_LNE_set_address
:
327 adr
= byte_get (data
, len
- bytes_read
- 1);
328 printf (_("set Address to 0x%lx\n"), adr
);
329 state_machine_regs
.address
= adr
;
330 state_machine_regs
.op_index
= 0;
333 case DW_LNE_define_file
:
334 printf (_(" define new File Table entry\n"));
335 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
337 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
339 data
+= strlen ((char *) data
) + 1;
340 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
342 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
344 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
345 printf (_("%s\n\n"), name
);
348 case DW_LNE_set_discriminator
:
349 printf (_("set Discriminator to %lu\n"),
350 read_leb128 (data
, & bytes_read
, 0));
354 case DW_LNE_HP_negate_is_UV_update
:
355 printf ("DW_LNE_HP_negate_is_UV_update\n");
357 case DW_LNE_HP_push_context
:
358 printf ("DW_LNE_HP_push_context\n");
360 case DW_LNE_HP_pop_context
:
361 printf ("DW_LNE_HP_pop_context\n");
363 case DW_LNE_HP_set_file_line_column
:
364 printf ("DW_LNE_HP_set_file_line_column\n");
366 case DW_LNE_HP_set_routine_name
:
367 printf ("DW_LNE_HP_set_routine_name\n");
369 case DW_LNE_HP_set_sequence
:
370 printf ("DW_LNE_HP_set_sequence\n");
372 case DW_LNE_HP_negate_post_semantics
:
373 printf ("DW_LNE_HP_negate_post_semantics\n");
375 case DW_LNE_HP_negate_function_exit
:
376 printf ("DW_LNE_HP_negate_function_exit\n");
378 case DW_LNE_HP_negate_front_end_logical
:
379 printf ("DW_LNE_HP_negate_front_end_logical\n");
381 case DW_LNE_HP_define_proc
:
382 printf ("DW_LNE_HP_define_proc\n");
386 if (op_code
>= DW_LNE_lo_user
387 /* The test against DW_LNW_hi_user is redundant due to
388 the limited range of the unsigned char data type used
390 /*&& op_code <= DW_LNE_hi_user*/)
391 printf (_("user defined: length %d\n"), len
- bytes_read
);
393 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
401 fetch_indirect_string (unsigned long offset
)
403 struct dwarf_section
*section
= &debug_displays
[str
].section
;
405 if (section
->start
== NULL
)
406 return _("<no .debug_str section>");
408 /* DWARF sections under Mach-O have non-zero addresses. */
409 offset
-= section
->address
;
410 if (offset
> section
->size
)
412 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
413 return _("<offset is too big>");
416 return (const char *) section
->start
+ offset
;
419 /* FIXME: There are better and more efficient ways to handle
420 these structures. For now though, I just want something that
421 is simple to implement. */
422 typedef struct abbrev_attr
424 unsigned long attribute
;
426 struct abbrev_attr
*next
;
430 typedef struct abbrev_entry
435 struct abbrev_attr
*first_attr
;
436 struct abbrev_attr
*last_attr
;
437 struct abbrev_entry
*next
;
441 static abbrev_entry
*first_abbrev
= NULL
;
442 static abbrev_entry
*last_abbrev
= NULL
;
449 for (abbrv
= first_abbrev
; abbrv
;)
451 abbrev_entry
*next_abbrev
= abbrv
->next
;
454 for (attr
= abbrv
->first_attr
; attr
;)
456 abbrev_attr
*next_attr
= attr
->next
;
466 last_abbrev
= first_abbrev
= NULL
;
470 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
474 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
480 entry
->entry
= number
;
482 entry
->children
= children
;
483 entry
->first_attr
= NULL
;
484 entry
->last_attr
= NULL
;
487 if (first_abbrev
== NULL
)
488 first_abbrev
= entry
;
490 last_abbrev
->next
= entry
;
496 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
500 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
506 attr
->attribute
= attribute
;
510 if (last_abbrev
->first_attr
== NULL
)
511 last_abbrev
->first_attr
= attr
;
513 last_abbrev
->last_attr
->next
= attr
;
515 last_abbrev
->last_attr
= attr
;
518 /* Processes the (partial) contents of a .debug_abbrev section.
519 Returns NULL if the end of the section was encountered.
520 Returns the address after the last byte read if the end of
521 an abbreviation set was found. */
523 static unsigned char *
524 process_abbrev_section (unsigned char *start
, unsigned char *end
)
526 if (first_abbrev
!= NULL
)
531 unsigned int bytes_read
;
534 unsigned long attribute
;
537 entry
= read_leb128 (start
, & bytes_read
, 0);
540 /* A single zero is supposed to end the section according
541 to the standard. If there's more, then signal that to
544 return start
== end
? NULL
: start
;
546 tag
= read_leb128 (start
, & bytes_read
, 0);
551 add_abbrev (entry
, tag
, children
);
557 attribute
= read_leb128 (start
, & bytes_read
, 0);
560 form
= read_leb128 (start
, & bytes_read
, 0);
564 add_abbrev_attr (attribute
, form
);
566 while (attribute
!= 0);
573 get_TAG_name (unsigned long tag
)
577 case DW_TAG_padding
: return "DW_TAG_padding";
578 case DW_TAG_array_type
: return "DW_TAG_array_type";
579 case DW_TAG_class_type
: return "DW_TAG_class_type";
580 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
581 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
582 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
583 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
584 case DW_TAG_label
: return "DW_TAG_label";
585 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
586 case DW_TAG_member
: return "DW_TAG_member";
587 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
588 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
589 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
590 case DW_TAG_string_type
: return "DW_TAG_string_type";
591 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
592 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
593 case DW_TAG_typedef
: return "DW_TAG_typedef";
594 case DW_TAG_union_type
: return "DW_TAG_union_type";
595 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
596 case DW_TAG_variant
: return "DW_TAG_variant";
597 case DW_TAG_common_block
: return "DW_TAG_common_block";
598 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
599 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
600 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
601 case DW_TAG_module
: return "DW_TAG_module";
602 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
603 case DW_TAG_set_type
: return "DW_TAG_set_type";
604 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
605 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
606 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
607 case DW_TAG_base_type
: return "DW_TAG_base_type";
608 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
609 case DW_TAG_const_type
: return "DW_TAG_const_type";
610 case DW_TAG_constant
: return "DW_TAG_constant";
611 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
612 case DW_TAG_file_type
: return "DW_TAG_file_type";
613 case DW_TAG_friend
: return "DW_TAG_friend";
614 case DW_TAG_namelist
: return "DW_TAG_namelist";
615 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
616 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
617 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
618 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
619 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
620 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
621 case DW_TAG_try_block
: return "DW_TAG_try_block";
622 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
623 case DW_TAG_variable
: return "DW_TAG_variable";
624 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
625 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
626 case DW_TAG_format_label
: return "DW_TAG_format_label";
627 case DW_TAG_function_template
: return "DW_TAG_function_template";
628 case DW_TAG_class_template
: return "DW_TAG_class_template";
629 /* DWARF 2.1 values. */
630 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
631 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
632 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
633 case DW_TAG_namespace
: return "DW_TAG_namespace";
634 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
635 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
636 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
637 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
638 case DW_TAG_condition
: return "DW_TAG_condition";
639 case DW_TAG_shared_type
: return "DW_TAG_shared_type";
640 /* DWARF 4 values. */
641 case DW_TAG_type_unit
: return "DW_TAG_type_unit";
642 case DW_TAG_rvalue_reference_type
: return "DW_TAG_rvalue_reference_type";
643 case DW_TAG_template_alias
: return "DW_TAG_template_alias";
645 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
646 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
647 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
650 static char buffer
[100];
652 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
659 get_FORM_name (unsigned long form
)
663 case DW_FORM_addr
: return "DW_FORM_addr";
664 case DW_FORM_block2
: return "DW_FORM_block2";
665 case DW_FORM_block4
: return "DW_FORM_block4";
666 case DW_FORM_data2
: return "DW_FORM_data2";
667 case DW_FORM_data4
: return "DW_FORM_data4";
668 case DW_FORM_data8
: return "DW_FORM_data8";
669 case DW_FORM_string
: return "DW_FORM_string";
670 case DW_FORM_block
: return "DW_FORM_block";
671 case DW_FORM_block1
: return "DW_FORM_block1";
672 case DW_FORM_data1
: return "DW_FORM_data1";
673 case DW_FORM_flag
: return "DW_FORM_flag";
674 case DW_FORM_sdata
: return "DW_FORM_sdata";
675 case DW_FORM_strp
: return "DW_FORM_strp";
676 case DW_FORM_udata
: return "DW_FORM_udata";
677 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
678 case DW_FORM_ref1
: return "DW_FORM_ref1";
679 case DW_FORM_ref2
: return "DW_FORM_ref2";
680 case DW_FORM_ref4
: return "DW_FORM_ref4";
681 case DW_FORM_ref8
: return "DW_FORM_ref8";
682 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
683 case DW_FORM_indirect
: return "DW_FORM_indirect";
684 /* DWARF 4 values. */
685 case DW_FORM_sec_offset
: return "DW_FORM_sec_offset";
686 case DW_FORM_exprloc
: return "DW_FORM_exprloc";
687 case DW_FORM_flag_present
: return "DW_FORM_flag_present";
688 case DW_FORM_ref_sig8
: return "DW_FORM_ref_sig8";
691 static char buffer
[100];
693 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
699 static unsigned char *
700 display_block (unsigned char *data
, unsigned long length
)
702 printf (_(" %lu byte block: "), length
);
705 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
711 decode_location_expression (unsigned char * data
,
712 unsigned int pointer_size
,
713 unsigned long length
,
714 unsigned long cu_offset
,
715 struct dwarf_section
* section
)
718 unsigned int bytes_read
;
719 unsigned long uvalue
;
720 unsigned char *end
= data
+ length
;
721 int need_frame_base
= 0;
730 printf ("DW_OP_addr: %lx",
731 (unsigned long) byte_get (data
, pointer_size
));
732 data
+= pointer_size
;
735 printf ("DW_OP_deref");
738 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
741 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
744 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
748 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
752 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
756 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
760 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
761 (unsigned long) byte_get (data
+ 4, 4));
765 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
766 (long) byte_get (data
+ 4, 4));
770 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
774 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
778 printf ("DW_OP_dup");
781 printf ("DW_OP_drop");
784 printf ("DW_OP_over");
787 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
790 printf ("DW_OP_swap");
793 printf ("DW_OP_rot");
796 printf ("DW_OP_xderef");
799 printf ("DW_OP_abs");
802 printf ("DW_OP_and");
805 printf ("DW_OP_div");
808 printf ("DW_OP_minus");
811 printf ("DW_OP_mod");
814 printf ("DW_OP_mul");
817 printf ("DW_OP_neg");
820 printf ("DW_OP_not");
826 printf ("DW_OP_plus");
828 case DW_OP_plus_uconst
:
829 printf ("DW_OP_plus_uconst: %lu",
830 read_leb128 (data
, &bytes_read
, 0));
834 printf ("DW_OP_shl");
837 printf ("DW_OP_shr");
840 printf ("DW_OP_shra");
843 printf ("DW_OP_xor");
846 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
868 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
904 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
939 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
974 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
975 read_leb128 (data
, &bytes_read
, 1));
980 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
985 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
989 uvalue
= read_leb128 (data
, &bytes_read
, 0);
991 printf ("DW_OP_bregx: %lu %ld", uvalue
,
992 read_leb128 (data
, &bytes_read
, 1));
996 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
999 case DW_OP_deref_size
:
1000 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
1002 case DW_OP_xderef_size
:
1003 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
1006 printf ("DW_OP_nop");
1009 /* DWARF 3 extensions. */
1010 case DW_OP_push_object_address
:
1011 printf ("DW_OP_push_object_address");
1014 /* XXX: Strictly speaking for 64-bit DWARF3 files
1015 this ought to be an 8-byte wide computation. */
1016 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
1020 /* XXX: Strictly speaking for 64-bit DWARF3 files
1021 this ought to be an 8-byte wide computation. */
1022 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
1025 case DW_OP_call_ref
:
1026 /* XXX: Strictly speaking for 64-bit DWARF3 files
1027 this ought to be an 8-byte wide computation. */
1028 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
1031 case DW_OP_form_tls_address
:
1032 printf ("DW_OP_form_tls_address");
1034 case DW_OP_call_frame_cfa
:
1035 printf ("DW_OP_call_frame_cfa");
1037 case DW_OP_bit_piece
:
1038 printf ("DW_OP_bit_piece: ");
1039 printf ("size: %lu ", read_leb128 (data
, &bytes_read
, 0));
1041 printf ("offset: %lu ", read_leb128 (data
, &bytes_read
, 0));
1045 /* DWARF 4 extensions. */
1046 case DW_OP_stack_value
:
1047 printf ("DW_OP_stack_value");
1050 case DW_OP_implicit_value
:
1051 printf ("DW_OP_implicit_value");
1052 uvalue
= read_leb128 (data
, &bytes_read
, 0);
1054 display_block (data
, uvalue
);
1058 /* GNU extensions. */
1059 case DW_OP_GNU_push_tls_address
:
1060 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1062 case DW_OP_GNU_uninit
:
1063 printf ("DW_OP_GNU_uninit");
1064 /* FIXME: Is there data associated with this OP ? */
1066 case DW_OP_GNU_encoded_addr
:
1072 addr
= get_encoded_value (data
, encoding
);
1073 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1074 addr
+= section
->address
+ (data
- section
->start
);
1075 data
+= size_of_encoded_value (encoding
);
1077 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1078 print_dwarf_vma (addr
, pointer_size
);
1082 /* HP extensions. */
1083 case DW_OP_HP_is_value
:
1084 printf ("DW_OP_HP_is_value");
1085 /* FIXME: Is there data associated with this OP ? */
1087 case DW_OP_HP_fltconst4
:
1088 printf ("DW_OP_HP_fltconst4");
1089 /* FIXME: Is there data associated with this OP ? */
1091 case DW_OP_HP_fltconst8
:
1092 printf ("DW_OP_HP_fltconst8");
1093 /* FIXME: Is there data associated with this OP ? */
1095 case DW_OP_HP_mod_range
:
1096 printf ("DW_OP_HP_mod_range");
1097 /* FIXME: Is there data associated with this OP ? */
1099 case DW_OP_HP_unmod_range
:
1100 printf ("DW_OP_HP_unmod_range");
1101 /* FIXME: Is there data associated with this OP ? */
1104 printf ("DW_OP_HP_tls");
1105 /* FIXME: Is there data associated with this OP ? */
1108 /* PGI (STMicroelectronics) extensions. */
1109 case DW_OP_PGI_omp_thread_num
:
1110 /* Pushes the thread number for the current thread as it would be
1111 returned by the standard OpenMP library function:
1112 omp_get_thread_num(). The "current thread" is the thread for
1113 which the expression is being evaluated. */
1114 printf ("DW_OP_PGI_omp_thread_num");
1118 if (op
>= DW_OP_lo_user
1119 && op
<= DW_OP_hi_user
)
1120 printf (_("(User defined location op)"));
1122 printf (_("(Unknown location op)"));
1123 /* No way to tell where the next op is, so just bail. */
1124 return need_frame_base
;
1127 /* Separate the ops. */
1132 return need_frame_base
;
1135 static unsigned char *
1136 read_and_display_attr_value (unsigned long attribute
,
1138 unsigned char * data
,
1139 unsigned long cu_offset
,
1140 unsigned long pointer_size
,
1141 unsigned long offset_size
,
1143 debug_info
* debug_info_p
,
1145 struct dwarf_section
* section
)
1147 unsigned long uvalue
= 0;
1148 unsigned char *block_start
= NULL
;
1149 unsigned char * orig_data
= data
;
1150 unsigned int bytes_read
;
1157 case DW_FORM_ref_addr
:
1158 if (dwarf_version
== 2)
1160 uvalue
= byte_get (data
, pointer_size
);
1161 data
+= pointer_size
;
1163 else if (dwarf_version
== 3 || dwarf_version
== 4)
1165 uvalue
= byte_get (data
, offset_size
);
1166 data
+= offset_size
;
1170 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1175 uvalue
= byte_get (data
, pointer_size
);
1176 data
+= pointer_size
;
1180 case DW_FORM_sec_offset
:
1181 uvalue
= byte_get (data
, offset_size
);
1182 data
+= offset_size
;
1185 case DW_FORM_flag_present
:
1192 uvalue
= byte_get (data
++, 1);
1197 uvalue
= byte_get (data
, 2);
1203 uvalue
= byte_get (data
, 4);
1208 uvalue
= read_leb128 (data
, & bytes_read
, 1);
1212 case DW_FORM_ref_udata
:
1214 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1218 case DW_FORM_indirect
:
1219 form
= read_leb128 (data
, & bytes_read
, 0);
1222 printf (" %s", get_FORM_name (form
));
1223 return read_and_display_attr_value (attribute
, form
, data
,
1224 cu_offset
, pointer_size
,
1225 offset_size
, dwarf_version
,
1226 debug_info_p
, do_loc
,
1232 case DW_FORM_ref_addr
:
1234 printf (" <0x%lx>", uvalue
);
1240 case DW_FORM_ref_udata
:
1242 printf (" <0x%lx>", uvalue
+ cu_offset
);
1247 case DW_FORM_sec_offset
:
1249 printf (" 0x%lx", uvalue
);
1252 case DW_FORM_flag_present
:
1259 printf (" %ld", uvalue
);
1266 uvalue
= byte_get (data
, 4);
1267 printf (" 0x%lx", uvalue
);
1268 printf (" 0x%lx", (unsigned long) byte_get (data
+ 4, 4));
1270 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1271 && num_debug_info_entries
== 0)
1273 if (sizeof (uvalue
) == 8)
1274 uvalue
= byte_get (data
, 8);
1276 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1281 case DW_FORM_string
:
1283 printf (" %s", data
);
1284 data
+= strlen ((char *) data
) + 1;
1288 case DW_FORM_exprloc
:
1289 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1290 block_start
= data
+ bytes_read
;
1292 data
= block_start
+ uvalue
;
1294 data
= display_block (block_start
, uvalue
);
1297 case DW_FORM_block1
:
1298 uvalue
= byte_get (data
, 1);
1299 block_start
= data
+ 1;
1301 data
= block_start
+ uvalue
;
1303 data
= display_block (block_start
, uvalue
);
1306 case DW_FORM_block2
:
1307 uvalue
= byte_get (data
, 2);
1308 block_start
= data
+ 2;
1310 data
= block_start
+ uvalue
;
1312 data
= display_block (block_start
, uvalue
);
1315 case DW_FORM_block4
:
1316 uvalue
= byte_get (data
, 4);
1317 block_start
= data
+ 4;
1319 data
= block_start
+ uvalue
;
1321 data
= display_block (block_start
, uvalue
);
1326 printf (_(" (indirect string, offset: 0x%lx): %s"),
1327 uvalue
, fetch_indirect_string (uvalue
));
1330 case DW_FORM_indirect
:
1331 /* Handled above. */
1334 case DW_FORM_ref_sig8
:
1338 printf (" signature: ");
1339 for (i
= 0; i
< 8; i
++)
1341 printf ("%02x", (unsigned) byte_get (data
, 1));
1350 warn (_("Unrecognized form: %lu\n"), form
);
1354 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1355 && num_debug_info_entries
== 0)
1359 case DW_AT_frame_base
:
1360 have_frame_base
= 1;
1361 case DW_AT_location
:
1362 case DW_AT_string_length
:
1363 case DW_AT_return_addr
:
1364 case DW_AT_data_member_location
:
1365 case DW_AT_vtable_elem_location
:
1367 case DW_AT_static_link
:
1368 case DW_AT_use_location
:
1369 if (form
== DW_FORM_data4
1370 || form
== DW_FORM_data8
1371 || form
== DW_FORM_sec_offset
)
1373 /* Process location list. */
1374 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1375 unsigned int num
= debug_info_p
->num_loc_offsets
;
1377 if (lmax
== 0 || num
>= lmax
)
1380 debug_info_p
->loc_offsets
= (long unsigned int *)
1381 xcrealloc (debug_info_p
->loc_offsets
,
1382 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1383 debug_info_p
->have_frame_base
= (int *)
1384 xcrealloc (debug_info_p
->have_frame_base
,
1385 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1386 debug_info_p
->max_loc_offsets
= lmax
;
1388 debug_info_p
->loc_offsets
[num
] = uvalue
;
1389 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1390 debug_info_p
->num_loc_offsets
++;
1395 if (need_base_address
)
1396 debug_info_p
->base_address
= uvalue
;
1400 if (form
== DW_FORM_data4
1401 || form
== DW_FORM_data8
1402 || form
== DW_FORM_sec_offset
)
1404 /* Process range list. */
1405 unsigned int lmax
= debug_info_p
->max_range_lists
;
1406 unsigned int num
= debug_info_p
->num_range_lists
;
1408 if (lmax
== 0 || num
>= lmax
)
1411 debug_info_p
->range_lists
= (long unsigned int *)
1412 xcrealloc (debug_info_p
->range_lists
,
1413 lmax
, sizeof (*debug_info_p
->range_lists
));
1414 debug_info_p
->max_range_lists
= lmax
;
1416 debug_info_p
->range_lists
[num
] = uvalue
;
1417 debug_info_p
->num_range_lists
++;
1429 /* For some attributes we can display further information. */
1437 case DW_INL_not_inlined
:
1438 printf (_("(not inlined)"));
1440 case DW_INL_inlined
:
1441 printf (_("(inlined)"));
1443 case DW_INL_declared_not_inlined
:
1444 printf (_("(declared as inline but ignored)"));
1446 case DW_INL_declared_inlined
:
1447 printf (_("(declared as inline and inlined)"));
1450 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1455 case DW_AT_language
:
1458 /* Ordered by the numeric value of these constants. */
1459 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1460 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1461 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1462 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1463 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1464 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1465 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1466 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1467 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1468 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1469 /* DWARF 2.1 values. */
1470 case DW_LANG_Java
: printf ("(Java)"); break;
1471 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1472 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1473 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1474 /* DWARF 3 values. */
1475 case DW_LANG_PLI
: printf ("(PLI)"); break;
1476 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1477 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1478 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1479 case DW_LANG_D
: printf ("(D)"); break;
1480 /* DWARF 4 values. */
1481 case DW_LANG_Python
: printf ("(Python)"); break;
1482 /* MIPS extension. */
1483 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1484 /* UPC extension. */
1485 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1487 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1488 printf ("(implementation defined: %lx)", uvalue
);
1490 printf ("(Unknown: %lx)", uvalue
);
1495 case DW_AT_encoding
:
1498 case DW_ATE_void
: printf ("(void)"); break;
1499 case DW_ATE_address
: printf ("(machine address)"); break;
1500 case DW_ATE_boolean
: printf ("(boolean)"); break;
1501 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1502 case DW_ATE_float
: printf ("(float)"); break;
1503 case DW_ATE_signed
: printf ("(signed)"); break;
1504 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1505 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1506 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1507 /* DWARF 2.1 values: */
1508 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1509 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1510 /* DWARF 3 values: */
1511 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1512 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1513 case DW_ATE_edited
: printf ("(edited)"); break;
1514 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1515 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1516 /* HP extensions: */
1517 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1518 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1519 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1520 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1521 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1522 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1523 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1526 if (uvalue
>= DW_ATE_lo_user
1527 && uvalue
<= DW_ATE_hi_user
)
1528 printf ("(user defined type)");
1530 printf ("(unknown type)");
1535 case DW_AT_accessibility
:
1538 case DW_ACCESS_public
: printf ("(public)"); break;
1539 case DW_ACCESS_protected
: printf ("(protected)"); break;
1540 case DW_ACCESS_private
: printf ("(private)"); break;
1542 printf ("(unknown accessibility)");
1547 case DW_AT_visibility
:
1550 case DW_VIS_local
: printf ("(local)"); break;
1551 case DW_VIS_exported
: printf ("(exported)"); break;
1552 case DW_VIS_qualified
: printf ("(qualified)"); break;
1553 default: printf ("(unknown visibility)"); break;
1557 case DW_AT_virtuality
:
1560 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1561 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1562 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1563 default: printf ("(unknown virtuality)"); break;
1567 case DW_AT_identifier_case
:
1570 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1571 case DW_ID_up_case
: printf ("(up_case)"); break;
1572 case DW_ID_down_case
: printf ("(down_case)"); break;
1573 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1574 default: printf ("(unknown case)"); break;
1578 case DW_AT_calling_convention
:
1581 case DW_CC_normal
: printf ("(normal)"); break;
1582 case DW_CC_program
: printf ("(program)"); break;
1583 case DW_CC_nocall
: printf ("(nocall)"); break;
1585 if (uvalue
>= DW_CC_lo_user
1586 && uvalue
<= DW_CC_hi_user
)
1587 printf ("(user defined)");
1589 printf ("(unknown convention)");
1593 case DW_AT_ordering
:
1596 case -1: printf ("(undefined)"); break;
1597 case 0: printf ("(row major)"); break;
1598 case 1: printf ("(column major)"); break;
1602 case DW_AT_frame_base
:
1603 have_frame_base
= 1;
1604 case DW_AT_location
:
1605 case DW_AT_string_length
:
1606 case DW_AT_return_addr
:
1607 case DW_AT_data_member_location
:
1608 case DW_AT_vtable_elem_location
:
1610 case DW_AT_static_link
:
1611 case DW_AT_use_location
:
1612 if (form
== DW_FORM_data4
1613 || form
== DW_FORM_data8
1614 || form
== DW_FORM_sec_offset
)
1615 printf (_("(location list)"));
1617 case DW_AT_allocated
:
1618 case DW_AT_associated
:
1619 case DW_AT_data_location
:
1621 case DW_AT_upper_bound
:
1622 case DW_AT_lower_bound
:
1625 int need_frame_base
;
1628 need_frame_base
= decode_location_expression (block_start
,
1631 cu_offset
, section
);
1633 if (need_frame_base
&& !have_frame_base
)
1634 printf (_(" [without DW_AT_frame_base]"));
1640 if (form
== DW_FORM_ref_sig8
)
1643 if (form
== DW_FORM_ref1
1644 || form
== DW_FORM_ref2
1645 || form
== DW_FORM_ref4
)
1646 uvalue
+= cu_offset
;
1648 if (uvalue
>= section
->size
)
1649 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1650 uvalue
, (unsigned long) (orig_data
- section
->start
));
1653 unsigned long abbrev_number
;
1654 abbrev_entry
* entry
;
1656 abbrev_number
= read_leb128 (section
->start
+ uvalue
, NULL
, 0);
1658 printf ("[Abbrev Number: %ld", abbrev_number
);
1659 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
1660 if (entry
->entry
== abbrev_number
)
1663 printf (" (%s)", get_TAG_name (entry
->tag
));
1677 get_AT_name (unsigned long attribute
)
1681 case DW_AT_sibling
: return "DW_AT_sibling";
1682 case DW_AT_location
: return "DW_AT_location";
1683 case DW_AT_name
: return "DW_AT_name";
1684 case DW_AT_ordering
: return "DW_AT_ordering";
1685 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1686 case DW_AT_byte_size
: return "DW_AT_byte_size";
1687 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1688 case DW_AT_bit_size
: return "DW_AT_bit_size";
1689 case DW_AT_element_list
: return "DW_AT_element_list";
1690 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1691 case DW_AT_low_pc
: return "DW_AT_low_pc";
1692 case DW_AT_high_pc
: return "DW_AT_high_pc";
1693 case DW_AT_language
: return "DW_AT_language";
1694 case DW_AT_member
: return "DW_AT_member";
1695 case DW_AT_discr
: return "DW_AT_discr";
1696 case DW_AT_discr_value
: return "DW_AT_discr_value";
1697 case DW_AT_visibility
: return "DW_AT_visibility";
1698 case DW_AT_import
: return "DW_AT_import";
1699 case DW_AT_string_length
: return "DW_AT_string_length";
1700 case DW_AT_common_reference
: return "DW_AT_common_reference";
1701 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1702 case DW_AT_const_value
: return "DW_AT_const_value";
1703 case DW_AT_containing_type
: return "DW_AT_containing_type";
1704 case DW_AT_default_value
: return "DW_AT_default_value";
1705 case DW_AT_inline
: return "DW_AT_inline";
1706 case DW_AT_is_optional
: return "DW_AT_is_optional";
1707 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1708 case DW_AT_producer
: return "DW_AT_producer";
1709 case DW_AT_prototyped
: return "DW_AT_prototyped";
1710 case DW_AT_return_addr
: return "DW_AT_return_addr";
1711 case DW_AT_start_scope
: return "DW_AT_start_scope";
1712 case DW_AT_stride_size
: return "DW_AT_stride_size";
1713 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1714 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1715 case DW_AT_accessibility
: return "DW_AT_accessibility";
1716 case DW_AT_address_class
: return "DW_AT_address_class";
1717 case DW_AT_artificial
: return "DW_AT_artificial";
1718 case DW_AT_base_types
: return "DW_AT_base_types";
1719 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1720 case DW_AT_count
: return "DW_AT_count";
1721 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1722 case DW_AT_decl_column
: return "DW_AT_decl_column";
1723 case DW_AT_decl_file
: return "DW_AT_decl_file";
1724 case DW_AT_decl_line
: return "DW_AT_decl_line";
1725 case DW_AT_declaration
: return "DW_AT_declaration";
1726 case DW_AT_discr_list
: return "DW_AT_discr_list";
1727 case DW_AT_encoding
: return "DW_AT_encoding";
1728 case DW_AT_external
: return "DW_AT_external";
1729 case DW_AT_frame_base
: return "DW_AT_frame_base";
1730 case DW_AT_friend
: return "DW_AT_friend";
1731 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1732 case DW_AT_macro_info
: return "DW_AT_macro_info";
1733 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1734 case DW_AT_priority
: return "DW_AT_priority";
1735 case DW_AT_segment
: return "DW_AT_segment";
1736 case DW_AT_specification
: return "DW_AT_specification";
1737 case DW_AT_static_link
: return "DW_AT_static_link";
1738 case DW_AT_type
: return "DW_AT_type";
1739 case DW_AT_use_location
: return "DW_AT_use_location";
1740 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1741 case DW_AT_virtuality
: return "DW_AT_virtuality";
1742 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1743 /* DWARF 2.1 values. */
1744 case DW_AT_allocated
: return "DW_AT_allocated";
1745 case DW_AT_associated
: return "DW_AT_associated";
1746 case DW_AT_data_location
: return "DW_AT_data_location";
1747 case DW_AT_stride
: return "DW_AT_stride";
1748 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1749 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1750 case DW_AT_extension
: return "DW_AT_extension";
1751 case DW_AT_ranges
: return "DW_AT_ranges";
1752 case DW_AT_trampoline
: return "DW_AT_trampoline";
1753 case DW_AT_call_column
: return "DW_AT_call_column";
1754 case DW_AT_call_file
: return "DW_AT_call_file";
1755 case DW_AT_call_line
: return "DW_AT_call_line";
1756 case DW_AT_description
: return "DW_AT_description";
1757 case DW_AT_binary_scale
: return "DW_AT_binary_scale";
1758 case DW_AT_decimal_scale
: return "DW_AT_decimal_scale";
1759 case DW_AT_small
: return "DW_AT_small";
1760 case DW_AT_decimal_sign
: return "DW_AT_decimal_sign";
1761 case DW_AT_digit_count
: return "DW_AT_digit_count";
1762 case DW_AT_picture_string
: return "DW_AT_picture_string";
1763 case DW_AT_mutable
: return "DW_AT_mutable";
1764 case DW_AT_threads_scaled
: return "DW_AT_threads_scaled";
1765 case DW_AT_explicit
: return "DW_AT_explicit";
1766 case DW_AT_object_pointer
: return "DW_AT_object_pointer";
1767 case DW_AT_endianity
: return "DW_AT_endianity";
1768 case DW_AT_elemental
: return "DW_AT_elemental";
1769 case DW_AT_pure
: return "DW_AT_pure";
1770 case DW_AT_recursive
: return "DW_AT_recursive";
1771 /* DWARF 4 values. */
1772 case DW_AT_signature
: return "DW_AT_signature";
1773 case DW_AT_main_subprogram
: return "DW_AT_main_subprogram";
1774 case DW_AT_data_bit_offset
: return "DW_AT_data_bit_offset";
1775 case DW_AT_const_expr
: return "DW_AT_const_expr";
1776 case DW_AT_enum_class
: return "DW_AT_enum_class";
1777 case DW_AT_linkage_name
: return "DW_AT_linkage_name";
1779 /* HP and SGI/MIPS extensions. */
1780 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1781 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1782 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1783 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1784 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
1785 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1786 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1787 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1788 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1789 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1791 /* HP Extensions. */
1792 case DW_AT_HP_block_index
: return "DW_AT_HP_block_index";
1793 case DW_AT_HP_actuals_stmt_list
: return "DW_AT_HP_actuals_stmt_list";
1794 case DW_AT_HP_proc_per_section
: return "DW_AT_HP_proc_per_section";
1795 case DW_AT_HP_raw_data_ptr
: return "DW_AT_HP_raw_data_ptr";
1796 case DW_AT_HP_pass_by_reference
: return "DW_AT_HP_pass_by_reference";
1797 case DW_AT_HP_opt_level
: return "DW_AT_HP_opt_level";
1798 case DW_AT_HP_prof_version_id
: return "DW_AT_HP_prof_version_id";
1799 case DW_AT_HP_opt_flags
: return "DW_AT_HP_opt_flags";
1800 case DW_AT_HP_cold_region_low_pc
: return "DW_AT_HP_cold_region_low_pc";
1801 case DW_AT_HP_cold_region_high_pc
: return "DW_AT_HP_cold_region_high_pc";
1802 case DW_AT_HP_all_variables_modifiable
: return "DW_AT_HP_all_variables_modifiable";
1803 case DW_AT_HP_linkage_name
: return "DW_AT_HP_linkage_name";
1804 case DW_AT_HP_prof_flags
: return "DW_AT_HP_prof_flags";
1806 /* One value is shared by the MIPS and HP extensions: */
1807 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1809 /* GNU extensions. */
1810 case DW_AT_sf_names
: return "DW_AT_sf_names";
1811 case DW_AT_src_info
: return "DW_AT_src_info";
1812 case DW_AT_mac_info
: return "DW_AT_mac_info";
1813 case DW_AT_src_coords
: return "DW_AT_src_coords";
1814 case DW_AT_body_begin
: return "DW_AT_body_begin";
1815 case DW_AT_body_end
: return "DW_AT_body_end";
1816 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1817 case DW_AT_GNU_guarded_by
: return "DW_AT_GNU_guarded_by";
1818 case DW_AT_GNU_pt_guarded_by
: return "DW_AT_GNU_pt_guarded_by";
1819 case DW_AT_GNU_guarded
: return "DW_AT_GNU_guarded";
1820 case DW_AT_GNU_pt_guarded
: return "DW_AT_GNU_pt_guarded";
1821 case DW_AT_GNU_locks_excluded
: return "DW_AT_GNU_locks_excluded";
1822 case DW_AT_GNU_exclusive_locks_required
: return "DW_AT_GNU_exclusive_locks_required";
1823 case DW_AT_GNU_shared_locks_required
: return "DW_AT_GNU_shared_locks_required";
1824 case DW_AT_GNU_odr_signature
: return "DW_AT_GNU_odr_signature";
1825 case DW_AT_use_GNAT_descriptive_type
: return "DW_AT_use_GNAT_descriptive_type";
1826 case DW_AT_GNAT_descriptive_type
: return "DW_AT_GNAT_descriptive_type";
1828 /* UPC extension. */
1829 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1831 /* PGI (STMicroelectronics) extensions. */
1832 case DW_AT_PGI_lbase
: return "DW_AT_PGI_lbase";
1833 case DW_AT_PGI_soffset
: return "DW_AT_PGI_soffset";
1834 case DW_AT_PGI_lstride
: return "DW_AT_PGI_lstride";
1838 static char buffer
[100];
1840 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1847 static unsigned char *
1848 read_and_display_attr (unsigned long attribute
,
1850 unsigned char * data
,
1851 unsigned long cu_offset
,
1852 unsigned long pointer_size
,
1853 unsigned long offset_size
,
1855 debug_info
* debug_info_p
,
1857 struct dwarf_section
* section
)
1860 printf (" %-18s:", get_AT_name (attribute
));
1861 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1862 pointer_size
, offset_size
,
1863 dwarf_version
, debug_info_p
,
1871 /* Process the contents of a .debug_info section. If do_loc is non-zero
1872 then we are scanning for location lists and we do not want to display
1873 anything to the user. If do_types is non-zero, we are processing
1874 a .debug_types section instead of a .debug_info section. */
1877 process_debug_info (struct dwarf_section
*section
,
1879 enum dwarf_section_display_enum abbrev_sec
,
1883 unsigned char *start
= section
->start
;
1884 unsigned char *end
= start
+ section
->size
;
1885 unsigned char *section_begin
;
1887 unsigned int num_units
= 0;
1889 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1890 && num_debug_info_entries
== 0
1893 unsigned long length
;
1895 /* First scan the section to get the number of comp units. */
1896 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1899 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1900 will be the length. For a 64-bit DWARF section, it'll be
1901 the escape code 0xffffffff followed by an 8 byte length. */
1902 length
= byte_get (section_begin
, 4);
1904 if (length
== 0xffffffff)
1906 length
= byte_get (section_begin
+ 4, 8);
1907 section_begin
+= length
+ 12;
1909 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
1911 warn (_("Reserved length value (%lx) found in section %s\n"), length
, section
->name
);
1915 section_begin
+= length
+ 4;
1917 /* Negative values are illegal, they may even cause infinite
1918 looping. This can happen if we can't accurately apply
1919 relocations to an object file. */
1920 if ((signed long) length
<= 0)
1922 warn (_("Corrupt unit length (%lx) found in section %s\n"), length
, section
->name
);
1929 error (_("No comp units in %s section ?"), section
->name
);
1933 /* Then allocate an array to hold the information. */
1934 debug_information
= (debug_info
*) cmalloc (num_units
,
1935 sizeof (* debug_information
));
1936 if (debug_information
== NULL
)
1938 error (_("Not enough memory for a debug info array of %u entries"),
1946 printf (_("Contents of the %s section:\n\n"), section
->name
);
1948 load_debug_section (str
, file
);
1951 load_debug_section (abbrev_sec
, file
);
1952 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
1954 warn (_("Unable to locate %s section!\n"),
1955 debug_displays
[abbrev_sec
].section
.name
);
1959 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1961 DWARF2_Internal_CompUnit compunit
;
1962 unsigned char *hdrptr
;
1963 unsigned char *tags
;
1965 unsigned long cu_offset
;
1967 int initial_length_size
;
1968 unsigned char signature
[8] = { 0 };
1969 unsigned long type_offset
= 0;
1973 compunit
.cu_length
= byte_get (hdrptr
, 4);
1976 if (compunit
.cu_length
== 0xffffffff)
1978 compunit
.cu_length
= byte_get (hdrptr
, 8);
1981 initial_length_size
= 12;
1986 initial_length_size
= 4;
1989 compunit
.cu_version
= byte_get (hdrptr
, 2);
1992 cu_offset
= start
- section_begin
;
1994 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
1995 hdrptr
+= offset_size
;
1997 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
2004 for (i
= 0; i
< 8; i
++)
2006 signature
[i
] = byte_get (hdrptr
, 1);
2010 type_offset
= byte_get (hdrptr
, offset_size
);
2011 hdrptr
+= offset_size
;
2014 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2015 && num_debug_info_entries
== 0
2018 debug_information
[unit
].cu_offset
= cu_offset
;
2019 debug_information
[unit
].pointer_size
2020 = compunit
.cu_pointer_size
;
2021 debug_information
[unit
].base_address
= 0;
2022 debug_information
[unit
].loc_offsets
= NULL
;
2023 debug_information
[unit
].have_frame_base
= NULL
;
2024 debug_information
[unit
].max_loc_offsets
= 0;
2025 debug_information
[unit
].num_loc_offsets
= 0;
2026 debug_information
[unit
].range_lists
= NULL
;
2027 debug_information
[unit
].max_range_lists
= 0;
2028 debug_information
[unit
].num_range_lists
= 0;
2033 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
2034 printf (_(" Length: 0x%lx (%s)\n"), compunit
.cu_length
,
2035 initial_length_size
== 8 ? "64-bit" : "32-bit");
2036 printf (_(" Version: %d\n"), compunit
.cu_version
);
2037 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
2038 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2042 printf (_(" Signature: "));
2043 for (i
= 0; i
< 8; i
++)
2044 printf ("%02x", signature
[i
]);
2046 printf (_(" Type Offset: 0x%lx\n"), type_offset
);
2050 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2053 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
2054 cu_offset
, compunit
.cu_length
);
2058 start
+= compunit
.cu_length
+ initial_length_size
;
2060 if (compunit
.cu_version
!= 2
2061 && compunit
.cu_version
!= 3
2062 && compunit
.cu_version
!= 4)
2064 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
2065 cu_offset
, compunit
.cu_version
);
2071 /* Process the abbrevs used by this compilation unit. DWARF
2072 sections under Mach-O have non-zero addresses. */
2073 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev_sec
].section
.size
)
2074 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2075 (unsigned long) compunit
.cu_abbrev_offset
,
2076 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2078 process_abbrev_section
2079 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2080 + compunit
.cu_abbrev_offset
2081 - debug_displays
[abbrev_sec
].section
.address
,
2082 (unsigned char *) debug_displays
[abbrev_sec
].section
.start
2083 + debug_displays
[abbrev_sec
].section
.size
);
2086 while (tags
< start
)
2088 unsigned int bytes_read
;
2089 unsigned long abbrev_number
;
2090 unsigned long die_offset
;
2091 abbrev_entry
*entry
;
2094 die_offset
= tags
- section_begin
;
2096 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
2099 /* A null DIE marks the end of a list of siblings or it may also be
2100 a section padding. */
2101 if (abbrev_number
== 0)
2103 /* Check if it can be a section padding for the last CU. */
2104 if (level
== 0 && start
== end
)
2108 for (chk
= tags
; chk
< start
; chk
++)
2118 static unsigned num_bogus_warns
= 0;
2120 if (num_bogus_warns
< 3)
2122 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2125 if (num_bogus_warns
== 3)
2126 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2133 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2134 level
, die_offset
, abbrev_number
);
2136 /* Scan through the abbreviation list until we reach the
2138 for (entry
= first_abbrev
;
2139 entry
&& entry
->entry
!= abbrev_number
;
2140 entry
= entry
->next
)
2150 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2151 die_offset
, abbrev_number
);
2156 printf (_(" (%s)\n"), get_TAG_name (entry
->tag
));
2161 need_base_address
= 0;
2163 case DW_TAG_compile_unit
:
2164 need_base_address
= 1;
2166 case DW_TAG_entry_point
:
2167 case DW_TAG_subprogram
:
2168 need_base_address
= 0;
2169 /* Assuming that there is no DW_AT_frame_base. */
2170 have_frame_base
= 0;
2174 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2177 /* Show the offset from where the tag was extracted. */
2178 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
2180 tags
= read_and_display_attr (attr
->attribute
,
2183 compunit
.cu_pointer_size
,
2185 compunit
.cu_version
,
2186 debug_information
+ unit
,
2190 if (entry
->children
)
2195 /* Set num_debug_info_entries here so that it can be used to check if
2196 we need to process .debug_loc and .debug_ranges sections. */
2197 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2198 && num_debug_info_entries
== 0
2200 num_debug_info_entries
= num_units
;
2210 /* Locate and scan the .debug_info section in the file and record the pointer
2211 sizes and offsets for the compilation units in it. Usually an executable
2212 will have just one pointer size, but this is not guaranteed, and so we try
2213 not to make any assumptions. Returns zero upon failure, or the number of
2214 compilation units upon success. */
2217 load_debug_info (void * file
)
2219 /* Reset the last pointer size so that we can issue correct error
2220 messages if we are displaying the contents of more than one section. */
2221 last_pointer_size
= 0;
2222 warned_about_missing_comp_units
= FALSE
;
2224 /* If we have already tried and failed to load the .debug_info
2225 section then do not bother to repear the task. */
2226 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2229 /* If we already have the information there is nothing else to do. */
2230 if (num_debug_info_entries
> 0)
2231 return num_debug_info_entries
;
2233 if (load_debug_section (info
, file
)
2234 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2235 return num_debug_info_entries
;
2237 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2242 display_debug_lines_raw (struct dwarf_section
*section
,
2243 unsigned char *data
,
2246 unsigned char *start
= section
->start
;
2248 printf (_("Raw dump of debug contents of section %s:\n\n"),
2253 DWARF2_Internal_LineInfo linfo
;
2254 unsigned char *standard_opcodes
;
2255 unsigned char *end_of_sequence
;
2256 unsigned char *hdrptr
;
2257 unsigned long hdroff
;
2258 int initial_length_size
;
2263 hdroff
= hdrptr
- start
;
2265 /* Check the length of the block. */
2266 linfo
.li_length
= byte_get (hdrptr
, 4);
2269 if (linfo
.li_length
== 0xffffffff)
2271 /* This section is 64-bit DWARF 3. */
2272 linfo
.li_length
= byte_get (hdrptr
, 8);
2275 initial_length_size
= 12;
2280 initial_length_size
= 4;
2283 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2286 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2291 /* Check its version number. */
2292 linfo
.li_version
= byte_get (hdrptr
, 2);
2294 if (linfo
.li_version
!= 2
2295 && linfo
.li_version
!= 3
2296 && linfo
.li_version
!= 4)
2298 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2302 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2303 hdrptr
+= offset_size
;
2304 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2306 if (linfo
.li_version
>= 4)
2308 linfo
.li_max_ops_per_insn
= byte_get (hdrptr
, 1);
2310 if (linfo
.li_max_ops_per_insn
== 0)
2312 warn (_("Invalid maximum operations per insn.\n"));
2317 linfo
.li_max_ops_per_insn
= 1;
2318 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2320 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2322 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2324 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2327 /* Sign extend the line base field. */
2328 linfo
.li_line_base
<<= 24;
2329 linfo
.li_line_base
>>= 24;
2331 printf (_(" Offset: 0x%lx\n"), hdroff
);
2332 printf (_(" Length: %ld\n"), linfo
.li_length
);
2333 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2334 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2335 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2336 if (linfo
.li_version
>= 4)
2337 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2338 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2339 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2340 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2341 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2343 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2345 reset_state_machine (linfo
.li_default_is_stmt
);
2347 /* Display the contents of the Opcodes table. */
2348 standard_opcodes
= hdrptr
;
2350 printf (_("\n Opcodes:\n"));
2352 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2353 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2355 /* Display the contents of the Directory table. */
2356 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2359 printf (_("\n The Directory Table is empty.\n"));
2362 printf (_("\n The Directory Table:\n"));
2366 printf (_(" %s\n"), data
);
2368 data
+= strlen ((char *) data
) + 1;
2372 /* Skip the NUL at the end of the table. */
2375 /* Display the contents of the File Name table. */
2377 printf (_("\n The File Name Table is empty.\n"));
2380 printf (_("\n The File Name Table:\n"));
2381 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2385 unsigned char *name
;
2386 unsigned int bytes_read
;
2388 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
2391 data
+= strlen ((char *) data
) + 1;
2393 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2395 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2397 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2399 printf (_("%s\n"), name
);
2403 /* Skip the NUL at the end of the table. */
2406 /* Now display the statements. */
2407 printf (_("\n Line Number Statements:\n"));
2409 while (data
< end_of_sequence
)
2411 unsigned char op_code
;
2413 unsigned long int uladv
;
2414 unsigned int bytes_read
;
2418 if (op_code
>= linfo
.li_opcode_base
)
2420 op_code
-= linfo
.li_opcode_base
;
2421 uladv
= (op_code
/ linfo
.li_line_range
);
2422 if (linfo
.li_max_ops_per_insn
== 1)
2424 uladv
*= linfo
.li_min_insn_length
;
2425 state_machine_regs
.address
+= uladv
;
2426 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2427 op_code
, uladv
, state_machine_regs
.address
);
2431 state_machine_regs
.address
2432 += ((state_machine_regs
.op_index
+ uladv
)
2433 / linfo
.li_max_ops_per_insn
)
2434 * linfo
.li_min_insn_length
;
2435 state_machine_regs
.op_index
2436 = (state_machine_regs
.op_index
+ uladv
)
2437 % linfo
.li_max_ops_per_insn
;
2438 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx[%d]"),
2439 op_code
, uladv
, state_machine_regs
.address
,
2440 state_machine_regs
.op_index
);
2442 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2443 state_machine_regs
.line
+= adv
;
2444 printf (_(" and Line by %d to %d\n"),
2445 adv
, state_machine_regs
.line
);
2447 else switch (op_code
)
2449 case DW_LNS_extended_op
:
2450 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
);
2454 printf (_(" Copy\n"));
2457 case DW_LNS_advance_pc
:
2458 uladv
= read_leb128 (data
, & bytes_read
, 0);
2460 if (linfo
.li_max_ops_per_insn
== 1)
2462 uladv
*= linfo
.li_min_insn_length
;
2463 state_machine_regs
.address
+= uladv
;
2464 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
2465 state_machine_regs
.address
);
2469 state_machine_regs
.address
2470 += ((state_machine_regs
.op_index
+ uladv
)
2471 / linfo
.li_max_ops_per_insn
)
2472 * linfo
.li_min_insn_length
;
2473 state_machine_regs
.op_index
2474 = (state_machine_regs
.op_index
+ uladv
)
2475 % linfo
.li_max_ops_per_insn
;
2476 printf (_(" Advance PC by %lu to 0x%lx[%d]\n"), uladv
,
2477 state_machine_regs
.address
,
2478 state_machine_regs
.op_index
);
2482 case DW_LNS_advance_line
:
2483 adv
= read_leb128 (data
, & bytes_read
, 1);
2485 state_machine_regs
.line
+= adv
;
2486 printf (_(" Advance Line by %d to %d\n"), adv
,
2487 state_machine_regs
.line
);
2490 case DW_LNS_set_file
:
2491 adv
= read_leb128 (data
, & bytes_read
, 0);
2493 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2495 state_machine_regs
.file
= adv
;
2498 case DW_LNS_set_column
:
2499 uladv
= read_leb128 (data
, & bytes_read
, 0);
2501 printf (_(" Set column to %lu\n"), uladv
);
2502 state_machine_regs
.column
= uladv
;
2505 case DW_LNS_negate_stmt
:
2506 adv
= state_machine_regs
.is_stmt
;
2508 printf (_(" Set is_stmt to %d\n"), adv
);
2509 state_machine_regs
.is_stmt
= adv
;
2512 case DW_LNS_set_basic_block
:
2513 printf (_(" Set basic block\n"));
2514 state_machine_regs
.basic_block
= 1;
2517 case DW_LNS_const_add_pc
:
2518 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2519 if (linfo
.li_max_ops_per_insn
)
2521 uladv
*= linfo
.li_min_insn_length
;
2522 state_machine_regs
.address
+= uladv
;
2523 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2524 state_machine_regs
.address
);
2528 state_machine_regs
.address
2529 += ((state_machine_regs
.op_index
+ uladv
)
2530 / linfo
.li_max_ops_per_insn
)
2531 * linfo
.li_min_insn_length
;
2532 state_machine_regs
.op_index
2533 = (state_machine_regs
.op_index
+ uladv
)
2534 % linfo
.li_max_ops_per_insn
;
2535 printf (_(" Advance PC by constant %lu to 0x%lx[%d]\n"),
2536 uladv
, state_machine_regs
.address
,
2537 state_machine_regs
.op_index
);
2541 case DW_LNS_fixed_advance_pc
:
2542 uladv
= byte_get (data
, 2);
2544 state_machine_regs
.address
+= uladv
;
2545 state_machine_regs
.op_index
= 0;
2546 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2547 uladv
, state_machine_regs
.address
);
2550 case DW_LNS_set_prologue_end
:
2551 printf (_(" Set prologue_end to true\n"));
2554 case DW_LNS_set_epilogue_begin
:
2555 printf (_(" Set epilogue_begin to true\n"));
2558 case DW_LNS_set_isa
:
2559 uladv
= read_leb128 (data
, & bytes_read
, 0);
2561 printf (_(" Set ISA to %lu\n"), uladv
);
2565 printf (_(" Unknown opcode %d with operands: "), op_code
);
2567 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2569 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2570 i
== 1 ? "" : ", ");
2585 unsigned char *name
;
2586 unsigned int directory_index
;
2587 unsigned int modification_date
;
2588 unsigned int length
;
2591 /* Output a decoded representation of the .debug_line section. */
2594 display_debug_lines_decoded (struct dwarf_section
*section
,
2595 unsigned char *data
,
2598 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2603 /* This loop amounts to one iteration per compilation unit. */
2604 DWARF2_Internal_LineInfo linfo
;
2605 unsigned char *standard_opcodes
;
2606 unsigned char *end_of_sequence
;
2607 unsigned char *hdrptr
;
2608 int initial_length_size
;
2611 File_Entry
*file_table
= NULL
;
2612 unsigned char **directory_table
= NULL
;
2616 /* Extract information from the Line Number Program Header.
2617 (section 6.2.4 in the Dwarf3 doc). */
2619 /* Get the length of this CU's line number information block. */
2620 linfo
.li_length
= byte_get (hdrptr
, 4);
2623 if (linfo
.li_length
== 0xffffffff)
2625 /* This section is 64-bit DWARF 3. */
2626 linfo
.li_length
= byte_get (hdrptr
, 8);
2629 initial_length_size
= 12;
2634 initial_length_size
= 4;
2637 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2639 warn (_("The line info appears to be corrupt - "
2640 "the section is too small\n"));
2644 /* Get this CU's Line Number Block version number. */
2645 linfo
.li_version
= byte_get (hdrptr
, 2);
2647 if (linfo
.li_version
!= 2
2648 && linfo
.li_version
!= 3
2649 && linfo
.li_version
!= 4)
2651 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2656 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2657 hdrptr
+= offset_size
;
2658 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2660 if (linfo
.li_version
>= 4)
2662 linfo
.li_max_ops_per_insn
= byte_get (hdrptr
, 1);
2664 if (linfo
.li_max_ops_per_insn
== 0)
2666 warn (_("Invalid maximum operations per insn.\n"));
2671 linfo
.li_max_ops_per_insn
= 1;
2672 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2674 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2676 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2678 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2681 /* Sign extend the line base field. */
2682 linfo
.li_line_base
<<= 24;
2683 linfo
.li_line_base
>>= 24;
2685 /* Find the end of this CU's Line Number Information Block. */
2686 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2688 reset_state_machine (linfo
.li_default_is_stmt
);
2690 /* Save a pointer to the contents of the Opcodes table. */
2691 standard_opcodes
= hdrptr
;
2693 /* Traverse the Directory table just to count entries. */
2694 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2697 unsigned int n_directories
= 0;
2698 unsigned char *ptr_directory_table
= data
;
2702 data
+= strlen ((char *) data
) + 1;
2706 /* Go through the directory table again to save the directories. */
2707 directory_table
= (unsigned char **)
2708 xmalloc (n_directories
* sizeof (unsigned char *));
2711 while (*ptr_directory_table
!= 0)
2713 directory_table
[i
] = ptr_directory_table
;
2714 ptr_directory_table
+= strlen ((char *) ptr_directory_table
) + 1;
2718 /* Skip the NUL at the end of the table. */
2721 /* Traverse the File Name table just to count the entries. */
2724 unsigned int n_files
= 0;
2725 unsigned char *ptr_file_name_table
= data
;
2729 unsigned int bytes_read
;
2731 /* Skip Name, directory index, last modification time and length
2733 data
+= strlen ((char *) data
) + 1;
2734 read_leb128 (data
, & bytes_read
, 0);
2736 read_leb128 (data
, & bytes_read
, 0);
2738 read_leb128 (data
, & bytes_read
, 0);
2744 /* Go through the file table again to save the strings. */
2745 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
2748 while (*ptr_file_name_table
!= 0)
2750 unsigned int bytes_read
;
2752 file_table
[i
].name
= ptr_file_name_table
;
2753 ptr_file_name_table
+= strlen ((char *) ptr_file_name_table
) + 1;
2755 /* We are not interested in directory, time or size. */
2756 file_table
[i
].directory_index
= read_leb128 (ptr_file_name_table
,
2758 ptr_file_name_table
+= bytes_read
;
2759 file_table
[i
].modification_date
= read_leb128 (ptr_file_name_table
,
2761 ptr_file_name_table
+= bytes_read
;
2762 file_table
[i
].length
= read_leb128 (ptr_file_name_table
, & bytes_read
, 0);
2763 ptr_file_name_table
+= bytes_read
;
2768 /* Print the Compilation Unit's name and a header. */
2769 if (directory_table
== NULL
)
2771 printf (_("CU: %s:\n"), file_table
[0].name
);
2772 printf (_("File name Line number Starting address\n"));
2776 if (do_wide
|| strlen ((char *) directory_table
[0]) < 76)
2778 printf (_("CU: %s/%s:\n"), directory_table
[0],
2779 file_table
[0].name
);
2783 printf (_("%s:\n"), file_table
[0].name
);
2785 printf (_("File name Line number Starting address\n"));
2789 /* Skip the NUL at the end of the table. */
2792 /* This loop iterates through the Dwarf Line Number Program. */
2793 while (data
< end_of_sequence
)
2795 unsigned char op_code
;
2797 unsigned long int uladv
;
2798 unsigned int bytes_read
;
2799 int is_special_opcode
= 0;
2803 if (op_code
>= linfo
.li_opcode_base
)
2805 op_code
-= linfo
.li_opcode_base
;
2806 uladv
= (op_code
/ linfo
.li_line_range
);
2807 if (linfo
.li_max_ops_per_insn
== 1)
2809 uladv
*= linfo
.li_min_insn_length
;
2810 state_machine_regs
.address
+= uladv
;
2814 state_machine_regs
.address
2815 += ((state_machine_regs
.op_index
+ uladv
)
2816 / linfo
.li_max_ops_per_insn
)
2817 * linfo
.li_min_insn_length
;
2818 state_machine_regs
.op_index
2819 = (state_machine_regs
.op_index
+ uladv
)
2820 % linfo
.li_max_ops_per_insn
;
2823 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2824 state_machine_regs
.line
+= adv
;
2825 is_special_opcode
= 1;
2827 else switch (op_code
)
2829 case DW_LNS_extended_op
:
2831 unsigned int ext_op_code_len
;
2832 unsigned char ext_op_code
;
2833 unsigned char *op_code_data
= data
;
2835 ext_op_code_len
= read_leb128 (op_code_data
, &bytes_read
, 0);
2836 op_code_data
+= bytes_read
;
2838 if (ext_op_code_len
== 0)
2840 warn (_("badly formed extended line op encountered!\n"));
2843 ext_op_code_len
+= bytes_read
;
2844 ext_op_code
= *op_code_data
++;
2846 switch (ext_op_code
)
2848 case DW_LNE_end_sequence
:
2849 reset_state_machine (linfo
.li_default_is_stmt
);
2851 case DW_LNE_set_address
:
2852 state_machine_regs
.address
=
2853 byte_get (op_code_data
, ext_op_code_len
- bytes_read
- 1);
2854 state_machine_regs
.op_index
= 0;
2856 case DW_LNE_define_file
:
2858 unsigned int dir_index
= 0;
2860 ++state_machine_regs
.last_file_entry
;
2861 op_code_data
+= strlen ((char *) op_code_data
) + 1;
2862 dir_index
= read_leb128 (op_code_data
, & bytes_read
, 0);
2863 op_code_data
+= bytes_read
;
2864 read_leb128 (op_code_data
, & bytes_read
, 0);
2865 op_code_data
+= bytes_read
;
2866 read_leb128 (op_code_data
, & bytes_read
, 0);
2868 printf (_("%s:\n"), directory_table
[dir_index
]);
2872 printf (_("UNKNOWN: length %d\n"), ext_op_code_len
- bytes_read
);
2875 data
+= ext_op_code_len
;
2881 case DW_LNS_advance_pc
:
2882 uladv
= read_leb128 (data
, & bytes_read
, 0);
2884 if (linfo
.li_max_ops_per_insn
== 1)
2886 uladv
*= linfo
.li_min_insn_length
;
2887 state_machine_regs
.address
+= uladv
;
2891 state_machine_regs
.address
2892 += ((state_machine_regs
.op_index
+ uladv
)
2893 / linfo
.li_max_ops_per_insn
)
2894 * linfo
.li_min_insn_length
;
2895 state_machine_regs
.op_index
2896 = (state_machine_regs
.op_index
+ uladv
)
2897 % linfo
.li_max_ops_per_insn
;
2901 case DW_LNS_advance_line
:
2902 adv
= read_leb128 (data
, & bytes_read
, 1);
2904 state_machine_regs
.line
+= adv
;
2907 case DW_LNS_set_file
:
2908 adv
= read_leb128 (data
, & bytes_read
, 0);
2910 state_machine_regs
.file
= adv
;
2911 if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
2913 /* If directory index is 0, that means current directory. */
2914 printf (_("\n./%s:[++]\n"),
2915 file_table
[state_machine_regs
.file
- 1].name
);
2919 /* The directory index starts counting at 1. */
2920 printf (_("\n%s/%s:\n"),
2921 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
2922 file_table
[state_machine_regs
.file
- 1].name
);
2926 case DW_LNS_set_column
:
2927 uladv
= read_leb128 (data
, & bytes_read
, 0);
2929 state_machine_regs
.column
= uladv
;
2932 case DW_LNS_negate_stmt
:
2933 adv
= state_machine_regs
.is_stmt
;
2935 state_machine_regs
.is_stmt
= adv
;
2938 case DW_LNS_set_basic_block
:
2939 state_machine_regs
.basic_block
= 1;
2942 case DW_LNS_const_add_pc
:
2943 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2944 if (linfo
.li_max_ops_per_insn
== 1)
2946 uladv
*= linfo
.li_min_insn_length
;
2947 state_machine_regs
.address
+= uladv
;
2951 state_machine_regs
.address
2952 += ((state_machine_regs
.op_index
+ uladv
)
2953 / linfo
.li_max_ops_per_insn
)
2954 * linfo
.li_min_insn_length
;
2955 state_machine_regs
.op_index
2956 = (state_machine_regs
.op_index
+ uladv
)
2957 % linfo
.li_max_ops_per_insn
;
2961 case DW_LNS_fixed_advance_pc
:
2962 uladv
= byte_get (data
, 2);
2964 state_machine_regs
.address
+= uladv
;
2965 state_machine_regs
.op_index
= 0;
2968 case DW_LNS_set_prologue_end
:
2971 case DW_LNS_set_epilogue_begin
:
2974 case DW_LNS_set_isa
:
2975 uladv
= read_leb128 (data
, & bytes_read
, 0);
2977 printf (_(" Set ISA to %lu\n"), uladv
);
2981 printf (_(" Unknown opcode %d with operands: "), op_code
);
2983 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2985 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2986 i
== 1 ? "" : ", ");
2993 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2994 to the DWARF address/line matrix. */
2995 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
2996 || (op_code
== DW_LNS_copy
))
2998 const unsigned int MAX_FILENAME_LENGTH
= 35;
2999 char *fileName
= (char *)file_table
[state_machine_regs
.file
- 1].name
;
3000 char *newFileName
= NULL
;
3001 size_t fileNameLength
= strlen (fileName
);
3003 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3005 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3006 /* Truncate file name */
3007 strncpy (newFileName
,
3008 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3009 MAX_FILENAME_LENGTH
+ 1);
3013 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3014 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3017 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3019 if (linfo
.li_max_ops_per_insn
== 1)
3020 printf (_("%-35s %11d %#18lx\n"), newFileName
,
3021 state_machine_regs
.line
,
3022 state_machine_regs
.address
);
3024 printf (_("%-35s %11d %#18lx[%d]\n"), newFileName
,
3025 state_machine_regs
.line
,
3026 state_machine_regs
.address
,
3027 state_machine_regs
.op_index
);
3031 if (linfo
.li_max_ops_per_insn
== 1)
3032 printf (_("%s %11d %#18lx\n"), newFileName
,
3033 state_machine_regs
.line
,
3034 state_machine_regs
.address
);
3036 printf (_("%s %11d %#18lx[%d]\n"), newFileName
,
3037 state_machine_regs
.line
,
3038 state_machine_regs
.address
,
3039 state_machine_regs
.op_index
);
3042 if (op_code
== DW_LNE_end_sequence
)
3050 free (directory_table
);
3051 directory_table
= NULL
;
3059 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3061 unsigned char *data
= section
->start
;
3062 unsigned char *end
= data
+ section
->size
;
3064 int retValDecoded
= 1;
3066 if (do_debug_lines
== 0)
3067 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3069 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3070 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3072 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3073 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3075 if (!retValRaw
|| !retValDecoded
)
3082 find_debug_info_for_offset (unsigned long offset
)
3086 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3089 for (i
= 0; i
< num_debug_info_entries
; i
++)
3090 if (debug_information
[i
].cu_offset
== offset
)
3091 return debug_information
+ i
;
3097 display_debug_pubnames (struct dwarf_section
*section
,
3098 void *file ATTRIBUTE_UNUSED
)
3100 DWARF2_Internal_PubNames names
;
3101 unsigned char *start
= section
->start
;
3102 unsigned char *end
= start
+ section
->size
;
3104 /* It does not matter if this load fails,
3105 we test for that later on. */
3106 load_debug_info (file
);
3108 printf (_("Contents of the %s section:\n\n"), section
->name
);
3112 unsigned char *data
;
3113 unsigned long offset
;
3114 int offset_size
, initial_length_size
;
3118 names
.pn_length
= byte_get (data
, 4);
3120 if (names
.pn_length
== 0xffffffff)
3122 names
.pn_length
= byte_get (data
, 8);
3125 initial_length_size
= 12;
3130 initial_length_size
= 4;
3133 names
.pn_version
= byte_get (data
, 2);
3136 names
.pn_offset
= byte_get (data
, offset_size
);
3137 data
+= offset_size
;
3139 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3140 && num_debug_info_entries
> 0
3141 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3142 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3143 names
.pn_offset
, section
->name
);
3145 names
.pn_size
= byte_get (data
, offset_size
);
3146 data
+= offset_size
;
3148 start
+= names
.pn_length
+ initial_length_size
;
3150 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3152 static int warned
= 0;
3156 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3163 printf (_(" Length: %ld\n"),
3165 printf (_(" Version: %d\n"),
3167 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3169 printf (_(" Size of area in .debug_info section: %ld\n"),
3172 printf (_("\n Offset\tName\n"));
3176 offset
= byte_get (data
, offset_size
);
3180 data
+= offset_size
;
3181 printf (" %-6lx\t%s\n", offset
, data
);
3182 data
+= strlen ((char *) data
) + 1;
3185 while (offset
!= 0);
3193 display_debug_macinfo (struct dwarf_section
*section
,
3194 void *file ATTRIBUTE_UNUSED
)
3196 unsigned char *start
= section
->start
;
3197 unsigned char *end
= start
+ section
->size
;
3198 unsigned char *curr
= start
;
3199 unsigned int bytes_read
;
3200 enum dwarf_macinfo_record_type op
;
3202 printf (_("Contents of the %s section:\n\n"), section
->name
);
3206 unsigned int lineno
;
3209 op
= (enum dwarf_macinfo_record_type
) *curr
;
3214 case DW_MACINFO_start_file
:
3216 unsigned int filenum
;
3218 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3220 filenum
= read_leb128 (curr
, & bytes_read
, 0);
3223 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3228 case DW_MACINFO_end_file
:
3229 printf (_(" DW_MACINFO_end_file\n"));
3232 case DW_MACINFO_define
:
3233 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3235 string
= (char *) curr
;
3236 curr
+= strlen (string
) + 1;
3237 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3241 case DW_MACINFO_undef
:
3242 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3244 string
= (char *) curr
;
3245 curr
+= strlen (string
) + 1;
3246 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3250 case DW_MACINFO_vendor_ext
:
3252 unsigned int constant
;
3254 constant
= read_leb128 (curr
, & bytes_read
, 0);
3256 string
= (char *) curr
;
3257 curr
+= strlen (string
) + 1;
3258 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3269 display_debug_abbrev (struct dwarf_section
*section
,
3270 void *file ATTRIBUTE_UNUSED
)
3272 abbrev_entry
*entry
;
3273 unsigned char *start
= section
->start
;
3274 unsigned char *end
= start
+ section
->size
;
3276 printf (_("Contents of the %s section:\n\n"), section
->name
);
3282 start
= process_abbrev_section (start
, end
);
3284 if (first_abbrev
== NULL
)
3287 printf (_(" Number TAG\n"));
3289 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
3293 printf (_(" %ld %s [%s]\n"),
3295 get_TAG_name (entry
->tag
),
3296 entry
->children
? _("has children") : _("no children"));
3298 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
3299 printf (_(" %-18s %s\n"),
3300 get_AT_name (attr
->attribute
),
3301 get_FORM_name (attr
->form
));
3312 display_debug_loc (struct dwarf_section
*section
, void *file
)
3314 unsigned char *start
= section
->start
;
3315 unsigned char *section_end
;
3316 unsigned long bytes
;
3317 unsigned char *section_begin
= start
;
3318 unsigned int num_loc_list
= 0;
3319 unsigned long last_offset
= 0;
3320 unsigned int first
= 0;
3323 int seen_first_offset
= 0;
3324 int use_debug_info
= 1;
3325 unsigned char *next
;
3327 bytes
= section
->size
;
3328 section_end
= start
+ bytes
;
3332 printf (_("\nThe %s section is empty.\n"), section
->name
);
3336 if (load_debug_info (file
) == 0)
3338 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3343 /* Check the order of location list in .debug_info section. If
3344 offsets of location lists are in the ascending order, we can
3345 use `debug_information' directly. */
3346 for (i
= 0; i
< num_debug_info_entries
; i
++)
3350 num
= debug_information
[i
].num_loc_offsets
;
3351 num_loc_list
+= num
;
3353 /* Check if we can use `debug_information' directly. */
3354 if (use_debug_info
&& num
!= 0)
3356 if (!seen_first_offset
)
3358 /* This is the first location list. */
3359 last_offset
= debug_information
[i
].loc_offsets
[0];
3361 seen_first_offset
= 1;
3367 for (; j
< num
; j
++)
3370 debug_information
[i
].loc_offsets
[j
])
3375 last_offset
= debug_information
[i
].loc_offsets
[j
];
3380 if (!use_debug_info
)
3381 /* FIXME: Should we handle this case? */
3382 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3384 if (!seen_first_offset
)
3385 error (_("No location lists in .debug_info section!\n"));
3387 /* DWARF sections under Mach-O have non-zero addresses. */
3388 if (debug_information
[first
].num_loc_offsets
> 0
3389 && debug_information
[first
].loc_offsets
[0] != section
->address
)
3390 warn (_("Location lists in %s section start at 0x%lx\n"),
3391 section
->name
, debug_information
[first
].loc_offsets
[0]);
3393 printf (_("Contents of the %s section:\n\n"), section
->name
);
3394 printf (_(" Offset Begin End Expression\n"));
3396 seen_first_offset
= 0;
3397 for (i
= first
; i
< num_debug_info_entries
; i
++)
3401 unsigned short length
;
3402 unsigned long offset
;
3403 unsigned int pointer_size
;
3404 unsigned long cu_offset
;
3405 unsigned long base_address
;
3406 int need_frame_base
;
3409 pointer_size
= debug_information
[i
].pointer_size
;
3410 cu_offset
= debug_information
[i
].cu_offset
;
3412 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
3414 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
3415 /* DWARF sections under Mach-O have non-zero addresses. */
3416 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
3417 next
= section_begin
+ offset
;
3418 base_address
= debug_information
[i
].base_address
;
3420 if (!seen_first_offset
)
3421 seen_first_offset
= 1;
3425 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3426 (unsigned long) (start
- section_begin
),
3427 (unsigned long) (next
- section_begin
));
3428 else if (start
> next
)
3429 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3430 (unsigned long) (start
- section_begin
),
3431 (unsigned long) (next
- section_begin
));
3435 if (offset
>= bytes
)
3437 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3444 if (start
+ 2 * pointer_size
> section_end
)
3446 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3451 /* Note: we use sign extension here in order to be sure that
3452 we can detect the -1 escape value. Sign extension into the
3453 top 32 bits of a 32-bit address will not affect the values
3454 that we display since we always show hex values, and always
3455 the bottom 32-bits. */
3456 begin
= byte_get_signed (start
, pointer_size
);
3457 start
+= pointer_size
;
3458 end
= byte_get_signed (start
, pointer_size
);
3459 start
+= pointer_size
;
3461 printf (" %8.8lx ", offset
);
3463 if (begin
== 0 && end
== 0)
3465 printf (_("<End of list>\n"));
3469 /* Check base address specifiers. */
3470 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3473 print_dwarf_vma (begin
, pointer_size
);
3474 print_dwarf_vma (end
, pointer_size
);
3475 printf (_("(base address)\n"));
3479 if (start
+ 2 > section_end
)
3481 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3486 length
= byte_get (start
, 2);
3489 if (start
+ length
> section_end
)
3491 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3496 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3497 print_dwarf_vma (end
+ base_address
, pointer_size
);
3500 need_frame_base
= decode_location_expression (start
,
3503 cu_offset
, section
);
3506 if (need_frame_base
&& !has_frame_base
)
3507 printf (_(" [without DW_AT_frame_base]"));
3510 fputs (_(" (start == end)"), stdout
);
3511 else if (begin
> end
)
3512 fputs (_(" (start > end)"), stdout
);
3521 if (start
< section_end
)
3522 warn (_("There are %ld unused bytes at the end of section %s\n"),
3523 (long) (section_end
- start
), section
->name
);
3529 display_debug_str (struct dwarf_section
*section
,
3530 void *file ATTRIBUTE_UNUSED
)
3532 unsigned char *start
= section
->start
;
3533 unsigned long bytes
= section
->size
;
3534 dwarf_vma addr
= section
->address
;
3538 printf (_("\nThe %s section is empty.\n"), section
->name
);
3542 printf (_("Contents of the %s section:\n\n"), section
->name
);
3550 lbytes
= (bytes
> 16 ? 16 : bytes
);
3552 printf (" 0x%8.8lx ", (unsigned long) addr
);
3554 for (j
= 0; j
< 16; j
++)
3557 printf ("%2.2x", start
[j
]);
3565 for (j
= 0; j
< lbytes
; j
++)
3568 if (k
>= ' ' && k
< 0x80)
3587 display_debug_info (struct dwarf_section
*section
, void *file
)
3589 return process_debug_info (section
, file
, abbrev
, 0, 0);
3593 display_debug_types (struct dwarf_section
*section
, void *file
)
3595 return process_debug_info (section
, file
, abbrev
, 0, 1);
3599 display_trace_info (struct dwarf_section
*section
, void *file
)
3601 return process_debug_info (section
, file
, trace_abbrev
, 0, 0);
3605 display_debug_aranges (struct dwarf_section
*section
,
3606 void *file ATTRIBUTE_UNUSED
)
3608 unsigned char *start
= section
->start
;
3609 unsigned char *end
= start
+ section
->size
;
3611 printf (_("Contents of the %s section:\n\n"), section
->name
);
3613 /* It does not matter if this load fails,
3614 we test for that later on. */
3615 load_debug_info (file
);
3619 unsigned char *hdrptr
;
3620 DWARF2_Internal_ARange arange
;
3621 unsigned char *addr_ranges
;
3624 unsigned char address_size
;
3627 int initial_length_size
;
3631 arange
.ar_length
= byte_get (hdrptr
, 4);
3634 if (arange
.ar_length
== 0xffffffff)
3636 arange
.ar_length
= byte_get (hdrptr
, 8);
3639 initial_length_size
= 12;
3644 initial_length_size
= 4;
3647 arange
.ar_version
= byte_get (hdrptr
, 2);
3650 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
3651 hdrptr
+= offset_size
;
3653 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3654 && num_debug_info_entries
> 0
3655 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
3656 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3657 arange
.ar_info_offset
, section
->name
);
3659 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
3662 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
3665 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
3667 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3671 printf (_(" Length: %ld\n"), arange
.ar_length
);
3672 printf (_(" Version: %d\n"), arange
.ar_version
);
3673 printf (_(" Offset into .debug_info: 0x%lx\n"), arange
.ar_info_offset
);
3674 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
3675 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
3677 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
3679 /* The DWARF spec does not require that the address size be a power
3680 of two, but we do. This will have to change if we ever encounter
3681 an uneven architecture. */
3682 if ((address_size
& (address_size
- 1)) != 0)
3684 warn (_("Pointer size + Segment size is not a power of two.\n"));
3688 if (address_size
> 4)
3689 printf (_("\n Address Length\n"));
3691 printf (_("\n Address Length\n"));
3693 addr_ranges
= hdrptr
;
3695 /* Must pad to an alignment boundary that is twice the address size. */
3696 excess
= (hdrptr
- start
) % (2 * address_size
);
3698 addr_ranges
+= (2 * address_size
) - excess
;
3700 start
+= arange
.ar_length
+ initial_length_size
;
3702 while (addr_ranges
+ 2 * address_size
<= start
)
3704 address
= byte_get (addr_ranges
, address_size
);
3706 addr_ranges
+= address_size
;
3708 length
= byte_get (addr_ranges
, address_size
);
3710 addr_ranges
+= address_size
;
3713 print_dwarf_vma (address
, address_size
);
3714 print_dwarf_vma (length
, address_size
);
3724 /* Each debug_information[x].range_lists[y] gets this representation for
3725 sorting purposes. */
3729 /* The debug_information[x].range_lists[y] value. */
3730 unsigned long ranges_offset
;
3732 /* Original debug_information to find parameters of the data. */
3733 debug_info
*debug_info_p
;
3736 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3739 range_entry_compar (const void *ap
, const void *bp
)
3741 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
3742 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
3743 const unsigned long a
= a_re
->ranges_offset
;
3744 const unsigned long b
= b_re
->ranges_offset
;
3746 return (a
> b
) - (b
> a
);
3750 display_debug_ranges (struct dwarf_section
*section
,
3751 void *file ATTRIBUTE_UNUSED
)
3753 unsigned char *start
= section
->start
;
3754 unsigned long bytes
;
3755 unsigned char *section_begin
= start
;
3756 unsigned int num_range_list
, i
;
3757 struct range_entry
*range_entries
, *range_entry_fill
;
3759 bytes
= section
->size
;
3763 printf (_("\nThe %s section is empty.\n"), section
->name
);
3767 if (load_debug_info (file
) == 0)
3769 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3775 for (i
= 0; i
< num_debug_info_entries
; i
++)
3776 num_range_list
+= debug_information
[i
].num_range_lists
;
3778 if (num_range_list
== 0)
3779 error (_("No range lists in .debug_info section!\n"));
3781 range_entries
= (struct range_entry
*)
3782 xmalloc (sizeof (*range_entries
) * num_range_list
);
3783 range_entry_fill
= range_entries
;
3785 for (i
= 0; i
< num_debug_info_entries
; i
++)
3787 debug_info
*debug_info_p
= &debug_information
[i
];
3790 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
3792 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
3793 range_entry_fill
->debug_info_p
= debug_info_p
;
3798 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
3799 range_entry_compar
);
3801 /* DWARF sections under Mach-O have non-zero addresses. */
3802 if (range_entries
[0].ranges_offset
!= section
->address
)
3803 warn (_("Range lists in %s section start at 0x%lx\n"),
3804 section
->name
, range_entries
[0].ranges_offset
);
3806 printf (_("Contents of the %s section:\n\n"), section
->name
);
3807 printf (_(" Offset Begin End\n"));
3809 for (i
= 0; i
< num_range_list
; i
++)
3811 struct range_entry
*range_entry
= &range_entries
[i
];
3812 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
3813 unsigned int pointer_size
;
3814 unsigned long offset
;
3815 unsigned char *next
;
3816 unsigned long base_address
;
3818 pointer_size
= debug_info_p
->pointer_size
;
3820 /* DWARF sections under Mach-O have non-zero addresses. */
3821 offset
= range_entry
->ranges_offset
- section
->address
;
3822 next
= section_begin
+ offset
;
3823 base_address
= debug_info_p
->base_address
;
3828 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3829 (unsigned long) (start
- section_begin
),
3830 (unsigned long) (next
- section_begin
), section
->name
);
3831 else if (start
> next
)
3832 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3833 (unsigned long) (start
- section_begin
),
3834 (unsigned long) (next
- section_begin
), section
->name
);
3843 /* Note: we use sign extension here in order to be sure that
3844 we can detect the -1 escape value. Sign extension into the
3845 top 32 bits of a 32-bit address will not affect the values
3846 that we display since we always show hex values, and always
3847 the bottom 32-bits. */
3848 begin
= byte_get_signed (start
, pointer_size
);
3849 start
+= pointer_size
;
3850 end
= byte_get_signed (start
, pointer_size
);
3851 start
+= pointer_size
;
3853 printf (" %8.8lx ", offset
);
3855 if (begin
== 0 && end
== 0)
3857 printf (_("<End of list>\n"));
3861 /* Check base address specifiers. */
3862 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3865 print_dwarf_vma (begin
, pointer_size
);
3866 print_dwarf_vma (end
, pointer_size
);
3867 printf ("(base address)\n");
3871 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3872 print_dwarf_vma (end
+ base_address
, pointer_size
);
3875 fputs (_("(start == end)"), stdout
);
3876 else if (begin
> end
)
3877 fputs (_("(start > end)"), stdout
);
3884 free (range_entries
);
3889 typedef struct Frame_Chunk
3891 struct Frame_Chunk
*next
;
3892 unsigned char *chunk_start
;
3894 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3895 short int *col_type
;
3898 unsigned int code_factor
;
3900 unsigned long pc_begin
;
3901 unsigned long pc_range
;
3905 unsigned char fde_encoding
;
3906 unsigned char cfa_exp
;
3907 unsigned char ptr_size
;
3908 unsigned char segment_size
;
3912 static const char *const *dwarf_regnames
;
3913 static unsigned int dwarf_regnames_count
;
3915 /* A marker for a col_type that means this column was never referenced
3916 in the frame info. */
3917 #define DW_CFA_unreferenced (-1)
3919 /* Return 0 if not more space is needed, 1 if more space is needed,
3920 -1 for invalid reg. */
3923 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
3925 int prev
= fc
->ncols
;
3927 if (reg
< (unsigned int) fc
->ncols
)
3930 if (dwarf_regnames_count
3931 && reg
> dwarf_regnames_count
)
3934 fc
->ncols
= reg
+ 1;
3935 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
3936 sizeof (short int));
3937 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
3939 while (prev
< fc
->ncols
)
3941 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
3942 fc
->col_offset
[prev
] = 0;
3948 static const char *const dwarf_regnames_i386
[] =
3950 "eax", "ecx", "edx", "ebx",
3951 "esp", "ebp", "esi", "edi",
3952 "eip", "eflags", NULL
,
3953 "st0", "st1", "st2", "st3",
3954 "st4", "st5", "st6", "st7",
3956 "xmm0", "xmm1", "xmm2", "xmm3",
3957 "xmm4", "xmm5", "xmm6", "xmm7",
3958 "mm0", "mm1", "mm2", "mm3",
3959 "mm4", "mm5", "mm6", "mm7",
3960 "fcw", "fsw", "mxcsr",
3961 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3965 static const char *const dwarf_regnames_x86_64
[] =
3967 "rax", "rdx", "rcx", "rbx",
3968 "rsi", "rdi", "rbp", "rsp",
3969 "r8", "r9", "r10", "r11",
3970 "r12", "r13", "r14", "r15",
3972 "xmm0", "xmm1", "xmm2", "xmm3",
3973 "xmm4", "xmm5", "xmm6", "xmm7",
3974 "xmm8", "xmm9", "xmm10", "xmm11",
3975 "xmm12", "xmm13", "xmm14", "xmm15",
3976 "st0", "st1", "st2", "st3",
3977 "st4", "st5", "st6", "st7",
3978 "mm0", "mm1", "mm2", "mm3",
3979 "mm4", "mm5", "mm6", "mm7",
3981 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3982 "fs.base", "gs.base", NULL
, NULL
,
3984 "mxcsr", "fcw", "fsw"
3988 init_dwarf_regnames (unsigned int e_machine
)
3994 dwarf_regnames
= dwarf_regnames_i386
;
3995 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
4000 dwarf_regnames
= dwarf_regnames_x86_64
;
4001 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
4010 regname (unsigned int regno
, int row
)
4012 static char reg
[64];
4014 && regno
< dwarf_regnames_count
4015 && dwarf_regnames
[regno
] != NULL
)
4018 return dwarf_regnames
[regno
];
4019 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
4020 dwarf_regnames
[regno
]);
4023 snprintf (reg
, sizeof (reg
), "r%d", regno
);
4028 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
4033 if (*max_regs
< fc
->ncols
)
4034 *max_regs
= fc
->ncols
;
4036 if (*need_col_headers
)
4038 static const char *sloc
= " LOC";
4040 *need_col_headers
= 0;
4042 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
4044 for (r
= 0; r
< *max_regs
; r
++)
4045 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
4050 printf ("%-5s ", regname (r
, 1));
4056 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
4058 strcpy (tmp
, "exp");
4060 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
4061 printf ("%-8s ", tmp
);
4063 for (r
= 0; r
< fc
->ncols
; r
++)
4065 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
4067 switch (fc
->col_type
[r
])
4069 case DW_CFA_undefined
:
4072 case DW_CFA_same_value
:
4076 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
4078 case DW_CFA_val_offset
:
4079 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
4081 case DW_CFA_register
:
4082 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
4084 case DW_CFA_expression
:
4085 strcpy (tmp
, "exp");
4087 case DW_CFA_val_expression
:
4088 strcpy (tmp
, "vexp");
4091 strcpy (tmp
, "n/a");
4094 printf ("%-5s ", tmp
);
4100 #define GET(N) byte_get (start, N); start += N
4101 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4102 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
4105 display_debug_frames (struct dwarf_section
*section
,
4106 void *file ATTRIBUTE_UNUSED
)
4108 unsigned char *start
= section
->start
;
4109 unsigned char *end
= start
+ section
->size
;
4110 unsigned char *section_start
= start
;
4111 Frame_Chunk
*chunks
= 0;
4112 Frame_Chunk
*remembered_state
= 0;
4114 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
4115 unsigned int length_return
;
4117 const char *bad_reg
= _("bad register: ");
4118 int saved_eh_addr_size
= eh_addr_size
;
4120 printf (_("Contents of the %s section:\n"), section
->name
);
4124 unsigned char *saved_start
;
4125 unsigned char *block_end
;
4126 unsigned long length
;
4127 unsigned long cie_id
;
4130 int need_col_headers
= 1;
4131 unsigned char *augmentation_data
= NULL
;
4132 unsigned long augmentation_data_len
= 0;
4133 int encoded_ptr_size
= saved_eh_addr_size
;
4135 int initial_length_size
;
4137 saved_start
= start
;
4138 length
= byte_get (start
, 4); start
+= 4;
4142 printf ("\n%08lx ZERO terminator\n\n",
4143 (unsigned long)(saved_start
- section_start
));
4147 if (length
== 0xffffffff)
4149 length
= byte_get (start
, 8);
4152 initial_length_size
= 12;
4157 initial_length_size
= 4;
4160 block_end
= saved_start
+ length
+ initial_length_size
;
4161 if (block_end
> end
)
4163 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4164 length
, (unsigned long)(saved_start
- section_start
));
4167 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
4169 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
4173 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4174 memset (fc
, 0, sizeof (Frame_Chunk
));
4178 fc
->chunk_start
= saved_start
;
4180 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4181 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4182 frame_need_space (fc
, max_regs
- 1);
4186 fc
->augmentation
= (char *) start
;
4187 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
4189 if (strcmp (fc
->augmentation
, "eh") == 0)
4190 start
+= eh_addr_size
;
4194 fc
->ptr_size
= GET (1);
4195 fc
->segment_size
= GET (1);
4196 eh_addr_size
= fc
->ptr_size
;
4200 fc
->ptr_size
= eh_addr_size
;
4201 fc
->segment_size
= 0;
4203 fc
->code_factor
= LEB ();
4204 fc
->data_factor
= SLEB ();
4214 if (fc
->augmentation
[0] == 'z')
4216 augmentation_data_len
= LEB ();
4217 augmentation_data
= start
;
4218 start
+= augmentation_data_len
;
4222 if (do_debug_frames_interp
)
4223 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4224 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4225 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
4229 printf ("\n%08lx %08lx %08lx CIE\n",
4230 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
4231 printf (" Version: %d\n", version
);
4232 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
4235 printf (" Pointer Size: %u\n", fc
->ptr_size
);
4236 printf (" Segment Size: %u\n", fc
->segment_size
);
4238 printf (" Code alignment factor: %u\n", fc
->code_factor
);
4239 printf (" Data alignment factor: %d\n", fc
->data_factor
);
4240 printf (" Return address column: %d\n", fc
->ra
);
4242 if (augmentation_data_len
)
4245 printf (" Augmentation data: ");
4246 for (i
= 0; i
< augmentation_data_len
; ++i
)
4247 printf (" %02x", augmentation_data
[i
]);
4253 if (augmentation_data_len
)
4255 unsigned char *p
, *q
;
4256 p
= (unsigned char *) fc
->augmentation
+ 1;
4257 q
= augmentation_data
;
4264 q
+= 1 + size_of_encoded_value (*q
);
4266 fc
->fde_encoding
= *q
++;
4274 if (fc
->fde_encoding
)
4275 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4278 frame_need_space (fc
, fc
->ra
);
4282 unsigned char *look_for
;
4283 static Frame_Chunk fde_fc
;
4284 unsigned long segment_selector
;
4287 memset (fc
, 0, sizeof (Frame_Chunk
));
4289 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
4291 for (cie
= chunks
; cie
; cie
= cie
->next
)
4292 if (cie
->chunk_start
== look_for
)
4297 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4298 cie_id
, (unsigned long)(saved_start
- section_start
));
4300 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4301 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4302 frame_need_space (fc
, max_regs
- 1);
4304 fc
->augmentation
= "";
4305 fc
->fde_encoding
= 0;
4306 fc
->ptr_size
= eh_addr_size
;
4307 fc
->segment_size
= 0;
4311 fc
->ncols
= cie
->ncols
;
4312 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
4313 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
4314 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
4315 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
4316 fc
->augmentation
= cie
->augmentation
;
4317 fc
->ptr_size
= cie
->ptr_size
;
4318 eh_addr_size
= cie
->ptr_size
;
4319 fc
->segment_size
= cie
->segment_size
;
4320 fc
->code_factor
= cie
->code_factor
;
4321 fc
->data_factor
= cie
->data_factor
;
4322 fc
->cfa_reg
= cie
->cfa_reg
;
4323 fc
->cfa_offset
= cie
->cfa_offset
;
4325 frame_need_space (fc
, max_regs
- 1);
4326 fc
->fde_encoding
= cie
->fde_encoding
;
4329 if (fc
->fde_encoding
)
4330 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4332 segment_selector
= 0;
4333 if (fc
->segment_size
)
4335 segment_selector
= byte_get (start
, fc
->segment_size
);
4336 start
+= fc
->segment_size
;
4338 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
4339 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4340 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
4341 start
+= encoded_ptr_size
;
4342 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
4343 start
+= encoded_ptr_size
;
4345 if (cie
->augmentation
[0] == 'z')
4347 augmentation_data_len
= LEB ();
4348 augmentation_data
= start
;
4349 start
+= augmentation_data_len
;
4352 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4353 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4354 (unsigned long)(cie
->chunk_start
- section_start
));
4355 if (fc
->segment_size
)
4356 printf ("%04lx:", segment_selector
);
4357 printf ("%08lx..%08lx\n", fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
4358 if (! do_debug_frames_interp
&& augmentation_data_len
)
4362 printf (" Augmentation data: ");
4363 for (i
= 0; i
< augmentation_data_len
; ++i
)
4364 printf (" %02x", augmentation_data
[i
]);
4370 /* At this point, fc is the current chunk, cie (if any) is set, and
4371 we're about to interpret instructions for the chunk. */
4372 /* ??? At present we need to do this always, since this sizes the
4373 fc->col_type and fc->col_offset arrays, which we write into always.
4374 We should probably split the interpreted and non-interpreted bits
4375 into two different routines, since there's so much that doesn't
4376 really overlap between them. */
4377 if (1 || do_debug_frames_interp
)
4379 /* Start by making a pass over the chunk, allocating storage
4380 and taking note of what registers are used. */
4381 unsigned char *tmp
= start
;
4383 while (start
< block_end
)
4386 unsigned long reg
, temp
;
4393 /* Warning: if you add any more cases to this switch, be
4394 sure to add them to the corresponding switch below. */
4397 case DW_CFA_advance_loc
:
4401 if (frame_need_space (fc
, opa
) >= 0)
4402 fc
->col_type
[opa
] = DW_CFA_undefined
;
4404 case DW_CFA_restore
:
4405 if (frame_need_space (fc
, opa
) >= 0)
4406 fc
->col_type
[opa
] = DW_CFA_undefined
;
4408 case DW_CFA_set_loc
:
4409 start
+= encoded_ptr_size
;
4411 case DW_CFA_advance_loc1
:
4414 case DW_CFA_advance_loc2
:
4417 case DW_CFA_advance_loc4
:
4420 case DW_CFA_offset_extended
:
4421 case DW_CFA_val_offset
:
4422 reg
= LEB (); LEB ();
4423 if (frame_need_space (fc
, reg
) >= 0)
4424 fc
->col_type
[reg
] = DW_CFA_undefined
;
4426 case DW_CFA_restore_extended
:
4428 frame_need_space (fc
, reg
);
4429 if (frame_need_space (fc
, reg
) >= 0)
4430 fc
->col_type
[reg
] = DW_CFA_undefined
;
4432 case DW_CFA_undefined
:
4434 if (frame_need_space (fc
, reg
) >= 0)
4435 fc
->col_type
[reg
] = DW_CFA_undefined
;
4437 case DW_CFA_same_value
:
4439 if (frame_need_space (fc
, reg
) >= 0)
4440 fc
->col_type
[reg
] = DW_CFA_undefined
;
4442 case DW_CFA_register
:
4443 reg
= LEB (); LEB ();
4444 if (frame_need_space (fc
, reg
) >= 0)
4445 fc
->col_type
[reg
] = DW_CFA_undefined
;
4447 case DW_CFA_def_cfa
:
4450 case DW_CFA_def_cfa_register
:
4453 case DW_CFA_def_cfa_offset
:
4456 case DW_CFA_def_cfa_expression
:
4460 case DW_CFA_expression
:
4461 case DW_CFA_val_expression
:
4465 if (frame_need_space (fc
, reg
) >= 0)
4466 fc
->col_type
[reg
] = DW_CFA_undefined
;
4468 case DW_CFA_offset_extended_sf
:
4469 case DW_CFA_val_offset_sf
:
4470 reg
= LEB (); SLEB ();
4471 if (frame_need_space (fc
, reg
) >= 0)
4472 fc
->col_type
[reg
] = DW_CFA_undefined
;
4474 case DW_CFA_def_cfa_sf
:
4477 case DW_CFA_def_cfa_offset_sf
:
4480 case DW_CFA_MIPS_advance_loc8
:
4483 case DW_CFA_GNU_args_size
:
4486 case DW_CFA_GNU_negative_offset_extended
:
4487 reg
= LEB (); LEB ();
4488 if (frame_need_space (fc
, reg
) >= 0)
4489 fc
->col_type
[reg
] = DW_CFA_undefined
;
4498 /* Now we know what registers are used, make a second pass over
4499 the chunk, this time actually printing out the info. */
4501 while (start
< block_end
)
4504 unsigned long ul
, reg
, roffs
;
4507 const char *reg_prefix
= "";
4514 /* Warning: if you add any more cases to this switch, be
4515 sure to add them to the corresponding switch above. */
4518 case DW_CFA_advance_loc
:
4519 if (do_debug_frames_interp
)
4520 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4522 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4523 opa
* fc
->code_factor
,
4524 fc
->pc_begin
+ opa
* fc
->code_factor
);
4525 fc
->pc_begin
+= opa
* fc
->code_factor
;
4530 if (opa
>= (unsigned int) fc
->ncols
)
4531 reg_prefix
= bad_reg
;
4532 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4533 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4534 reg_prefix
, regname (opa
, 0),
4535 roffs
* fc
->data_factor
);
4536 if (*reg_prefix
== '\0')
4538 fc
->col_type
[opa
] = DW_CFA_offset
;
4539 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
4543 case DW_CFA_restore
:
4544 if (opa
>= (unsigned int) cie
->ncols
4545 || opa
>= (unsigned int) fc
->ncols
)
4546 reg_prefix
= bad_reg
;
4547 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4548 printf (" DW_CFA_restore: %s%s\n",
4549 reg_prefix
, regname (opa
, 0));
4550 if (*reg_prefix
== '\0')
4552 fc
->col_type
[opa
] = cie
->col_type
[opa
];
4553 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
4557 case DW_CFA_set_loc
:
4558 vma
= get_encoded_value (start
, fc
->fde_encoding
);
4559 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4560 vma
+= section
->address
+ (start
- section_start
);
4561 start
+= encoded_ptr_size
;
4562 if (do_debug_frames_interp
)
4563 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4565 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
4569 case DW_CFA_advance_loc1
:
4570 ofs
= byte_get (start
, 1); start
+= 1;
4571 if (do_debug_frames_interp
)
4572 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4574 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4575 ofs
* fc
->code_factor
,
4576 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4577 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4580 case DW_CFA_advance_loc2
:
4581 ofs
= byte_get (start
, 2); start
+= 2;
4582 if (do_debug_frames_interp
)
4583 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4585 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4586 ofs
* fc
->code_factor
,
4587 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4588 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4591 case DW_CFA_advance_loc4
:
4592 ofs
= byte_get (start
, 4); start
+= 4;
4593 if (do_debug_frames_interp
)
4594 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4596 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4597 ofs
* fc
->code_factor
,
4598 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4599 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4602 case DW_CFA_offset_extended
:
4605 if (reg
>= (unsigned int) fc
->ncols
)
4606 reg_prefix
= bad_reg
;
4607 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4608 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4609 reg_prefix
, regname (reg
, 0),
4610 roffs
* fc
->data_factor
);
4611 if (*reg_prefix
== '\0')
4613 fc
->col_type
[reg
] = DW_CFA_offset
;
4614 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4618 case DW_CFA_val_offset
:
4621 if (reg
>= (unsigned int) fc
->ncols
)
4622 reg_prefix
= bad_reg
;
4623 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4624 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4625 reg_prefix
, regname (reg
, 0),
4626 roffs
* fc
->data_factor
);
4627 if (*reg_prefix
== '\0')
4629 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4630 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4634 case DW_CFA_restore_extended
:
4636 if (reg
>= (unsigned int) cie
->ncols
4637 || reg
>= (unsigned int) fc
->ncols
)
4638 reg_prefix
= bad_reg
;
4639 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4640 printf (" DW_CFA_restore_extended: %s%s\n",
4641 reg_prefix
, regname (reg
, 0));
4642 if (*reg_prefix
== '\0')
4644 fc
->col_type
[reg
] = cie
->col_type
[reg
];
4645 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
4649 case DW_CFA_undefined
:
4651 if (reg
>= (unsigned int) fc
->ncols
)
4652 reg_prefix
= bad_reg
;
4653 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4654 printf (" DW_CFA_undefined: %s%s\n",
4655 reg_prefix
, regname (reg
, 0));
4656 if (*reg_prefix
== '\0')
4658 fc
->col_type
[reg
] = DW_CFA_undefined
;
4659 fc
->col_offset
[reg
] = 0;
4663 case DW_CFA_same_value
:
4665 if (reg
>= (unsigned int) fc
->ncols
)
4666 reg_prefix
= bad_reg
;
4667 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4668 printf (" DW_CFA_same_value: %s%s\n",
4669 reg_prefix
, regname (reg
, 0));
4670 if (*reg_prefix
== '\0')
4672 fc
->col_type
[reg
] = DW_CFA_same_value
;
4673 fc
->col_offset
[reg
] = 0;
4677 case DW_CFA_register
:
4680 if (reg
>= (unsigned int) fc
->ncols
)
4681 reg_prefix
= bad_reg
;
4682 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4684 printf (" DW_CFA_register: %s%s in ",
4685 reg_prefix
, regname (reg
, 0));
4686 puts (regname (roffs
, 0));
4688 if (*reg_prefix
== '\0')
4690 fc
->col_type
[reg
] = DW_CFA_register
;
4691 fc
->col_offset
[reg
] = roffs
;
4695 case DW_CFA_remember_state
:
4696 if (! do_debug_frames_interp
)
4697 printf (" DW_CFA_remember_state\n");
4698 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4699 rs
->ncols
= fc
->ncols
;
4700 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
4701 sizeof (short int));
4702 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
4703 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
4704 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
4705 rs
->next
= remembered_state
;
4706 remembered_state
= rs
;
4709 case DW_CFA_restore_state
:
4710 if (! do_debug_frames_interp
)
4711 printf (" DW_CFA_restore_state\n");
4712 rs
= remembered_state
;
4715 remembered_state
= rs
->next
;
4716 frame_need_space (fc
, rs
->ncols
- 1);
4717 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
4718 memcpy (fc
->col_offset
, rs
->col_offset
,
4719 rs
->ncols
* sizeof (int));
4720 free (rs
->col_type
);
4721 free (rs
->col_offset
);
4724 else if (do_debug_frames_interp
)
4725 printf ("Mismatched DW_CFA_restore_state\n");
4728 case DW_CFA_def_cfa
:
4729 fc
->cfa_reg
= LEB ();
4730 fc
->cfa_offset
= LEB ();
4732 if (! do_debug_frames_interp
)
4733 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4734 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4737 case DW_CFA_def_cfa_register
:
4738 fc
->cfa_reg
= LEB ();
4740 if (! do_debug_frames_interp
)
4741 printf (" DW_CFA_def_cfa_register: %s\n",
4742 regname (fc
->cfa_reg
, 0));
4745 case DW_CFA_def_cfa_offset
:
4746 fc
->cfa_offset
= LEB ();
4747 if (! do_debug_frames_interp
)
4748 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
4752 if (! do_debug_frames_interp
)
4753 printf (" DW_CFA_nop\n");
4756 case DW_CFA_def_cfa_expression
:
4758 if (! do_debug_frames_interp
)
4760 printf (" DW_CFA_def_cfa_expression (");
4761 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4769 case DW_CFA_expression
:
4772 if (reg
>= (unsigned int) fc
->ncols
)
4773 reg_prefix
= bad_reg
;
4774 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4776 printf (" DW_CFA_expression: %s%s (",
4777 reg_prefix
, regname (reg
, 0));
4778 decode_location_expression (start
, eh_addr_size
,
4782 if (*reg_prefix
== '\0')
4783 fc
->col_type
[reg
] = DW_CFA_expression
;
4787 case DW_CFA_val_expression
:
4790 if (reg
>= (unsigned int) fc
->ncols
)
4791 reg_prefix
= bad_reg
;
4792 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4794 printf (" DW_CFA_val_expression: %s%s (",
4795 reg_prefix
, regname (reg
, 0));
4796 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4800 if (*reg_prefix
== '\0')
4801 fc
->col_type
[reg
] = DW_CFA_val_expression
;
4805 case DW_CFA_offset_extended_sf
:
4808 if (frame_need_space (fc
, reg
) < 0)
4809 reg_prefix
= bad_reg
;
4810 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4811 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4812 reg_prefix
, regname (reg
, 0),
4813 l
* fc
->data_factor
);
4814 if (*reg_prefix
== '\0')
4816 fc
->col_type
[reg
] = DW_CFA_offset
;
4817 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4821 case DW_CFA_val_offset_sf
:
4824 if (frame_need_space (fc
, reg
) < 0)
4825 reg_prefix
= bad_reg
;
4826 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4827 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4828 reg_prefix
, regname (reg
, 0),
4829 l
* fc
->data_factor
);
4830 if (*reg_prefix
== '\0')
4832 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4833 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4837 case DW_CFA_def_cfa_sf
:
4838 fc
->cfa_reg
= LEB ();
4839 fc
->cfa_offset
= SLEB ();
4840 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4842 if (! do_debug_frames_interp
)
4843 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4844 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4847 case DW_CFA_def_cfa_offset_sf
:
4848 fc
->cfa_offset
= SLEB ();
4849 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4850 if (! do_debug_frames_interp
)
4851 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
4854 case DW_CFA_MIPS_advance_loc8
:
4855 ofs
= byte_get (start
, 8); start
+= 8;
4856 if (do_debug_frames_interp
)
4857 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4859 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4860 ofs
* fc
->code_factor
,
4861 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4862 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4865 case DW_CFA_GNU_window_save
:
4866 if (! do_debug_frames_interp
)
4867 printf (" DW_CFA_GNU_window_save\n");
4870 case DW_CFA_GNU_args_size
:
4872 if (! do_debug_frames_interp
)
4873 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
4876 case DW_CFA_GNU_negative_offset_extended
:
4879 if (frame_need_space (fc
, reg
) < 0)
4880 reg_prefix
= bad_reg
;
4881 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4882 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4883 reg_prefix
, regname (reg
, 0),
4884 l
* fc
->data_factor
);
4885 if (*reg_prefix
== '\0')
4887 fc
->col_type
[reg
] = DW_CFA_offset
;
4888 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4893 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
4894 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
4896 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
4901 if (do_debug_frames_interp
)
4902 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4905 eh_addr_size
= saved_eh_addr_size
;
4918 display_debug_not_supported (struct dwarf_section
*section
,
4919 void *file ATTRIBUTE_UNUSED
)
4921 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4928 cmalloc (size_t nmemb
, size_t size
)
4930 /* Check for overflow. */
4931 if (nmemb
>= ~(size_t) 0 / size
)
4934 return malloc (nmemb
* size
);
4938 xcmalloc (size_t nmemb
, size_t size
)
4940 /* Check for overflow. */
4941 if (nmemb
>= ~(size_t) 0 / size
)
4944 return xmalloc (nmemb
* size
);
4948 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
4950 /* Check for overflow. */
4951 if (nmemb
>= ~(size_t) 0 / size
)
4954 return xrealloc (ptr
, nmemb
* size
);
4958 error (const char *message
, ...)
4962 va_start (args
, message
);
4963 fprintf (stderr
, _("%s: Error: "), program_name
);
4964 vfprintf (stderr
, message
, args
);
4969 warn (const char *message
, ...)
4973 va_start (args
, message
);
4974 fprintf (stderr
, _("%s: Warning: "), program_name
);
4975 vfprintf (stderr
, message
, args
);
4980 free_debug_memory (void)
4986 for (i
= 0; i
< max
; i
++)
4987 free_debug_section ((enum dwarf_section_display_enum
) i
);
4989 if (debug_information
!= NULL
)
4991 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
4993 for (i
= 0; i
< num_debug_info_entries
; i
++)
4995 if (!debug_information
[i
].max_loc_offsets
)
4997 free (debug_information
[i
].loc_offsets
);
4998 free (debug_information
[i
].have_frame_base
);
5000 if (!debug_information
[i
].max_range_lists
)
5001 free (debug_information
[i
].range_lists
);
5005 free (debug_information
);
5006 debug_information
= NULL
;
5007 num_debug_info_entries
= 0;
5012 dwarf_select_sections_by_names (const char *names
)
5016 const char * option
;
5020 debug_dump_long_opts
;
5022 static const debug_dump_long_opts opts_table
[] =
5024 /* Please keep this table alpha- sorted. */
5025 { "Ranges", & do_debug_ranges
, 1 },
5026 { "abbrev", & do_debug_abbrevs
, 1 },
5027 { "aranges", & do_debug_aranges
, 1 },
5028 { "frames", & do_debug_frames
, 1 },
5029 { "frames-interp", & do_debug_frames_interp
, 1 },
5030 { "info", & do_debug_info
, 1 },
5031 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
5032 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
5033 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
5034 { "loc", & do_debug_loc
, 1 },
5035 { "macro", & do_debug_macinfo
, 1 },
5036 { "pubnames", & do_debug_pubnames
, 1 },
5037 { "pubtypes", & do_debug_pubtypes
, 1 },
5038 /* This entry is for compatability
5039 with earlier versions of readelf. */
5040 { "ranges", & do_debug_aranges
, 1 },
5041 { "str", & do_debug_str
, 1 },
5042 /* These trace_* sections are used by Itanium VMS. */
5043 { "trace_abbrev", & do_trace_abbrevs
, 1 },
5044 { "trace_aranges", & do_trace_aranges
, 1 },
5045 { "trace_info", & do_trace_info
, 1 },
5054 const debug_dump_long_opts
* entry
;
5056 for (entry
= opts_table
; entry
->option
; entry
++)
5058 size_t len
= strlen (entry
->option
);
5060 if (strncmp (p
, entry
->option
, len
) == 0
5061 && (p
[len
] == ',' || p
[len
] == '\0'))
5063 * entry
->variable
|= entry
->val
;
5065 /* The --debug-dump=frames-interp option also
5066 enables the --debug-dump=frames option. */
5067 if (do_debug_frames_interp
)
5068 do_debug_frames
= 1;
5075 if (entry
->option
== NULL
)
5077 warn (_("Unrecognized debug option '%s'\n"), p
);
5078 p
= strchr (p
, ',');
5089 dwarf_select_sections_by_letters (const char *letters
)
5091 unsigned int lindex
= 0;
5093 while (letters
[lindex
])
5094 switch (letters
[lindex
++])
5101 do_debug_abbrevs
= 1;
5105 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5109 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
5113 do_debug_pubnames
= 1;
5117 do_debug_pubtypes
= 1;
5121 do_debug_aranges
= 1;
5125 do_debug_ranges
= 1;
5129 do_debug_frames_interp
= 1;
5131 do_debug_frames
= 1;
5135 do_debug_macinfo
= 1;
5147 warn (_("Unrecognized debug option '%s'\n"), optarg
);
5153 dwarf_select_sections_all (void)
5156 do_debug_abbrevs
= 1;
5157 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
5158 do_debug_pubnames
= 1;
5159 do_debug_pubtypes
= 1;
5160 do_debug_aranges
= 1;
5161 do_debug_ranges
= 1;
5162 do_debug_frames
= 1;
5163 do_debug_macinfo
= 1;
5167 do_trace_abbrevs
= 1;
5168 do_trace_aranges
= 1;
5171 struct dwarf_section_display debug_displays
[] =
5173 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0 },
5174 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
5175 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0 },
5176 display_debug_aranges
, &do_debug_aranges
, 1 },
5177 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0 },
5178 display_debug_frames
, &do_debug_frames
, 1 },
5179 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0 },
5180 display_debug_info
, &do_debug_info
, 1 },
5181 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0 },
5182 display_debug_lines
, &do_debug_lines
, 1 },
5183 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0 },
5184 display_debug_pubnames
, &do_debug_pubnames
, 0 },
5185 { { ".eh_frame", "", NULL
, NULL
, 0, 0 },
5186 display_debug_frames
, &do_debug_frames
, 1 },
5187 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0 },
5188 display_debug_macinfo
, &do_debug_macinfo
, 0 },
5189 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0 },
5190 display_debug_str
, &do_debug_str
, 0 },
5191 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0 },
5192 display_debug_loc
, &do_debug_loc
, 1 },
5193 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0 },
5194 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
5195 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0 },
5196 display_debug_ranges
, &do_debug_ranges
, 1 },
5197 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0 },
5198 display_debug_not_supported
, NULL
, 0 },
5199 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0 },
5200 display_debug_not_supported
, NULL
, 0 },
5201 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0 },
5202 display_debug_types
, &do_debug_info
, 1 },
5203 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0 },
5204 display_debug_not_supported
, NULL
, 0 },
5205 { { ".trace_info", "", NULL
, NULL
, 0, 0 },
5206 display_trace_info
, &do_trace_info
, 1 },
5207 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0 },
5208 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
5209 { { ".trace_aranges", "", NULL
, NULL
, 0, 0 },
5210 display_debug_aranges
, &do_trace_aranges
, 0 }