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