1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/common.h"
30 static int have_frame_base
;
31 static int need_base_address
;
33 static unsigned int last_pointer_size
= 0;
34 static int warned_about_missing_comp_units
= FALSE
;
36 static unsigned int num_debug_info_entries
= 0;
37 static debug_info
*debug_information
= NULL
;
38 /* Special value for num_debug_info_entries to indicate
39 that the .debug_info section could not be loaded/parsed. */
40 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
47 int do_debug_pubnames
;
48 int do_debug_pubtypes
;
52 int do_debug_frames_interp
;
58 /* Values for do_debug_lines. */
59 #define FLAG_DEBUG_LINES_RAW 1
60 #define FLAG_DEBUG_LINES_DECODED 2
62 dwarf_vma (*byte_get
) (unsigned char *, int);
65 byte_get_little_endian (unsigned char *field
, int size
)
73 return ((unsigned int) (field
[0]))
74 | (((unsigned int) (field
[1])) << 8);
77 return ((unsigned long) (field
[0]))
78 | (((unsigned long) (field
[1])) << 8)
79 | (((unsigned long) (field
[2])) << 16);
82 return ((unsigned long) (field
[0]))
83 | (((unsigned long) (field
[1])) << 8)
84 | (((unsigned long) (field
[2])) << 16)
85 | (((unsigned long) (field
[3])) << 24);
88 if (sizeof (dwarf_vma
) == 8)
89 return ((dwarf_vma
) (field
[0]))
90 | (((dwarf_vma
) (field
[1])) << 8)
91 | (((dwarf_vma
) (field
[2])) << 16)
92 | (((dwarf_vma
) (field
[3])) << 24)
93 | (((dwarf_vma
) (field
[4])) << 32)
94 | (((dwarf_vma
) (field
[5])) << 40)
95 | (((dwarf_vma
) (field
[6])) << 48)
96 | (((dwarf_vma
) (field
[7])) << 56);
97 else if (sizeof (dwarf_vma
) == 4)
98 /* We want to extract data from an 8 byte wide field and
99 place it into a 4 byte wide field. Since this is a little
100 endian source we can just use the 4 byte extraction code. */
101 return ((unsigned long) (field
[0]))
102 | (((unsigned long) (field
[1])) << 8)
103 | (((unsigned long) (field
[2])) << 16)
104 | (((unsigned long) (field
[3])) << 24);
107 error (_("Unhandled data length: %d\n"), size
);
113 byte_get_big_endian (unsigned char *field
, int size
)
121 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
124 return ((unsigned long) (field
[2]))
125 | (((unsigned long) (field
[1])) << 8)
126 | (((unsigned long) (field
[0])) << 16);
129 return ((unsigned long) (field
[3]))
130 | (((unsigned long) (field
[2])) << 8)
131 | (((unsigned long) (field
[1])) << 16)
132 | (((unsigned long) (field
[0])) << 24);
135 if (sizeof (dwarf_vma
) == 8)
136 return ((dwarf_vma
) (field
[7]))
137 | (((dwarf_vma
) (field
[6])) << 8)
138 | (((dwarf_vma
) (field
[5])) << 16)
139 | (((dwarf_vma
) (field
[4])) << 24)
140 | (((dwarf_vma
) (field
[3])) << 32)
141 | (((dwarf_vma
) (field
[2])) << 40)
142 | (((dwarf_vma
) (field
[1])) << 48)
143 | (((dwarf_vma
) (field
[0])) << 56);
144 else if (sizeof (dwarf_vma
) == 4)
146 /* Although we are extracing data from an 8 byte wide field,
147 we are returning only 4 bytes of data. */
149 return ((unsigned long) (field
[3]))
150 | (((unsigned long) (field
[2])) << 8)
151 | (((unsigned long) (field
[1])) << 16)
152 | (((unsigned long) (field
[0])) << 24);
156 error (_("Unhandled data length: %d\n"), size
);
162 byte_get_signed (unsigned char *field
, int size
)
164 dwarf_vma x
= byte_get (field
, size
);
169 return (x
^ 0x80) - 0x80;
171 return (x
^ 0x8000) - 0x8000;
173 return (x
^ 0x80000000) - 0x80000000;
182 size_of_encoded_value (int encoding
)
184 switch (encoding
& 0x7)
187 case 0: return eh_addr_size
;
195 get_encoded_value (unsigned char *data
, int encoding
)
197 int size
= size_of_encoded_value (encoding
);
199 if (encoding
& DW_EH_PE_signed
)
200 return byte_get_signed (data
, size
);
202 return byte_get (data
, size
);
205 /* Print a dwarf_vma value (typically an address, offset or length) in
206 hexadecimal format, followed by a space. The length of the value (and
207 hence the precision displayed) is determined by the byte_size parameter. */
210 print_dwarf_vma (dwarf_vma val
, unsigned byte_size
)
212 static char buff
[18];
214 /* Printf does not have a way of specifiying a maximum field width for an
215 integer value, so we print the full value into a buffer and then select
216 the precision we need. */
217 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
219 snprintf (buff
, sizeof (buff
), "%16.16llx ", val
);
221 snprintf (buff
, sizeof (buff
), "%016I64x ", val
);
224 snprintf (buff
, sizeof (buff
), "%16.16lx ", val
);
227 fputs (buff
+ (byte_size
== 4 ? 8 : 0), stdout
);
230 static unsigned long int
231 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
233 unsigned long int result
= 0;
234 unsigned int num_read
= 0;
235 unsigned int shift
= 0;
243 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
250 if (length_return
!= NULL
)
251 *length_return
= num_read
;
253 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
254 result
|= -1L << shift
;
259 typedef struct State_Machine_Registers
261 unsigned long address
;
268 /* This variable hold the number of the last entry seen
269 in the File Table. */
270 unsigned int last_file_entry
;
273 static SMR state_machine_regs
;
276 reset_state_machine (int is_stmt
)
278 state_machine_regs
.address
= 0;
279 state_machine_regs
.file
= 1;
280 state_machine_regs
.line
= 1;
281 state_machine_regs
.column
= 0;
282 state_machine_regs
.is_stmt
= is_stmt
;
283 state_machine_regs
.basic_block
= 0;
284 state_machine_regs
.end_sequence
= 0;
285 state_machine_regs
.last_file_entry
= 0;
288 /* Handled an extend line op.
289 Returns the number of bytes read. */
292 process_extended_line_op (unsigned char *data
, int is_stmt
)
294 unsigned char op_code
;
295 unsigned int bytes_read
;
300 len
= read_leb128 (data
, & bytes_read
, 0);
305 warn (_("badly formed extended line op encountered!\n"));
312 printf (_(" Extended opcode %d: "), op_code
);
316 case DW_LNE_end_sequence
:
317 printf (_("End of Sequence\n\n"));
318 reset_state_machine (is_stmt
);
321 case DW_LNE_set_address
:
322 adr
= byte_get (data
, len
- bytes_read
- 1);
323 printf (_("set Address to 0x%lx\n"), adr
);
324 state_machine_regs
.address
= adr
;
327 case DW_LNE_define_file
:
328 printf (_(" define new File Table entry\n"));
329 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
331 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
333 data
+= strlen ((char *) data
) + 1;
334 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
336 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
338 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
339 printf (_("%s\n\n"), name
);
342 case DW_LNE_set_discriminator
:
343 printf (_("set Discriminator to %lu\n"),
344 read_leb128 (data
, & bytes_read
, 0));
348 case DW_LNE_HP_negate_is_UV_update
:
349 printf ("DW_LNE_HP_negate_is_UV_update\n");
351 case DW_LNE_HP_push_context
:
352 printf ("DW_LNE_HP_push_context\n");
354 case DW_LNE_HP_pop_context
:
355 printf ("DW_LNE_HP_pop_context\n");
357 case DW_LNE_HP_set_file_line_column
:
358 printf ("DW_LNE_HP_set_file_line_column\n");
360 case DW_LNE_HP_set_routine_name
:
361 printf ("DW_LNE_HP_set_routine_name\n");
363 case DW_LNE_HP_set_sequence
:
364 printf ("DW_LNE_HP_set_sequence\n");
366 case DW_LNE_HP_negate_post_semantics
:
367 printf ("DW_LNE_HP_negate_post_semantics\n");
369 case DW_LNE_HP_negate_function_exit
:
370 printf ("DW_LNE_HP_negate_function_exit\n");
372 case DW_LNE_HP_negate_front_end_logical
:
373 printf ("DW_LNE_HP_negate_front_end_logical\n");
375 case DW_LNE_HP_define_proc
:
376 printf ("DW_LNE_HP_define_proc\n");
380 if (op_code
>= DW_LNE_lo_user
381 /* The test against DW_LNW_hi_user is redundant due to
382 the limited range of the unsigned char data type used
384 /*&& op_code <= DW_LNE_hi_user*/)
385 printf (_("user defined: length %d\n"), len
- bytes_read
);
387 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
395 fetch_indirect_string (unsigned long offset
)
397 struct dwarf_section
*section
= &debug_displays
[str
].section
;
399 if (section
->start
== NULL
)
400 return _("<no .debug_str section>");
402 /* DWARF sections under Mach-O have non-zero addresses. */
403 offset
-= section
->address
;
404 if (offset
> section
->size
)
406 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
407 return _("<offset is too big>");
410 return (const char *) section
->start
+ offset
;
413 /* FIXME: There are better and more efficient ways to handle
414 these structures. For now though, I just want something that
415 is simple to implement. */
416 typedef struct abbrev_attr
418 unsigned long attribute
;
420 struct abbrev_attr
*next
;
424 typedef struct abbrev_entry
429 struct abbrev_attr
*first_attr
;
430 struct abbrev_attr
*last_attr
;
431 struct abbrev_entry
*next
;
435 static abbrev_entry
*first_abbrev
= NULL
;
436 static abbrev_entry
*last_abbrev
= NULL
;
443 for (abbrv
= first_abbrev
; abbrv
;)
445 abbrev_entry
*next_abbrev
= abbrv
->next
;
448 for (attr
= abbrv
->first_attr
; attr
;)
450 abbrev_attr
*next_attr
= attr
->next
;
460 last_abbrev
= first_abbrev
= NULL
;
464 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
468 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
474 entry
->entry
= number
;
476 entry
->children
= children
;
477 entry
->first_attr
= NULL
;
478 entry
->last_attr
= NULL
;
481 if (first_abbrev
== NULL
)
482 first_abbrev
= entry
;
484 last_abbrev
->next
= entry
;
490 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
494 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
500 attr
->attribute
= attribute
;
504 if (last_abbrev
->first_attr
== NULL
)
505 last_abbrev
->first_attr
= attr
;
507 last_abbrev
->last_attr
->next
= attr
;
509 last_abbrev
->last_attr
= attr
;
512 /* Processes the (partial) contents of a .debug_abbrev section.
513 Returns NULL if the end of the section was encountered.
514 Returns the address after the last byte read if the end of
515 an abbreviation set was found. */
517 static unsigned char *
518 process_abbrev_section (unsigned char *start
, unsigned char *end
)
520 if (first_abbrev
!= NULL
)
525 unsigned int bytes_read
;
528 unsigned long attribute
;
531 entry
= read_leb128 (start
, & bytes_read
, 0);
534 /* A single zero is supposed to end the section according
535 to the standard. If there's more, then signal that to
538 return start
== end
? NULL
: start
;
540 tag
= read_leb128 (start
, & bytes_read
, 0);
545 add_abbrev (entry
, tag
, children
);
551 attribute
= read_leb128 (start
, & bytes_read
, 0);
554 form
= read_leb128 (start
, & bytes_read
, 0);
558 add_abbrev_attr (attribute
, form
);
560 while (attribute
!= 0);
567 get_TAG_name (unsigned long tag
)
571 case DW_TAG_padding
: return "DW_TAG_padding";
572 case DW_TAG_array_type
: return "DW_TAG_array_type";
573 case DW_TAG_class_type
: return "DW_TAG_class_type";
574 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
575 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
576 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
577 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
578 case DW_TAG_label
: return "DW_TAG_label";
579 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
580 case DW_TAG_member
: return "DW_TAG_member";
581 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
582 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
583 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
584 case DW_TAG_string_type
: return "DW_TAG_string_type";
585 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
586 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
587 case DW_TAG_typedef
: return "DW_TAG_typedef";
588 case DW_TAG_union_type
: return "DW_TAG_union_type";
589 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
590 case DW_TAG_variant
: return "DW_TAG_variant";
591 case DW_TAG_common_block
: return "DW_TAG_common_block";
592 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
593 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
594 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
595 case DW_TAG_module
: return "DW_TAG_module";
596 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
597 case DW_TAG_set_type
: return "DW_TAG_set_type";
598 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
599 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
600 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
601 case DW_TAG_base_type
: return "DW_TAG_base_type";
602 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
603 case DW_TAG_const_type
: return "DW_TAG_const_type";
604 case DW_TAG_constant
: return "DW_TAG_constant";
605 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
606 case DW_TAG_file_type
: return "DW_TAG_file_type";
607 case DW_TAG_friend
: return "DW_TAG_friend";
608 case DW_TAG_namelist
: return "DW_TAG_namelist";
609 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
610 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
611 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
612 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
613 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
614 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
615 case DW_TAG_try_block
: return "DW_TAG_try_block";
616 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
617 case DW_TAG_variable
: return "DW_TAG_variable";
618 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
619 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
620 case DW_TAG_format_label
: return "DW_TAG_format_label";
621 case DW_TAG_function_template
: return "DW_TAG_function_template";
622 case DW_TAG_class_template
: return "DW_TAG_class_template";
623 /* DWARF 2.1 values. */
624 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
625 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
626 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
627 case DW_TAG_namespace
: return "DW_TAG_namespace";
628 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
629 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
630 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
631 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
632 case DW_TAG_condition
: return "DW_TAG_condition";
633 case DW_TAG_shared_type
: return "DW_TAG_shared_type";
634 /* DWARF 4 values. */
635 case DW_TAG_type_unit
: return "DW_TAG_type_unit";
636 case DW_TAG_rvalue_reference_type
: return "DW_TAG_rvalue_reference_type";
637 case DW_TAG_template_alias
: return "DW_TAG_template_alias";
639 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
640 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
641 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
644 static char buffer
[100];
646 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
653 get_FORM_name (unsigned long form
)
657 case DW_FORM_addr
: return "DW_FORM_addr";
658 case DW_FORM_block2
: return "DW_FORM_block2";
659 case DW_FORM_block4
: return "DW_FORM_block4";
660 case DW_FORM_data2
: return "DW_FORM_data2";
661 case DW_FORM_data4
: return "DW_FORM_data4";
662 case DW_FORM_data8
: return "DW_FORM_data8";
663 case DW_FORM_string
: return "DW_FORM_string";
664 case DW_FORM_block
: return "DW_FORM_block";
665 case DW_FORM_block1
: return "DW_FORM_block1";
666 case DW_FORM_data1
: return "DW_FORM_data1";
667 case DW_FORM_flag
: return "DW_FORM_flag";
668 case DW_FORM_sdata
: return "DW_FORM_sdata";
669 case DW_FORM_strp
: return "DW_FORM_strp";
670 case DW_FORM_udata
: return "DW_FORM_udata";
671 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
672 case DW_FORM_ref1
: return "DW_FORM_ref1";
673 case DW_FORM_ref2
: return "DW_FORM_ref2";
674 case DW_FORM_ref4
: return "DW_FORM_ref4";
675 case DW_FORM_ref8
: return "DW_FORM_ref8";
676 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
677 case DW_FORM_indirect
: return "DW_FORM_indirect";
678 /* DWARF 4 values. */
679 case DW_FORM_sec_offset
: return "DW_FORM_sec_offset";
680 case DW_FORM_exprloc
: return "DW_FORM_exprloc";
681 case DW_FORM_flag_present
: return "DW_FORM_flag_present";
682 case DW_FORM_ref_sig8
: return "DW_FORM_ref_sig8";
685 static char buffer
[100];
687 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
693 static unsigned char *
694 display_block (unsigned char *data
, unsigned long length
)
696 printf (_(" %lu byte block: "), length
);
699 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
705 decode_location_expression (unsigned char * data
,
706 unsigned int pointer_size
,
707 unsigned long length
,
708 unsigned long cu_offset
,
709 struct dwarf_section
* section
)
712 unsigned int bytes_read
;
713 unsigned long uvalue
;
714 unsigned char *end
= data
+ length
;
715 int need_frame_base
= 0;
724 printf ("DW_OP_addr: %lx",
725 (unsigned long) byte_get (data
, pointer_size
));
726 data
+= pointer_size
;
729 printf ("DW_OP_deref");
732 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
735 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
738 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
742 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
746 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
750 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
754 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
755 (unsigned long) byte_get (data
+ 4, 4));
759 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
760 (long) byte_get (data
+ 4, 4));
764 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
768 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
772 printf ("DW_OP_dup");
775 printf ("DW_OP_drop");
778 printf ("DW_OP_over");
781 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
784 printf ("DW_OP_swap");
787 printf ("DW_OP_rot");
790 printf ("DW_OP_xderef");
793 printf ("DW_OP_abs");
796 printf ("DW_OP_and");
799 printf ("DW_OP_div");
802 printf ("DW_OP_minus");
805 printf ("DW_OP_mod");
808 printf ("DW_OP_mul");
811 printf ("DW_OP_neg");
814 printf ("DW_OP_not");
820 printf ("DW_OP_plus");
822 case DW_OP_plus_uconst
:
823 printf ("DW_OP_plus_uconst: %lu",
824 read_leb128 (data
, &bytes_read
, 0));
828 printf ("DW_OP_shl");
831 printf ("DW_OP_shr");
834 printf ("DW_OP_shra");
837 printf ("DW_OP_xor");
840 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
862 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
898 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
933 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
968 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
969 read_leb128 (data
, &bytes_read
, 1));
974 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
979 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
983 uvalue
= read_leb128 (data
, &bytes_read
, 0);
985 printf ("DW_OP_bregx: %lu %ld", uvalue
,
986 read_leb128 (data
, &bytes_read
, 1));
990 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
993 case DW_OP_deref_size
:
994 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
996 case DW_OP_xderef_size
:
997 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
1000 printf ("DW_OP_nop");
1003 /* DWARF 3 extensions. */
1004 case DW_OP_push_object_address
:
1005 printf ("DW_OP_push_object_address");
1008 /* XXX: Strictly speaking for 64-bit DWARF3 files
1009 this ought to be an 8-byte wide computation. */
1010 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
1014 /* XXX: Strictly speaking for 64-bit DWARF3 files
1015 this ought to be an 8-byte wide computation. */
1016 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
1019 case DW_OP_call_ref
:
1020 /* XXX: Strictly speaking for 64-bit DWARF3 files
1021 this ought to be an 8-byte wide computation. */
1022 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
1025 case DW_OP_form_tls_address
:
1026 printf ("DW_OP_form_tls_address");
1028 case DW_OP_call_frame_cfa
:
1029 printf ("DW_OP_call_frame_cfa");
1031 case DW_OP_bit_piece
:
1032 printf ("DW_OP_bit_piece: ");
1033 printf ("size: %lu ", read_leb128 (data
, &bytes_read
, 0));
1035 printf ("offset: %lu ", read_leb128 (data
, &bytes_read
, 0));
1039 /* DWARF 4 extensions. */
1040 case DW_OP_stack_value
:
1041 printf ("DW_OP_stack_value");
1044 case DW_OP_implicit_value
:
1045 printf ("DW_OP_implicit_value");
1046 uvalue
= read_leb128 (data
, &bytes_read
, 0);
1048 display_block (data
, uvalue
);
1052 /* GNU extensions. */
1053 case DW_OP_GNU_push_tls_address
:
1054 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1056 case DW_OP_GNU_uninit
:
1057 printf ("DW_OP_GNU_uninit");
1058 /* FIXME: Is there data associated with this OP ? */
1060 case DW_OP_GNU_encoded_addr
:
1066 addr
= get_encoded_value (data
, encoding
);
1067 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1068 addr
+= section
->address
+ (data
- section
->start
);
1069 data
+= size_of_encoded_value (encoding
);
1071 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1072 print_dwarf_vma (addr
, pointer_size
);
1076 /* HP extensions. */
1077 case DW_OP_HP_is_value
:
1078 printf ("DW_OP_HP_is_value");
1079 /* FIXME: Is there data associated with this OP ? */
1081 case DW_OP_HP_fltconst4
:
1082 printf ("DW_OP_HP_fltconst4");
1083 /* FIXME: Is there data associated with this OP ? */
1085 case DW_OP_HP_fltconst8
:
1086 printf ("DW_OP_HP_fltconst8");
1087 /* FIXME: Is there data associated with this OP ? */
1089 case DW_OP_HP_mod_range
:
1090 printf ("DW_OP_HP_mod_range");
1091 /* FIXME: Is there data associated with this OP ? */
1093 case DW_OP_HP_unmod_range
:
1094 printf ("DW_OP_HP_unmod_range");
1095 /* FIXME: Is there data associated with this OP ? */
1098 printf ("DW_OP_HP_tls");
1099 /* FIXME: Is there data associated with this OP ? */
1102 /* PGI (STMicroelectronics) extensions. */
1103 case DW_OP_PGI_omp_thread_num
:
1104 /* Pushes the thread number for the current thread as it would be
1105 returned by the standard OpenMP library function:
1106 omp_get_thread_num(). The "current thread" is the thread for
1107 which the expression is being evaluated. */
1108 printf ("DW_OP_PGI_omp_thread_num");
1112 if (op
>= DW_OP_lo_user
1113 && op
<= DW_OP_hi_user
)
1114 printf (_("(User defined location op)"));
1116 printf (_("(Unknown location op)"));
1117 /* No way to tell where the next op is, so just bail. */
1118 return need_frame_base
;
1121 /* Separate the ops. */
1126 return need_frame_base
;
1129 static unsigned char *
1130 read_and_display_attr_value (unsigned long attribute
,
1132 unsigned char * data
,
1133 unsigned long cu_offset
,
1134 unsigned long pointer_size
,
1135 unsigned long offset_size
,
1137 debug_info
* debug_info_p
,
1139 struct dwarf_section
* section
)
1141 unsigned long uvalue
= 0;
1142 unsigned char *block_start
= NULL
;
1143 unsigned char * orig_data
= data
;
1144 unsigned int bytes_read
;
1151 case DW_FORM_ref_addr
:
1152 if (dwarf_version
== 2)
1154 uvalue
= byte_get (data
, pointer_size
);
1155 data
+= pointer_size
;
1157 else if (dwarf_version
== 3)
1159 uvalue
= byte_get (data
, offset_size
);
1160 data
+= offset_size
;
1164 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1169 uvalue
= byte_get (data
, pointer_size
);
1170 data
+= pointer_size
;
1174 uvalue
= byte_get (data
, offset_size
);
1175 data
+= offset_size
;
1181 uvalue
= byte_get (data
++, 1);
1186 uvalue
= byte_get (data
, 2);
1192 uvalue
= byte_get (data
, 4);
1197 uvalue
= read_leb128 (data
, & bytes_read
, 1);
1201 case DW_FORM_ref_udata
:
1203 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1207 case DW_FORM_indirect
:
1208 form
= read_leb128 (data
, & bytes_read
, 0);
1211 printf (" %s", get_FORM_name (form
));
1212 return read_and_display_attr_value (attribute
, form
, data
,
1213 cu_offset
, pointer_size
,
1214 offset_size
, dwarf_version
,
1215 debug_info_p
, do_loc
,
1221 case DW_FORM_ref_addr
:
1223 printf (" <0x%lx>", uvalue
);
1229 case DW_FORM_ref_udata
:
1231 printf (" <0x%lx>", uvalue
+ cu_offset
);
1237 printf (" 0x%lx", uvalue
);
1246 printf (" %ld", uvalue
);
1253 uvalue
= byte_get (data
, 4);
1254 printf (" 0x%lx", uvalue
);
1255 printf (" 0x%lx", (unsigned long) byte_get (data
+ 4, 4));
1257 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1258 && num_debug_info_entries
== 0)
1260 if (sizeof (uvalue
) == 8)
1261 uvalue
= byte_get (data
, 8);
1263 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1268 case DW_FORM_string
:
1270 printf (" %s", data
);
1271 data
+= strlen ((char *) data
) + 1;
1275 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1276 block_start
= data
+ bytes_read
;
1278 data
= block_start
+ uvalue
;
1280 data
= display_block (block_start
, uvalue
);
1283 case DW_FORM_block1
:
1284 uvalue
= byte_get (data
, 1);
1285 block_start
= data
+ 1;
1287 data
= block_start
+ uvalue
;
1289 data
= display_block (block_start
, uvalue
);
1292 case DW_FORM_block2
:
1293 uvalue
= byte_get (data
, 2);
1294 block_start
= data
+ 2;
1296 data
= block_start
+ uvalue
;
1298 data
= display_block (block_start
, uvalue
);
1301 case DW_FORM_block4
:
1302 uvalue
= byte_get (data
, 4);
1303 block_start
= data
+ 4;
1305 data
= block_start
+ uvalue
;
1307 data
= display_block (block_start
, uvalue
);
1312 printf (_(" (indirect string, offset: 0x%lx): %s"),
1313 uvalue
, fetch_indirect_string (uvalue
));
1316 case DW_FORM_indirect
:
1317 /* Handled above. */
1320 case DW_FORM_ref_sig8
:
1324 printf (" signature: ");
1325 for (i
= 0; i
< 8; i
++)
1327 printf ("%02x", (unsigned) byte_get (data
, 1));
1336 warn (_("Unrecognized form: %lu\n"), form
);
1340 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1341 && num_debug_info_entries
== 0)
1345 case DW_AT_frame_base
:
1346 have_frame_base
= 1;
1347 case DW_AT_location
:
1348 case DW_AT_string_length
:
1349 case DW_AT_return_addr
:
1350 case DW_AT_data_member_location
:
1351 case DW_AT_vtable_elem_location
:
1353 case DW_AT_static_link
:
1354 case DW_AT_use_location
:
1355 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1357 /* Process location list. */
1358 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1359 unsigned int num
= debug_info_p
->num_loc_offsets
;
1361 if (lmax
== 0 || num
>= lmax
)
1364 debug_info_p
->loc_offsets
= (long unsigned int *)
1365 xcrealloc (debug_info_p
->loc_offsets
,
1366 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1367 debug_info_p
->have_frame_base
= (int *)
1368 xcrealloc (debug_info_p
->have_frame_base
,
1369 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1370 debug_info_p
->max_loc_offsets
= lmax
;
1372 debug_info_p
->loc_offsets
[num
] = uvalue
;
1373 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1374 debug_info_p
->num_loc_offsets
++;
1379 if (need_base_address
)
1380 debug_info_p
->base_address
= uvalue
;
1384 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1386 /* Process range list. */
1387 unsigned int lmax
= debug_info_p
->max_range_lists
;
1388 unsigned int num
= debug_info_p
->num_range_lists
;
1390 if (lmax
== 0 || num
>= lmax
)
1393 debug_info_p
->range_lists
= (long unsigned int *)
1394 xcrealloc (debug_info_p
->range_lists
,
1395 lmax
, sizeof (*debug_info_p
->range_lists
));
1396 debug_info_p
->max_range_lists
= lmax
;
1398 debug_info_p
->range_lists
[num
] = uvalue
;
1399 debug_info_p
->num_range_lists
++;
1411 /* For some attributes we can display further information. */
1419 case DW_INL_not_inlined
:
1420 printf (_("(not inlined)"));
1422 case DW_INL_inlined
:
1423 printf (_("(inlined)"));
1425 case DW_INL_declared_not_inlined
:
1426 printf (_("(declared as inline but ignored)"));
1428 case DW_INL_declared_inlined
:
1429 printf (_("(declared as inline and inlined)"));
1432 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1437 case DW_AT_language
:
1440 /* Ordered by the numeric value of these constants. */
1441 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1442 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1443 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1444 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1445 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1446 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1447 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1448 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1449 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1450 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1451 /* DWARF 2.1 values. */
1452 case DW_LANG_Java
: printf ("(Java)"); break;
1453 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1454 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1455 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1456 /* DWARF 3 values. */
1457 case DW_LANG_PLI
: printf ("(PLI)"); break;
1458 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1459 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1460 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1461 case DW_LANG_D
: printf ("(D)"); break;
1462 /* DWARF 4 values. */
1463 case DW_LANG_Python
: printf ("(Python)"); break;
1464 /* MIPS extension. */
1465 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1466 /* UPC extension. */
1467 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1469 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1470 printf ("(implementation defined: %lx)", uvalue
);
1472 printf ("(Unknown: %lx)", uvalue
);
1477 case DW_AT_encoding
:
1480 case DW_ATE_void
: printf ("(void)"); break;
1481 case DW_ATE_address
: printf ("(machine address)"); break;
1482 case DW_ATE_boolean
: printf ("(boolean)"); break;
1483 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1484 case DW_ATE_float
: printf ("(float)"); break;
1485 case DW_ATE_signed
: printf ("(signed)"); break;
1486 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1487 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1488 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1489 /* DWARF 2.1 values: */
1490 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1491 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1492 /* DWARF 3 values: */
1493 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1494 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1495 case DW_ATE_edited
: printf ("(edited)"); break;
1496 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1497 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1498 /* HP extensions: */
1499 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1500 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1501 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1502 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1503 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1504 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1505 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1508 if (uvalue
>= DW_ATE_lo_user
1509 && uvalue
<= DW_ATE_hi_user
)
1510 printf ("(user defined type)");
1512 printf ("(unknown type)");
1517 case DW_AT_accessibility
:
1520 case DW_ACCESS_public
: printf ("(public)"); break;
1521 case DW_ACCESS_protected
: printf ("(protected)"); break;
1522 case DW_ACCESS_private
: printf ("(private)"); break;
1524 printf ("(unknown accessibility)");
1529 case DW_AT_visibility
:
1532 case DW_VIS_local
: printf ("(local)"); break;
1533 case DW_VIS_exported
: printf ("(exported)"); break;
1534 case DW_VIS_qualified
: printf ("(qualified)"); break;
1535 default: printf ("(unknown visibility)"); break;
1539 case DW_AT_virtuality
:
1542 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1543 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1544 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1545 default: printf ("(unknown virtuality)"); break;
1549 case DW_AT_identifier_case
:
1552 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1553 case DW_ID_up_case
: printf ("(up_case)"); break;
1554 case DW_ID_down_case
: printf ("(down_case)"); break;
1555 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1556 default: printf ("(unknown case)"); break;
1560 case DW_AT_calling_convention
:
1563 case DW_CC_normal
: printf ("(normal)"); break;
1564 case DW_CC_program
: printf ("(program)"); break;
1565 case DW_CC_nocall
: printf ("(nocall)"); break;
1567 if (uvalue
>= DW_CC_lo_user
1568 && uvalue
<= DW_CC_hi_user
)
1569 printf ("(user defined)");
1571 printf ("(unknown convention)");
1575 case DW_AT_ordering
:
1578 case -1: printf ("(undefined)"); break;
1579 case 0: printf ("(row major)"); break;
1580 case 1: printf ("(column major)"); break;
1584 case DW_AT_frame_base
:
1585 have_frame_base
= 1;
1586 case DW_AT_location
:
1587 case DW_AT_string_length
:
1588 case DW_AT_return_addr
:
1589 case DW_AT_data_member_location
:
1590 case DW_AT_vtable_elem_location
:
1592 case DW_AT_static_link
:
1593 case DW_AT_use_location
:
1594 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1595 printf (_("(location list)"));
1597 case DW_AT_allocated
:
1598 case DW_AT_associated
:
1599 case DW_AT_data_location
:
1601 case DW_AT_upper_bound
:
1602 case DW_AT_lower_bound
:
1605 int need_frame_base
;
1608 need_frame_base
= decode_location_expression (block_start
,
1611 cu_offset
, section
);
1613 if (need_frame_base
&& !have_frame_base
)
1614 printf (_(" [without DW_AT_frame_base]"));
1620 if (form
== DW_FORM_ref_sig8
)
1623 if (form
== DW_FORM_ref1
1624 || form
== DW_FORM_ref2
1625 || form
== DW_FORM_ref4
)
1626 uvalue
+= cu_offset
;
1628 if (uvalue
>= section
->size
)
1629 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1630 uvalue
, (unsigned long) (orig_data
- section
->start
));
1633 unsigned long abbrev_number
;
1634 abbrev_entry
* entry
;
1636 abbrev_number
= read_leb128 (section
->start
+ uvalue
, NULL
, 0);
1638 printf ("[Abbrev Number: %ld", abbrev_number
);
1639 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
1640 if (entry
->entry
== abbrev_number
)
1643 printf (" (%s)", get_TAG_name (entry
->tag
));
1657 get_AT_name (unsigned long attribute
)
1661 case DW_AT_sibling
: return "DW_AT_sibling";
1662 case DW_AT_location
: return "DW_AT_location";
1663 case DW_AT_name
: return "DW_AT_name";
1664 case DW_AT_ordering
: return "DW_AT_ordering";
1665 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1666 case DW_AT_byte_size
: return "DW_AT_byte_size";
1667 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1668 case DW_AT_bit_size
: return "DW_AT_bit_size";
1669 case DW_AT_element_list
: return "DW_AT_element_list";
1670 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1671 case DW_AT_low_pc
: return "DW_AT_low_pc";
1672 case DW_AT_high_pc
: return "DW_AT_high_pc";
1673 case DW_AT_language
: return "DW_AT_language";
1674 case DW_AT_member
: return "DW_AT_member";
1675 case DW_AT_discr
: return "DW_AT_discr";
1676 case DW_AT_discr_value
: return "DW_AT_discr_value";
1677 case DW_AT_visibility
: return "DW_AT_visibility";
1678 case DW_AT_import
: return "DW_AT_import";
1679 case DW_AT_string_length
: return "DW_AT_string_length";
1680 case DW_AT_common_reference
: return "DW_AT_common_reference";
1681 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1682 case DW_AT_const_value
: return "DW_AT_const_value";
1683 case DW_AT_containing_type
: return "DW_AT_containing_type";
1684 case DW_AT_default_value
: return "DW_AT_default_value";
1685 case DW_AT_inline
: return "DW_AT_inline";
1686 case DW_AT_is_optional
: return "DW_AT_is_optional";
1687 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1688 case DW_AT_producer
: return "DW_AT_producer";
1689 case DW_AT_prototyped
: return "DW_AT_prototyped";
1690 case DW_AT_return_addr
: return "DW_AT_return_addr";
1691 case DW_AT_start_scope
: return "DW_AT_start_scope";
1692 case DW_AT_stride_size
: return "DW_AT_stride_size";
1693 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1694 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1695 case DW_AT_accessibility
: return "DW_AT_accessibility";
1696 case DW_AT_address_class
: return "DW_AT_address_class";
1697 case DW_AT_artificial
: return "DW_AT_artificial";
1698 case DW_AT_base_types
: return "DW_AT_base_types";
1699 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1700 case DW_AT_count
: return "DW_AT_count";
1701 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1702 case DW_AT_decl_column
: return "DW_AT_decl_column";
1703 case DW_AT_decl_file
: return "DW_AT_decl_file";
1704 case DW_AT_decl_line
: return "DW_AT_decl_line";
1705 case DW_AT_declaration
: return "DW_AT_declaration";
1706 case DW_AT_discr_list
: return "DW_AT_discr_list";
1707 case DW_AT_encoding
: return "DW_AT_encoding";
1708 case DW_AT_external
: return "DW_AT_external";
1709 case DW_AT_frame_base
: return "DW_AT_frame_base";
1710 case DW_AT_friend
: return "DW_AT_friend";
1711 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1712 case DW_AT_macro_info
: return "DW_AT_macro_info";
1713 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1714 case DW_AT_priority
: return "DW_AT_priority";
1715 case DW_AT_segment
: return "DW_AT_segment";
1716 case DW_AT_specification
: return "DW_AT_specification";
1717 case DW_AT_static_link
: return "DW_AT_static_link";
1718 case DW_AT_type
: return "DW_AT_type";
1719 case DW_AT_use_location
: return "DW_AT_use_location";
1720 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1721 case DW_AT_virtuality
: return "DW_AT_virtuality";
1722 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1723 /* DWARF 2.1 values. */
1724 case DW_AT_allocated
: return "DW_AT_allocated";
1725 case DW_AT_associated
: return "DW_AT_associated";
1726 case DW_AT_data_location
: return "DW_AT_data_location";
1727 case DW_AT_stride
: return "DW_AT_stride";
1728 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1729 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1730 case DW_AT_extension
: return "DW_AT_extension";
1731 case DW_AT_ranges
: return "DW_AT_ranges";
1732 case DW_AT_trampoline
: return "DW_AT_trampoline";
1733 case DW_AT_call_column
: return "DW_AT_call_column";
1734 case DW_AT_call_file
: return "DW_AT_call_file";
1735 case DW_AT_call_line
: return "DW_AT_call_line";
1736 case DW_AT_description
: return "DW_AT_description";
1737 case DW_AT_binary_scale
: return "DW_AT_binary_scale";
1738 case DW_AT_decimal_scale
: return "DW_AT_decimal_scale";
1739 case DW_AT_small
: return "DW_AT_small";
1740 case DW_AT_decimal_sign
: return "DW_AT_decimal_sign";
1741 case DW_AT_digit_count
: return "DW_AT_digit_count";
1742 case DW_AT_picture_string
: return "DW_AT_picture_string";
1743 case DW_AT_mutable
: return "DW_AT_mutable";
1744 case DW_AT_threads_scaled
: return "DW_AT_threads_scaled";
1745 case DW_AT_explicit
: return "DW_AT_explicit";
1746 case DW_AT_object_pointer
: return "DW_AT_object_pointer";
1747 case DW_AT_endianity
: return "DW_AT_endianity";
1748 case DW_AT_elemental
: return "DW_AT_elemental";
1749 case DW_AT_pure
: return "DW_AT_pure";
1750 case DW_AT_recursive
: return "DW_AT_recursive";
1751 /* DWARF 4 values. */
1752 case DW_AT_signature
: return "DW_AT_signature";
1753 case DW_AT_main_subprogram
: return "DW_AT_main_subprogram";
1754 case DW_AT_data_bit_offset
: return "DW_AT_data_bit_offset";
1755 case DW_AT_const_expr
: return "DW_AT_const_expr";
1756 case DW_AT_enum_class
: return "DW_AT_enum_class";
1757 case DW_AT_linkage_name
: return "DW_AT_linkage_name";
1759 /* HP and SGI/MIPS extensions. */
1760 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1761 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1762 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1763 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1764 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
1765 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1766 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1767 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1768 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1769 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1771 /* HP Extensions. */
1772 case DW_AT_HP_block_index
: return "DW_AT_HP_block_index";
1773 case DW_AT_HP_actuals_stmt_list
: return "DW_AT_HP_actuals_stmt_list";
1774 case DW_AT_HP_proc_per_section
: return "DW_AT_HP_proc_per_section";
1775 case DW_AT_HP_raw_data_ptr
: return "DW_AT_HP_raw_data_ptr";
1776 case DW_AT_HP_pass_by_reference
: return "DW_AT_HP_pass_by_reference";
1777 case DW_AT_HP_opt_level
: return "DW_AT_HP_opt_level";
1778 case DW_AT_HP_prof_version_id
: return "DW_AT_HP_prof_version_id";
1779 case DW_AT_HP_opt_flags
: return "DW_AT_HP_opt_flags";
1780 case DW_AT_HP_cold_region_low_pc
: return "DW_AT_HP_cold_region_low_pc";
1781 case DW_AT_HP_cold_region_high_pc
: return "DW_AT_HP_cold_region_high_pc";
1782 case DW_AT_HP_all_variables_modifiable
: return "DW_AT_HP_all_variables_modifiable";
1783 case DW_AT_HP_linkage_name
: return "DW_AT_HP_linkage_name";
1784 case DW_AT_HP_prof_flags
: return "DW_AT_HP_prof_flags";
1786 /* One value is shared by the MIPS and HP extensions: */
1787 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1789 /* GNU extensions. */
1790 case DW_AT_sf_names
: return "DW_AT_sf_names";
1791 case DW_AT_src_info
: return "DW_AT_src_info";
1792 case DW_AT_mac_info
: return "DW_AT_mac_info";
1793 case DW_AT_src_coords
: return "DW_AT_src_coords";
1794 case DW_AT_body_begin
: return "DW_AT_body_begin";
1795 case DW_AT_body_end
: return "DW_AT_body_end";
1796 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1797 case DW_AT_GNU_guarded_by
: return "DW_AT_GNU_guarded_by";
1798 case DW_AT_GNU_pt_guarded_by
: return "DW_AT_GNU_pt_guarded_by";
1799 case DW_AT_GNU_guarded
: return "DW_AT_GNU_guarded";
1800 case DW_AT_GNU_pt_guarded
: return "DW_AT_GNU_pt_guarded";
1801 case DW_AT_GNU_locks_excluded
: return "DW_AT_GNU_locks_excluded";
1802 case DW_AT_GNU_exclusive_locks_required
: return "DW_AT_GNU_exclusive_locks_required";
1803 case DW_AT_GNU_shared_locks_required
: return "DW_AT_GNU_shared_locks_required";
1804 case DW_AT_GNU_odr_signature
: return "DW_AT_GNU_odr_signature";
1805 case DW_AT_use_GNAT_descriptive_type
: return "DW_AT_use_GNAT_descriptive_type";
1806 case DW_AT_GNAT_descriptive_type
: return "DW_AT_GNAT_descriptive_type";
1808 /* UPC extension. */
1809 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1811 /* PGI (STMicroelectronics) extensions. */
1812 case DW_AT_PGI_lbase
: return "DW_AT_PGI_lbase";
1813 case DW_AT_PGI_soffset
: return "DW_AT_PGI_soffset";
1814 case DW_AT_PGI_lstride
: return "DW_AT_PGI_lstride";
1818 static char buffer
[100];
1820 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1827 static unsigned char *
1828 read_and_display_attr (unsigned long attribute
,
1830 unsigned char * data
,
1831 unsigned long cu_offset
,
1832 unsigned long pointer_size
,
1833 unsigned long offset_size
,
1835 debug_info
* debug_info_p
,
1837 struct dwarf_section
* section
)
1840 printf (" %-18s:", get_AT_name (attribute
));
1841 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1842 pointer_size
, offset_size
,
1843 dwarf_version
, debug_info_p
,
1851 /* Process the contents of a .debug_info section. If do_loc is non-zero
1852 then we are scanning for location lists and we do not want to display
1853 anything to the user. If do_types is non-zero, we are processing
1854 a .debug_types section instead of a .debug_info section. */
1857 process_debug_info (struct dwarf_section
*section
,
1862 unsigned char *start
= section
->start
;
1863 unsigned char *end
= start
+ section
->size
;
1864 unsigned char *section_begin
;
1866 unsigned int num_units
= 0;
1868 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1869 && num_debug_info_entries
== 0
1872 unsigned long length
;
1874 /* First scan the section to get the number of comp units. */
1875 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1878 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1879 will be the length. For a 64-bit DWARF section, it'll be
1880 the escape code 0xffffffff followed by an 8 byte length. */
1881 length
= byte_get (section_begin
, 4);
1883 if (length
== 0xffffffff)
1885 length
= byte_get (section_begin
+ 4, 8);
1886 section_begin
+= length
+ 12;
1888 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
1890 warn (_("Reserved length value (%lx) found in section %s\n"), length
, section
->name
);
1894 section_begin
+= length
+ 4;
1896 /* Negative values are illegal, they may even cause infinite
1897 looping. This can happen if we can't accurately apply
1898 relocations to an object file. */
1899 if ((signed long) length
<= 0)
1901 warn (_("Corrupt unit length (%lx) found in section %s\n"), length
, section
->name
);
1908 error (_("No comp units in %s section ?"), section
->name
);
1912 /* Then allocate an array to hold the information. */
1913 debug_information
= (debug_info
*) cmalloc (num_units
,
1914 sizeof (* debug_information
));
1915 if (debug_information
== NULL
)
1917 error (_("Not enough memory for a debug info array of %u entries"),
1925 printf (_("Contents of the %s section:\n\n"), section
->name
);
1927 load_debug_section (str
, file
);
1930 load_debug_section (abbrev
, file
);
1931 if (debug_displays
[abbrev
].section
.start
== NULL
)
1933 warn (_("Unable to locate %s section!\n"),
1934 debug_displays
[abbrev
].section
.name
);
1938 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1940 DWARF2_Internal_CompUnit compunit
;
1941 unsigned char *hdrptr
;
1942 unsigned char *cu_abbrev_offset_ptr
;
1943 unsigned char *tags
;
1945 unsigned long cu_offset
;
1947 int initial_length_size
;
1948 unsigned char signature
[8];
1949 unsigned long type_offset
= 0;
1953 compunit
.cu_length
= byte_get (hdrptr
, 4);
1956 if (compunit
.cu_length
== 0xffffffff)
1958 compunit
.cu_length
= byte_get (hdrptr
, 8);
1961 initial_length_size
= 12;
1966 initial_length_size
= 4;
1969 compunit
.cu_version
= byte_get (hdrptr
, 2);
1972 cu_offset
= start
- section_begin
;
1974 cu_abbrev_offset_ptr
= hdrptr
;
1975 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
1976 hdrptr
+= offset_size
;
1978 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
1985 for (i
= 0; i
< 8; i
++)
1987 signature
[i
] = byte_get (hdrptr
, 1);
1991 type_offset
= byte_get (hdrptr
, offset_size
);
1992 hdrptr
+= offset_size
;
1995 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1996 && num_debug_info_entries
== 0
1999 debug_information
[unit
].cu_offset
= cu_offset
;
2000 debug_information
[unit
].pointer_size
2001 = compunit
.cu_pointer_size
;
2002 debug_information
[unit
].base_address
= 0;
2003 debug_information
[unit
].loc_offsets
= NULL
;
2004 debug_information
[unit
].have_frame_base
= NULL
;
2005 debug_information
[unit
].max_loc_offsets
= 0;
2006 debug_information
[unit
].num_loc_offsets
= 0;
2007 debug_information
[unit
].range_lists
= NULL
;
2008 debug_information
[unit
].max_range_lists
= 0;
2009 debug_information
[unit
].num_range_lists
= 0;
2014 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
2015 printf (_(" Length: 0x%lx (%s)\n"), compunit
.cu_length
,
2016 initial_length_size
== 8 ? "64-bit" : "32-bit");
2017 printf (_(" Version: %d\n"), compunit
.cu_version
);
2018 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
2019 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2023 printf (_(" Signature: "));
2024 for (i
= 0; i
< 8; i
++)
2025 printf ("%02x", signature
[i
]);
2027 printf (_(" Type Offset: 0x%lx\n"), type_offset
);
2031 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2034 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
2035 cu_offset
, compunit
.cu_length
);
2039 start
+= compunit
.cu_length
+ initial_length_size
;
2041 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
2043 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
2044 cu_offset
, compunit
.cu_version
);
2050 /* Process the abbrevs used by this compilation unit. DWARF
2051 sections under Mach-O have non-zero addresses. */
2052 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev
].section
.size
)
2053 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2054 (unsigned long) compunit
.cu_abbrev_offset
,
2055 (unsigned long) debug_displays
[abbrev
].section
.size
);
2057 process_abbrev_section
2058 ((unsigned char *) debug_displays
[abbrev
].section
.start
2059 + compunit
.cu_abbrev_offset
- debug_displays
[abbrev
].section
.address
,
2060 (unsigned char *) debug_displays
[abbrev
].section
.start
2061 + debug_displays
[abbrev
].section
.size
);
2064 while (tags
< start
)
2066 unsigned int bytes_read
;
2067 unsigned long abbrev_number
;
2068 unsigned long die_offset
;
2069 abbrev_entry
*entry
;
2072 die_offset
= tags
- section_begin
;
2074 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
2077 /* A null DIE marks the end of a list of siblings or it may also be
2078 a section padding. */
2079 if (abbrev_number
== 0)
2081 /* Check if it can be a section padding for the last CU. */
2082 if (level
== 0 && start
== end
)
2086 for (chk
= tags
; chk
< start
; chk
++)
2096 static unsigned num_bogus_warns
= 0;
2098 if (num_bogus_warns
< 3)
2100 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2103 if (num_bogus_warns
== 3)
2104 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2111 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2112 level
, die_offset
, abbrev_number
);
2114 /* Scan through the abbreviation list until we reach the
2116 for (entry
= first_abbrev
;
2117 entry
&& entry
->entry
!= abbrev_number
;
2118 entry
= entry
->next
)
2128 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2129 die_offset
, abbrev_number
);
2134 printf (_(" (%s)\n"), get_TAG_name (entry
->tag
));
2139 need_base_address
= 0;
2141 case DW_TAG_compile_unit
:
2142 need_base_address
= 1;
2144 case DW_TAG_entry_point
:
2145 case DW_TAG_subprogram
:
2146 need_base_address
= 0;
2147 /* Assuming that there is no DW_AT_frame_base. */
2148 have_frame_base
= 0;
2152 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2155 /* Show the offset from where the tag was extracted. */
2156 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
2158 tags
= read_and_display_attr (attr
->attribute
,
2161 compunit
.cu_pointer_size
,
2163 compunit
.cu_version
,
2164 debug_information
+ unit
,
2168 if (entry
->children
)
2173 /* Set num_debug_info_entries here so that it can be used to check if
2174 we need to process .debug_loc and .debug_ranges sections. */
2175 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2176 && num_debug_info_entries
== 0
2178 num_debug_info_entries
= num_units
;
2188 /* Locate and scan the .debug_info section in the file and record the pointer
2189 sizes and offsets for the compilation units in it. Usually an executable
2190 will have just one pointer size, but this is not guaranteed, and so we try
2191 not to make any assumptions. Returns zero upon failure, or the number of
2192 compilation units upon success. */
2195 load_debug_info (void * file
)
2197 /* Reset the last pointer size so that we can issue correct error
2198 messages if we are displaying the contents of more than one section. */
2199 last_pointer_size
= 0;
2200 warned_about_missing_comp_units
= FALSE
;
2202 /* If we have already tried and failed to load the .debug_info
2203 section then do not bother to repear the task. */
2204 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2207 /* If we already have the information there is nothing else to do. */
2208 if (num_debug_info_entries
> 0)
2209 return num_debug_info_entries
;
2211 if (load_debug_section (info
, file
)
2212 && process_debug_info (&debug_displays
[info
].section
, file
, 1, 0))
2213 return num_debug_info_entries
;
2215 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2220 display_debug_lines_raw (struct dwarf_section
*section
,
2221 unsigned char *data
,
2224 unsigned char *start
= section
->start
;
2226 printf (_("Raw dump of debug contents of section %s:\n\n"),
2231 DWARF2_Internal_LineInfo linfo
;
2232 unsigned char *standard_opcodes
;
2233 unsigned char *end_of_sequence
;
2234 unsigned char *hdrptr
;
2235 unsigned long hdroff
;
2236 int initial_length_size
;
2241 hdroff
= hdrptr
- start
;
2243 /* Check the length of the block. */
2244 linfo
.li_length
= byte_get (hdrptr
, 4);
2247 if (linfo
.li_length
== 0xffffffff)
2249 /* This section is 64-bit DWARF 3. */
2250 linfo
.li_length
= byte_get (hdrptr
, 8);
2253 initial_length_size
= 12;
2258 initial_length_size
= 4;
2261 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2264 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2269 /* Check its version number. */
2270 linfo
.li_version
= byte_get (hdrptr
, 2);
2272 if (linfo
.li_version
!= 2 && linfo
.li_version
!= 3)
2274 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2278 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2279 hdrptr
+= offset_size
;
2280 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2282 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2284 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2286 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2288 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2291 /* Sign extend the line base field. */
2292 linfo
.li_line_base
<<= 24;
2293 linfo
.li_line_base
>>= 24;
2295 printf (_(" Offset: 0x%lx\n"), hdroff
);
2296 printf (_(" Length: %ld\n"), linfo
.li_length
);
2297 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2298 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2299 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2300 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2301 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2302 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2303 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2305 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2307 reset_state_machine (linfo
.li_default_is_stmt
);
2309 /* Display the contents of the Opcodes table. */
2310 standard_opcodes
= hdrptr
;
2312 printf (_("\n Opcodes:\n"));
2314 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2315 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2317 /* Display the contents of the Directory table. */
2318 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2321 printf (_("\n The Directory Table is empty.\n"));
2324 printf (_("\n The Directory Table:\n"));
2328 printf (_(" %s\n"), data
);
2330 data
+= strlen ((char *) data
) + 1;
2334 /* Skip the NUL at the end of the table. */
2337 /* Display the contents of the File Name table. */
2339 printf (_("\n The File Name Table is empty.\n"));
2342 printf (_("\n The File Name Table:\n"));
2343 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2347 unsigned char *name
;
2348 unsigned int bytes_read
;
2350 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
2353 data
+= strlen ((char *) data
) + 1;
2355 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2357 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2359 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2361 printf (_("%s\n"), name
);
2365 /* Skip the NUL at the end of the table. */
2368 /* Now display the statements. */
2369 printf (_("\n Line Number Statements:\n"));
2371 while (data
< end_of_sequence
)
2373 unsigned char op_code
;
2375 unsigned long int uladv
;
2376 unsigned int bytes_read
;
2380 if (op_code
>= linfo
.li_opcode_base
)
2382 op_code
-= linfo
.li_opcode_base
;
2383 uladv
= (op_code
/ linfo
.li_line_range
) * linfo
.li_min_insn_length
;
2384 state_machine_regs
.address
+= uladv
;
2385 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2386 op_code
, uladv
, state_machine_regs
.address
);
2387 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2388 state_machine_regs
.line
+= adv
;
2389 printf (_(" and Line by %d to %d\n"),
2390 adv
, state_machine_regs
.line
);
2392 else switch (op_code
)
2394 case DW_LNS_extended_op
:
2395 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
);
2399 printf (_(" Copy\n"));
2402 case DW_LNS_advance_pc
:
2403 uladv
= read_leb128 (data
, & bytes_read
, 0);
2404 uladv
*= linfo
.li_min_insn_length
;
2406 state_machine_regs
.address
+= uladv
;
2407 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
2408 state_machine_regs
.address
);
2411 case DW_LNS_advance_line
:
2412 adv
= read_leb128 (data
, & bytes_read
, 1);
2414 state_machine_regs
.line
+= adv
;
2415 printf (_(" Advance Line by %d to %d\n"), adv
,
2416 state_machine_regs
.line
);
2419 case DW_LNS_set_file
:
2420 adv
= read_leb128 (data
, & bytes_read
, 0);
2422 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2424 state_machine_regs
.file
= adv
;
2427 case DW_LNS_set_column
:
2428 uladv
= read_leb128 (data
, & bytes_read
, 0);
2430 printf (_(" Set column to %lu\n"), uladv
);
2431 state_machine_regs
.column
= uladv
;
2434 case DW_LNS_negate_stmt
:
2435 adv
= state_machine_regs
.is_stmt
;
2437 printf (_(" Set is_stmt to %d\n"), adv
);
2438 state_machine_regs
.is_stmt
= adv
;
2441 case DW_LNS_set_basic_block
:
2442 printf (_(" Set basic block\n"));
2443 state_machine_regs
.basic_block
= 1;
2446 case DW_LNS_const_add_pc
:
2447 uladv
= (((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
)
2448 * linfo
.li_min_insn_length
);
2449 state_machine_regs
.address
+= uladv
;
2450 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2451 state_machine_regs
.address
);
2454 case DW_LNS_fixed_advance_pc
:
2455 uladv
= byte_get (data
, 2);
2457 state_machine_regs
.address
+= uladv
;
2458 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2459 uladv
, state_machine_regs
.address
);
2462 case DW_LNS_set_prologue_end
:
2463 printf (_(" Set prologue_end to true\n"));
2466 case DW_LNS_set_epilogue_begin
:
2467 printf (_(" Set epilogue_begin to true\n"));
2470 case DW_LNS_set_isa
:
2471 uladv
= read_leb128 (data
, & bytes_read
, 0);
2473 printf (_(" Set ISA to %lu\n"), uladv
);
2477 printf (_(" Unknown opcode %d with operands: "), op_code
);
2479 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2481 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2482 i
== 1 ? "" : ", ");
2497 unsigned char *name
;
2498 unsigned int directory_index
;
2499 unsigned int modification_date
;
2500 unsigned int length
;
2503 /* Output a decoded representation of the .debug_line section. */
2506 display_debug_lines_decoded (struct dwarf_section
*section
,
2507 unsigned char *data
,
2510 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2515 /* This loop amounts to one iteration per compilation unit. */
2516 DWARF2_Internal_LineInfo linfo
;
2517 unsigned char *standard_opcodes
;
2518 unsigned char *end_of_sequence
;
2519 unsigned char *hdrptr
;
2520 int initial_length_size
;
2523 File_Entry
*file_table
= NULL
;
2524 unsigned char **directory_table
= NULL
;
2525 unsigned int prev_line
= 0;
2529 /* Extract information from the Line Number Program Header.
2530 (section 6.2.4 in the Dwarf3 doc). */
2532 /* Get the length of this CU's line number information block. */
2533 linfo
.li_length
= byte_get (hdrptr
, 4);
2536 if (linfo
.li_length
== 0xffffffff)
2538 /* This section is 64-bit DWARF 3. */
2539 linfo
.li_length
= byte_get (hdrptr
, 8);
2542 initial_length_size
= 12;
2547 initial_length_size
= 4;
2550 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2552 warn (_("The line info appears to be corrupt - "
2553 "the section is too small\n"));
2557 /* Get this CU's Line Number Block version number. */
2558 linfo
.li_version
= byte_get (hdrptr
, 2);
2560 if (linfo
.li_version
!= 2 && linfo
.li_version
!= 3)
2562 warn (_("Only DWARF version 2 and 3 line info is currently "
2567 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2568 hdrptr
+= offset_size
;
2569 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2571 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2573 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2575 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2577 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2580 /* Sign extend the line base field. */
2581 linfo
.li_line_base
<<= 24;
2582 linfo
.li_line_base
>>= 24;
2584 /* Find the end of this CU's Line Number Information Block. */
2585 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2587 reset_state_machine (linfo
.li_default_is_stmt
);
2589 /* Save a pointer to the contents of the Opcodes table. */
2590 standard_opcodes
= hdrptr
;
2592 /* Traverse the Directory table just to count entries. */
2593 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2596 unsigned int n_directories
= 0;
2597 unsigned char *ptr_directory_table
= data
;
2601 data
+= strlen ((char *) data
) + 1;
2605 /* Go through the directory table again to save the directories. */
2606 directory_table
= (unsigned char **)
2607 xmalloc (n_directories
* sizeof (unsigned char *));
2610 while (*ptr_directory_table
!= 0)
2612 directory_table
[i
] = ptr_directory_table
;
2613 ptr_directory_table
+= strlen ((char *) ptr_directory_table
) + 1;
2617 /* Skip the NUL at the end of the table. */
2620 /* Traverse the File Name table just to count the entries. */
2623 unsigned int n_files
= 0;
2624 unsigned char *ptr_file_name_table
= data
;
2628 unsigned int bytes_read
;
2630 /* Skip Name, directory index, last modification time and length
2632 data
+= strlen ((char *) data
) + 1;
2633 read_leb128 (data
, & bytes_read
, 0);
2635 read_leb128 (data
, & bytes_read
, 0);
2637 read_leb128 (data
, & bytes_read
, 0);
2643 /* Go through the file table again to save the strings. */
2644 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
2647 while (*ptr_file_name_table
!= 0)
2649 unsigned int bytes_read
;
2651 file_table
[i
].name
= ptr_file_name_table
;
2652 ptr_file_name_table
+= strlen ((char *) ptr_file_name_table
) + 1;
2654 /* We are not interested in directory, time or size. */
2655 file_table
[i
].directory_index
= read_leb128 (ptr_file_name_table
,
2657 ptr_file_name_table
+= bytes_read
;
2658 file_table
[i
].modification_date
= read_leb128 (ptr_file_name_table
,
2660 ptr_file_name_table
+= bytes_read
;
2661 file_table
[i
].length
= read_leb128 (ptr_file_name_table
, & bytes_read
, 0);
2662 ptr_file_name_table
+= bytes_read
;
2667 /* Print the Compilation Unit's name and a header. */
2668 if (directory_table
== NULL
)
2670 printf (_("CU: %s:\n"), file_table
[0].name
);
2671 printf (_("File name Line number Starting address\n"));
2675 if (do_wide
|| strlen ((char *) directory_table
[0]) < 76)
2677 printf (_("CU: %s/%s:\n"), directory_table
[0],
2678 file_table
[0].name
);
2682 printf (_("%s:\n"), file_table
[0].name
);
2684 printf (_("File name Line number Starting address\n"));
2688 /* Skip the NUL at the end of the table. */
2691 /* This loop iterates through the Dwarf Line Number Program. */
2692 while (data
< end_of_sequence
)
2694 unsigned char op_code
;
2696 unsigned long int uladv
;
2697 unsigned int bytes_read
;
2698 int is_special_opcode
= 0;
2701 prev_line
= state_machine_regs
.line
;
2703 if (op_code
>= linfo
.li_opcode_base
)
2705 op_code
-= linfo
.li_opcode_base
;
2706 uladv
= (op_code
/ linfo
.li_line_range
) * linfo
.li_min_insn_length
;
2707 state_machine_regs
.address
+= uladv
;
2709 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2710 state_machine_regs
.line
+= adv
;
2711 is_special_opcode
= 1;
2713 else switch (op_code
)
2715 case DW_LNS_extended_op
:
2717 unsigned int ext_op_code_len
;
2718 unsigned char ext_op_code
;
2719 unsigned char *op_code_data
= data
;
2721 ext_op_code_len
= read_leb128 (op_code_data
, &bytes_read
, 0);
2722 op_code_data
+= bytes_read
;
2724 if (ext_op_code_len
== 0)
2726 warn (_("badly formed extended line op encountered!\n"));
2729 ext_op_code_len
+= bytes_read
;
2730 ext_op_code
= *op_code_data
++;
2732 switch (ext_op_code
)
2734 case DW_LNE_end_sequence
:
2735 reset_state_machine (linfo
.li_default_is_stmt
);
2737 case DW_LNE_set_address
:
2738 state_machine_regs
.address
=
2739 byte_get (op_code_data
, ext_op_code_len
- bytes_read
- 1);
2741 case DW_LNE_define_file
:
2743 unsigned int dir_index
= 0;
2745 ++state_machine_regs
.last_file_entry
;
2746 op_code_data
+= strlen ((char *) op_code_data
) + 1;
2747 dir_index
= read_leb128 (op_code_data
, & bytes_read
, 0);
2748 op_code_data
+= bytes_read
;
2749 read_leb128 (op_code_data
, & bytes_read
, 0);
2750 op_code_data
+= bytes_read
;
2751 read_leb128 (op_code_data
, & bytes_read
, 0);
2753 printf (_("%s:\n"), directory_table
[dir_index
]);
2757 printf (_("UNKNOWN: length %d\n"), ext_op_code_len
- bytes_read
);
2760 data
+= ext_op_code_len
;
2766 case DW_LNS_advance_pc
:
2767 uladv
= read_leb128 (data
, & bytes_read
, 0);
2768 uladv
*= linfo
.li_min_insn_length
;
2770 state_machine_regs
.address
+= uladv
;
2773 case DW_LNS_advance_line
:
2774 adv
= read_leb128 (data
, & bytes_read
, 1);
2776 state_machine_regs
.line
+= adv
;
2779 case DW_LNS_set_file
:
2780 adv
= read_leb128 (data
, & bytes_read
, 0);
2782 state_machine_regs
.file
= adv
;
2783 if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
2785 /* If directory index is 0, that means current directory. */
2786 printf (_("\n./%s:[++]\n"),
2787 file_table
[state_machine_regs
.file
- 1].name
);
2791 /* The directory index starts counting at 1. */
2792 printf (_("\n%s/%s:\n"),
2793 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
2794 file_table
[state_machine_regs
.file
- 1].name
);
2798 case DW_LNS_set_column
:
2799 uladv
= read_leb128 (data
, & bytes_read
, 0);
2801 state_machine_regs
.column
= uladv
;
2804 case DW_LNS_negate_stmt
:
2805 adv
= state_machine_regs
.is_stmt
;
2807 state_machine_regs
.is_stmt
= adv
;
2810 case DW_LNS_set_basic_block
:
2811 state_machine_regs
.basic_block
= 1;
2814 case DW_LNS_const_add_pc
:
2815 uladv
= (((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
)
2816 * linfo
.li_min_insn_length
);
2817 state_machine_regs
.address
+= uladv
;
2820 case DW_LNS_fixed_advance_pc
:
2821 uladv
= byte_get (data
, 2);
2823 state_machine_regs
.address
+= uladv
;
2826 case DW_LNS_set_prologue_end
:
2829 case DW_LNS_set_epilogue_begin
:
2832 case DW_LNS_set_isa
:
2833 uladv
= read_leb128 (data
, & bytes_read
, 0);
2835 printf (_(" Set ISA to %lu\n"), uladv
);
2839 printf (_(" Unknown opcode %d with operands: "), op_code
);
2841 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2843 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2844 i
== 1 ? "" : ", ");
2851 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2852 to the DWARF address/line matrix. */
2853 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
2854 || (op_code
== DW_LNS_copy
))
2856 const unsigned int MAX_FILENAME_LENGTH
= 35;
2857 char *fileName
= (char *)file_table
[state_machine_regs
.file
- 1].name
;
2858 char *newFileName
= NULL
;
2859 size_t fileNameLength
= strlen (fileName
);
2861 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
2863 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
2864 /* Truncate file name */
2865 strncpy (newFileName
,
2866 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
2867 MAX_FILENAME_LENGTH
+ 1);
2871 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
2872 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
2875 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
2877 printf (_("%-35s %11d %#18lx\n"), newFileName
,
2878 state_machine_regs
.line
, state_machine_regs
.address
);
2882 printf (_("%s %11d %#18lx\n"), newFileName
,
2883 state_machine_regs
.line
, state_machine_regs
.address
);
2886 if (op_code
== DW_LNE_end_sequence
)
2894 free (directory_table
);
2895 directory_table
= NULL
;
2903 display_debug_lines (struct dwarf_section
*section
, void *file
)
2905 unsigned char *data
= section
->start
;
2906 unsigned char *end
= data
+ section
->size
;
2908 int retValDecoded
= 1;
2910 if (load_debug_info (file
) == 0)
2912 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2917 if (do_debug_lines
== 0)
2918 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
2920 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
2921 retValRaw
= display_debug_lines_raw (section
, data
, end
);
2923 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
2924 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
2926 if (!retValRaw
|| !retValDecoded
)
2933 find_debug_info_for_offset (unsigned long offset
)
2937 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2940 for (i
= 0; i
< num_debug_info_entries
; i
++)
2941 if (debug_information
[i
].cu_offset
== offset
)
2942 return debug_information
+ i
;
2948 display_debug_pubnames (struct dwarf_section
*section
,
2949 void *file ATTRIBUTE_UNUSED
)
2951 DWARF2_Internal_PubNames names
;
2952 unsigned char *start
= section
->start
;
2953 unsigned char *end
= start
+ section
->size
;
2955 /* It does not matter if this load fails,
2956 we test for that later on. */
2957 load_debug_info (file
);
2959 printf (_("Contents of the %s section:\n\n"), section
->name
);
2963 unsigned char *data
;
2964 unsigned long offset
;
2965 int offset_size
, initial_length_size
;
2969 names
.pn_length
= byte_get (data
, 4);
2971 if (names
.pn_length
== 0xffffffff)
2973 names
.pn_length
= byte_get (data
, 8);
2976 initial_length_size
= 12;
2981 initial_length_size
= 4;
2984 names
.pn_version
= byte_get (data
, 2);
2987 names
.pn_offset
= byte_get (data
, offset_size
);
2988 data
+= offset_size
;
2990 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
2991 && num_debug_info_entries
> 0
2992 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
2993 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2994 names
.pn_offset
, section
->name
);
2996 names
.pn_size
= byte_get (data
, offset_size
);
2997 data
+= offset_size
;
2999 start
+= names
.pn_length
+ initial_length_size
;
3001 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3003 static int warned
= 0;
3007 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3014 printf (_(" Length: %ld\n"),
3016 printf (_(" Version: %d\n"),
3018 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3020 printf (_(" Size of area in .debug_info section: %ld\n"),
3023 printf (_("\n Offset\tName\n"));
3027 offset
= byte_get (data
, offset_size
);
3031 data
+= offset_size
;
3032 printf (" %-6lx\t%s\n", offset
, data
);
3033 data
+= strlen ((char *) data
) + 1;
3036 while (offset
!= 0);
3044 display_debug_macinfo (struct dwarf_section
*section
,
3045 void *file ATTRIBUTE_UNUSED
)
3047 unsigned char *start
= section
->start
;
3048 unsigned char *end
= start
+ section
->size
;
3049 unsigned char *curr
= start
;
3050 unsigned int bytes_read
;
3051 enum dwarf_macinfo_record_type op
;
3053 printf (_("Contents of the %s section:\n\n"), section
->name
);
3057 unsigned int lineno
;
3060 op
= (enum dwarf_macinfo_record_type
) *curr
;
3065 case DW_MACINFO_start_file
:
3067 unsigned int filenum
;
3069 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3071 filenum
= read_leb128 (curr
, & bytes_read
, 0);
3074 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3079 case DW_MACINFO_end_file
:
3080 printf (_(" DW_MACINFO_end_file\n"));
3083 case DW_MACINFO_define
:
3084 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3086 string
= (char *) curr
;
3087 curr
+= strlen (string
) + 1;
3088 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3092 case DW_MACINFO_undef
:
3093 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3095 string
= (char *) curr
;
3096 curr
+= strlen (string
) + 1;
3097 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3101 case DW_MACINFO_vendor_ext
:
3103 unsigned int constant
;
3105 constant
= read_leb128 (curr
, & bytes_read
, 0);
3107 string
= (char *) curr
;
3108 curr
+= strlen (string
) + 1;
3109 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3120 display_debug_abbrev (struct dwarf_section
*section
,
3121 void *file ATTRIBUTE_UNUSED
)
3123 abbrev_entry
*entry
;
3124 unsigned char *start
= section
->start
;
3125 unsigned char *end
= start
+ section
->size
;
3127 printf (_("Contents of the %s section:\n\n"), section
->name
);
3133 start
= process_abbrev_section (start
, end
);
3135 if (first_abbrev
== NULL
)
3138 printf (_(" Number TAG\n"));
3140 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
3144 printf (_(" %ld %s [%s]\n"),
3146 get_TAG_name (entry
->tag
),
3147 entry
->children
? _("has children") : _("no children"));
3149 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
3150 printf (_(" %-18s %s\n"),
3151 get_AT_name (attr
->attribute
),
3152 get_FORM_name (attr
->form
));
3163 display_debug_loc (struct dwarf_section
*section
, void *file
)
3165 unsigned char *start
= section
->start
;
3166 unsigned char *section_end
;
3167 unsigned long bytes
;
3168 unsigned char *section_begin
= start
;
3169 unsigned int num_loc_list
= 0;
3170 unsigned long last_offset
= 0;
3171 unsigned int first
= 0;
3174 int seen_first_offset
= 0;
3175 int use_debug_info
= 1;
3176 unsigned char *next
;
3178 bytes
= section
->size
;
3179 section_end
= start
+ bytes
;
3183 printf (_("\nThe %s section is empty.\n"), section
->name
);
3187 if (load_debug_info (file
) == 0)
3189 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3194 /* Check the order of location list in .debug_info section. If
3195 offsets of location lists are in the ascending order, we can
3196 use `debug_information' directly. */
3197 for (i
= 0; i
< num_debug_info_entries
; i
++)
3201 num
= debug_information
[i
].num_loc_offsets
;
3202 num_loc_list
+= num
;
3204 /* Check if we can use `debug_information' directly. */
3205 if (use_debug_info
&& num
!= 0)
3207 if (!seen_first_offset
)
3209 /* This is the first location list. */
3210 last_offset
= debug_information
[i
].loc_offsets
[0];
3212 seen_first_offset
= 1;
3218 for (; j
< num
; j
++)
3221 debug_information
[i
].loc_offsets
[j
])
3226 last_offset
= debug_information
[i
].loc_offsets
[j
];
3231 if (!use_debug_info
)
3232 /* FIXME: Should we handle this case? */
3233 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3235 if (!seen_first_offset
)
3236 error (_("No location lists in .debug_info section!\n"));
3238 /* DWARF sections under Mach-O have non-zero addresses. */
3239 if (debug_information
[first
].num_loc_offsets
> 0
3240 && debug_information
[first
].loc_offsets
[0] != section
->address
)
3241 warn (_("Location lists in %s section start at 0x%lx\n"),
3242 section
->name
, debug_information
[first
].loc_offsets
[0]);
3244 printf (_("Contents of the %s section:\n\n"), section
->name
);
3245 printf (_(" Offset Begin End Expression\n"));
3247 seen_first_offset
= 0;
3248 for (i
= first
; i
< num_debug_info_entries
; i
++)
3252 unsigned short length
;
3253 unsigned long offset
;
3254 unsigned int pointer_size
;
3255 unsigned long cu_offset
;
3256 unsigned long base_address
;
3257 int need_frame_base
;
3260 pointer_size
= debug_information
[i
].pointer_size
;
3261 cu_offset
= debug_information
[i
].cu_offset
;
3263 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
3265 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
3266 /* DWARF sections under Mach-O have non-zero addresses. */
3267 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
3268 next
= section_begin
+ offset
;
3269 base_address
= debug_information
[i
].base_address
;
3271 if (!seen_first_offset
)
3272 seen_first_offset
= 1;
3276 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3277 (unsigned long) (start
- section_begin
),
3278 (unsigned long) (next
- section_begin
));
3279 else if (start
> next
)
3280 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3281 (unsigned long) (start
- section_begin
),
3282 (unsigned long) (next
- section_begin
));
3286 if (offset
>= bytes
)
3288 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3295 if (start
+ 2 * pointer_size
> section_end
)
3297 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3302 /* Note: we use sign extension here in order to be sure that
3303 we can detect the -1 escape value. Sign extension into the
3304 top 32 bits of a 32-bit address will not affect the values
3305 that we display since we always show hex values, and always
3306 the bottom 32-bits. */
3307 begin
= byte_get_signed (start
, pointer_size
);
3308 start
+= pointer_size
;
3309 end
= byte_get_signed (start
, pointer_size
);
3310 start
+= pointer_size
;
3312 printf (" %8.8lx ", offset
);
3314 if (begin
== 0 && end
== 0)
3316 printf (_("<End of list>\n"));
3320 /* Check base address specifiers. */
3321 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3324 print_dwarf_vma (begin
, pointer_size
);
3325 print_dwarf_vma (end
, pointer_size
);
3326 printf (_("(base address)\n"));
3330 if (start
+ 2 > section_end
)
3332 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3337 length
= byte_get (start
, 2);
3340 if (start
+ length
> section_end
)
3342 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3347 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3348 print_dwarf_vma (end
+ base_address
, pointer_size
);
3351 need_frame_base
= decode_location_expression (start
,
3354 cu_offset
, section
);
3357 if (need_frame_base
&& !has_frame_base
)
3358 printf (_(" [without DW_AT_frame_base]"));
3361 fputs (_(" (start == end)"), stdout
);
3362 else if (begin
> end
)
3363 fputs (_(" (start > end)"), stdout
);
3372 if (start
< section_end
)
3373 warn (_("There are %ld unused bytes at the end of section %s\n"),
3374 (long) (section_end
- start
), section
->name
);
3380 display_debug_str (struct dwarf_section
*section
,
3381 void *file ATTRIBUTE_UNUSED
)
3383 unsigned char *start
= section
->start
;
3384 unsigned long bytes
= section
->size
;
3385 dwarf_vma addr
= section
->address
;
3389 printf (_("\nThe %s section is empty.\n"), section
->name
);
3393 printf (_("Contents of the %s section:\n\n"), section
->name
);
3401 lbytes
= (bytes
> 16 ? 16 : bytes
);
3403 printf (" 0x%8.8lx ", (unsigned long) addr
);
3405 for (j
= 0; j
< 16; j
++)
3408 printf ("%2.2x", start
[j
]);
3416 for (j
= 0; j
< lbytes
; j
++)
3419 if (k
>= ' ' && k
< 0x80)
3438 display_debug_info (struct dwarf_section
*section
, void *file
)
3440 return process_debug_info (section
, file
, 0, 0);
3444 display_debug_types (struct dwarf_section
*section
, void *file
)
3446 return process_debug_info (section
, file
, 0, 1);
3450 display_debug_aranges (struct dwarf_section
*section
,
3451 void *file ATTRIBUTE_UNUSED
)
3453 unsigned char *start
= section
->start
;
3454 unsigned char *end
= start
+ section
->size
;
3456 printf (_("Contents of the %s section:\n\n"), section
->name
);
3458 /* It does not matter if this load fails,
3459 we test for that later on. */
3460 load_debug_info (file
);
3464 unsigned char *hdrptr
;
3465 DWARF2_Internal_ARange arange
;
3466 unsigned char *addr_ranges
;
3469 unsigned char address_size
;
3472 int initial_length_size
;
3476 arange
.ar_length
= byte_get (hdrptr
, 4);
3479 if (arange
.ar_length
== 0xffffffff)
3481 arange
.ar_length
= byte_get (hdrptr
, 8);
3484 initial_length_size
= 12;
3489 initial_length_size
= 4;
3492 arange
.ar_version
= byte_get (hdrptr
, 2);
3495 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
3496 hdrptr
+= offset_size
;
3498 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3499 && num_debug_info_entries
> 0
3500 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
3501 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3502 arange
.ar_info_offset
, section
->name
);
3504 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
3507 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
3510 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
3512 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3516 printf (_(" Length: %ld\n"), arange
.ar_length
);
3517 printf (_(" Version: %d\n"), arange
.ar_version
);
3518 printf (_(" Offset into .debug_info: 0x%lx\n"), arange
.ar_info_offset
);
3519 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
3520 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
3522 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
3524 /* The DWARF spec does not require that the address size be a power
3525 of two, but we do. This will have to change if we ever encounter
3526 an uneven architecture. */
3527 if ((address_size
& (address_size
- 1)) != 0)
3529 warn (_("Pointer size + Segment size is not a power of two.\n"));
3533 if (address_size
> 4)
3534 printf (_("\n Address Length\n"));
3536 printf (_("\n Address Length\n"));
3538 addr_ranges
= hdrptr
;
3540 /* Must pad to an alignment boundary that is twice the address size. */
3541 excess
= (hdrptr
- start
) % (2 * address_size
);
3543 addr_ranges
+= (2 * address_size
) - excess
;
3545 start
+= arange
.ar_length
+ initial_length_size
;
3547 while (addr_ranges
+ 2 * address_size
<= start
)
3549 address
= byte_get (addr_ranges
, address_size
);
3551 addr_ranges
+= address_size
;
3553 length
= byte_get (addr_ranges
, address_size
);
3555 addr_ranges
+= address_size
;
3558 print_dwarf_vma (address
, address_size
);
3559 print_dwarf_vma (length
, address_size
);
3569 /* Each debug_information[x].range_lists[y] gets this representation for
3570 sorting purposes. */
3574 /* The debug_information[x].range_lists[y] value. */
3575 unsigned long ranges_offset
;
3577 /* Original debug_information to find parameters of the data. */
3578 debug_info
*debug_info_p
;
3581 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3584 range_entry_compar (const void *ap
, const void *bp
)
3586 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
3587 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
3588 const unsigned long a
= a_re
->ranges_offset
;
3589 const unsigned long b
= b_re
->ranges_offset
;
3591 return (a
> b
) - (b
> a
);
3595 display_debug_ranges (struct dwarf_section
*section
,
3596 void *file ATTRIBUTE_UNUSED
)
3598 unsigned char *start
= section
->start
;
3599 unsigned char *section_end
;
3600 unsigned long bytes
;
3601 unsigned char *section_begin
= start
;
3602 unsigned int num_range_list
, i
;
3603 struct range_entry
*range_entries
, *range_entry_fill
;
3605 bytes
= section
->size
;
3606 section_end
= start
+ bytes
;
3610 printf (_("\nThe %s section is empty.\n"), section
->name
);
3614 if (load_debug_info (file
) == 0)
3616 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3622 for (i
= 0; i
< num_debug_info_entries
; i
++)
3623 num_range_list
+= debug_information
[i
].num_range_lists
;
3625 if (num_range_list
== 0)
3626 error (_("No range lists in .debug_info section!\n"));
3628 range_entries
= (struct range_entry
*)
3629 xmalloc (sizeof (*range_entries
) * num_range_list
);
3630 range_entry_fill
= range_entries
;
3632 for (i
= 0; i
< num_debug_info_entries
; i
++)
3634 debug_info
*debug_info_p
= &debug_information
[i
];
3637 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
3639 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
3640 range_entry_fill
->debug_info_p
= debug_info_p
;
3645 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
3646 range_entry_compar
);
3648 /* DWARF sections under Mach-O have non-zero addresses. */
3649 if (range_entries
[0].ranges_offset
!= section
->address
)
3650 warn (_("Range lists in %s section start at 0x%lx\n"),
3651 section
->name
, range_entries
[0].ranges_offset
);
3653 printf (_("Contents of the %s section:\n\n"), section
->name
);
3654 printf (_(" Offset Begin End\n"));
3656 for (i
= 0; i
< num_range_list
; i
++)
3658 struct range_entry
*range_entry
= &range_entries
[i
];
3659 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
3660 unsigned int pointer_size
;
3661 unsigned long offset
;
3662 unsigned char *next
;
3663 unsigned long base_address
;
3665 pointer_size
= debug_info_p
->pointer_size
;
3667 /* DWARF sections under Mach-O have non-zero addresses. */
3668 offset
= range_entry
->ranges_offset
- section
->address
;
3669 next
= section_begin
+ offset
;
3670 base_address
= debug_info_p
->base_address
;
3675 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3676 (unsigned long) (start
- section_begin
),
3677 (unsigned long) (next
- section_begin
), section
->name
);
3678 else if (start
> next
)
3679 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3680 (unsigned long) (start
- section_begin
),
3681 (unsigned long) (next
- section_begin
), section
->name
);
3690 /* Note: we use sign extension here in order to be sure that
3691 we can detect the -1 escape value. Sign extension into the
3692 top 32 bits of a 32-bit address will not affect the values
3693 that we display since we always show hex values, and always
3694 the bottom 32-bits. */
3695 begin
= byte_get_signed (start
, pointer_size
);
3696 start
+= pointer_size
;
3697 end
= byte_get_signed (start
, pointer_size
);
3698 start
+= pointer_size
;
3700 printf (" %8.8lx ", offset
);
3702 if (begin
== 0 && end
== 0)
3704 printf (_("<End of list>\n"));
3708 /* Check base address specifiers. */
3709 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3712 print_dwarf_vma (begin
, pointer_size
);
3713 print_dwarf_vma (end
, pointer_size
);
3714 printf ("(base address)\n");
3718 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3719 print_dwarf_vma (end
+ base_address
, pointer_size
);
3722 fputs (_("(start == end)"), stdout
);
3723 else if (begin
> end
)
3724 fputs (_("(start > end)"), stdout
);
3731 free (range_entries
);
3736 typedef struct Frame_Chunk
3738 struct Frame_Chunk
*next
;
3739 unsigned char *chunk_start
;
3741 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3742 short int *col_type
;
3745 unsigned int code_factor
;
3747 unsigned long pc_begin
;
3748 unsigned long pc_range
;
3752 unsigned char fde_encoding
;
3753 unsigned char cfa_exp
;
3757 static const char *const *dwarf_regnames
;
3758 static unsigned int dwarf_regnames_count
;
3760 /* A marker for a col_type that means this column was never referenced
3761 in the frame info. */
3762 #define DW_CFA_unreferenced (-1)
3764 /* Return 0 if not more space is needed, 1 if more space is needed,
3765 -1 for invalid reg. */
3768 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
3770 int prev
= fc
->ncols
;
3772 if (reg
< (unsigned int) fc
->ncols
)
3775 if (dwarf_regnames_count
3776 && reg
> dwarf_regnames_count
)
3779 fc
->ncols
= reg
+ 1;
3780 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
3781 sizeof (short int));
3782 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
3784 while (prev
< fc
->ncols
)
3786 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
3787 fc
->col_offset
[prev
] = 0;
3793 static const char *const dwarf_regnames_i386
[] =
3795 "eax", "ecx", "edx", "ebx",
3796 "esp", "ebp", "esi", "edi",
3797 "eip", "eflags", NULL
,
3798 "st0", "st1", "st2", "st3",
3799 "st4", "st5", "st6", "st7",
3801 "xmm0", "xmm1", "xmm2", "xmm3",
3802 "xmm4", "xmm5", "xmm6", "xmm7",
3803 "mm0", "mm1", "mm2", "mm3",
3804 "mm4", "mm5", "mm6", "mm7",
3805 "fcw", "fsw", "mxcsr",
3806 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3810 static const char *const dwarf_regnames_x86_64
[] =
3812 "rax", "rdx", "rcx", "rbx",
3813 "rsi", "rdi", "rbp", "rsp",
3814 "r8", "r9", "r10", "r11",
3815 "r12", "r13", "r14", "r15",
3817 "xmm0", "xmm1", "xmm2", "xmm3",
3818 "xmm4", "xmm5", "xmm6", "xmm7",
3819 "xmm8", "xmm9", "xmm10", "xmm11",
3820 "xmm12", "xmm13", "xmm14", "xmm15",
3821 "st0", "st1", "st2", "st3",
3822 "st4", "st5", "st6", "st7",
3823 "mm0", "mm1", "mm2", "mm3",
3824 "mm4", "mm5", "mm6", "mm7",
3826 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3827 "fs.base", "gs.base", NULL
, NULL
,
3829 "mxcsr", "fcw", "fsw"
3833 init_dwarf_regnames (unsigned int e_machine
)
3839 dwarf_regnames
= dwarf_regnames_i386
;
3840 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
3844 dwarf_regnames
= dwarf_regnames_x86_64
;
3845 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
3854 regname (unsigned int regno
, int row
)
3856 static char reg
[64];
3858 && regno
< dwarf_regnames_count
3859 && dwarf_regnames
[regno
] != NULL
)
3862 return dwarf_regnames
[regno
];
3863 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
3864 dwarf_regnames
[regno
]);
3867 snprintf (reg
, sizeof (reg
), "r%d", regno
);
3872 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
3877 if (*max_regs
< fc
->ncols
)
3878 *max_regs
= fc
->ncols
;
3880 if (*need_col_headers
)
3882 static const char *sloc
= " LOC";
3884 *need_col_headers
= 0;
3886 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
3888 for (r
= 0; r
< *max_regs
; r
++)
3889 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
3894 printf ("%-5s ", regname (r
, 1));
3900 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
3902 strcpy (tmp
, "exp");
3904 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
3905 printf ("%-8s ", tmp
);
3907 for (r
= 0; r
< fc
->ncols
; r
++)
3909 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
3911 switch (fc
->col_type
[r
])
3913 case DW_CFA_undefined
:
3916 case DW_CFA_same_value
:
3920 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
3922 case DW_CFA_val_offset
:
3923 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
3925 case DW_CFA_register
:
3926 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
3928 case DW_CFA_expression
:
3929 strcpy (tmp
, "exp");
3931 case DW_CFA_val_expression
:
3932 strcpy (tmp
, "vexp");
3935 strcpy (tmp
, "n/a");
3938 printf ("%-5s ", tmp
);
3944 #define GET(N) byte_get (start, N); start += N
3945 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3946 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3949 display_debug_frames (struct dwarf_section
*section
,
3950 void *file ATTRIBUTE_UNUSED
)
3952 unsigned char *start
= section
->start
;
3953 unsigned char *end
= start
+ section
->size
;
3954 unsigned char *section_start
= start
;
3955 Frame_Chunk
*chunks
= 0;
3956 Frame_Chunk
*remembered_state
= 0;
3958 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
3959 unsigned int length_return
;
3961 const char *bad_reg
= _("bad register: ");
3963 printf (_("Contents of the %s section:\n"), section
->name
);
3967 unsigned char *saved_start
;
3968 unsigned char *block_end
;
3969 unsigned long length
;
3970 unsigned long cie_id
;
3973 int need_col_headers
= 1;
3974 unsigned char *augmentation_data
= NULL
;
3975 unsigned long augmentation_data_len
= 0;
3976 int encoded_ptr_size
= eh_addr_size
;
3978 int initial_length_size
;
3980 saved_start
= start
;
3981 length
= byte_get (start
, 4); start
+= 4;
3985 printf ("\n%08lx ZERO terminator\n\n",
3986 (unsigned long)(saved_start
- section_start
));
3990 if (length
== 0xffffffff)
3992 length
= byte_get (start
, 8);
3995 initial_length_size
= 12;
4000 initial_length_size
= 4;
4003 block_end
= saved_start
+ length
+ initial_length_size
;
4004 if (block_end
> end
)
4006 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4007 length
, (unsigned long)(saved_start
- section_start
));
4010 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
4012 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
4016 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4017 memset (fc
, 0, sizeof (Frame_Chunk
));
4021 fc
->chunk_start
= saved_start
;
4023 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4024 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4025 frame_need_space (fc
, max_regs
- 1);
4029 fc
->augmentation
= (char *) start
;
4030 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
4032 if (fc
->augmentation
[0] == 'z')
4034 fc
->code_factor
= LEB ();
4035 fc
->data_factor
= SLEB ();
4044 augmentation_data_len
= LEB ();
4045 augmentation_data
= start
;
4046 start
+= augmentation_data_len
;
4048 else if (strcmp (fc
->augmentation
, "eh") == 0)
4050 start
+= eh_addr_size
;
4051 fc
->code_factor
= LEB ();
4052 fc
->data_factor
= SLEB ();
4064 fc
->code_factor
= LEB ();
4065 fc
->data_factor
= SLEB ();
4077 if (do_debug_frames_interp
)
4078 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4079 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4080 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
4084 printf ("\n%08lx %08lx %08lx CIE\n",
4085 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
4086 printf (" Version: %d\n", version
);
4087 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
4088 printf (" Code alignment factor: %u\n", fc
->code_factor
);
4089 printf (" Data alignment factor: %d\n", fc
->data_factor
);
4090 printf (" Return address column: %d\n", fc
->ra
);
4092 if (augmentation_data_len
)
4095 printf (" Augmentation data: ");
4096 for (i
= 0; i
< augmentation_data_len
; ++i
)
4097 printf (" %02x", augmentation_data
[i
]);
4103 if (augmentation_data_len
)
4105 unsigned char *p
, *q
;
4106 p
= (unsigned char *) fc
->augmentation
+ 1;
4107 q
= augmentation_data
;
4114 q
+= 1 + size_of_encoded_value (*q
);
4116 fc
->fde_encoding
= *q
++;
4124 if (fc
->fde_encoding
)
4125 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4128 frame_need_space (fc
, fc
->ra
);
4132 unsigned char *look_for
;
4133 static Frame_Chunk fde_fc
;
4136 memset (fc
, 0, sizeof (Frame_Chunk
));
4138 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
4140 for (cie
= chunks
; cie
; cie
= cie
->next
)
4141 if (cie
->chunk_start
== look_for
)
4146 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4147 cie_id
, (unsigned long)(saved_start
- section_start
));
4149 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4150 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4151 frame_need_space (fc
, max_regs
- 1);
4153 fc
->augmentation
= "";
4154 fc
->fde_encoding
= 0;
4158 fc
->ncols
= cie
->ncols
;
4159 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
4160 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
4161 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
4162 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
4163 fc
->augmentation
= cie
->augmentation
;
4164 fc
->code_factor
= cie
->code_factor
;
4165 fc
->data_factor
= cie
->data_factor
;
4166 fc
->cfa_reg
= cie
->cfa_reg
;
4167 fc
->cfa_offset
= cie
->cfa_offset
;
4169 frame_need_space (fc
, max_regs
- 1);
4170 fc
->fde_encoding
= cie
->fde_encoding
;
4173 if (fc
->fde_encoding
)
4174 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4176 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
4177 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4178 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
4179 start
+= encoded_ptr_size
;
4180 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
4181 start
+= encoded_ptr_size
;
4183 if (cie
->augmentation
[0] == 'z')
4185 augmentation_data_len
= LEB ();
4186 augmentation_data
= start
;
4187 start
+= augmentation_data_len
;
4190 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4191 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4192 (unsigned long)(cie
->chunk_start
- section_start
),
4193 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
4194 if (! do_debug_frames_interp
&& augmentation_data_len
)
4198 printf (" Augmentation data: ");
4199 for (i
= 0; i
< augmentation_data_len
; ++i
)
4200 printf (" %02x", augmentation_data
[i
]);
4206 /* At this point, fc is the current chunk, cie (if any) is set, and
4207 we're about to interpret instructions for the chunk. */
4208 /* ??? At present we need to do this always, since this sizes the
4209 fc->col_type and fc->col_offset arrays, which we write into always.
4210 We should probably split the interpreted and non-interpreted bits
4211 into two different routines, since there's so much that doesn't
4212 really overlap between them. */
4213 if (1 || do_debug_frames_interp
)
4215 /* Start by making a pass over the chunk, allocating storage
4216 and taking note of what registers are used. */
4217 unsigned char *tmp
= start
;
4219 while (start
< block_end
)
4222 unsigned long reg
, temp
;
4229 /* Warning: if you add any more cases to this switch, be
4230 sure to add them to the corresponding switch below. */
4233 case DW_CFA_advance_loc
:
4237 if (frame_need_space (fc
, opa
) >= 0)
4238 fc
->col_type
[opa
] = DW_CFA_undefined
;
4240 case DW_CFA_restore
:
4241 if (frame_need_space (fc
, opa
) >= 0)
4242 fc
->col_type
[opa
] = DW_CFA_undefined
;
4244 case DW_CFA_set_loc
:
4245 start
+= encoded_ptr_size
;
4247 case DW_CFA_advance_loc1
:
4250 case DW_CFA_advance_loc2
:
4253 case DW_CFA_advance_loc4
:
4256 case DW_CFA_offset_extended
:
4257 case DW_CFA_val_offset
:
4258 reg
= LEB (); LEB ();
4259 if (frame_need_space (fc
, reg
) >= 0)
4260 fc
->col_type
[reg
] = DW_CFA_undefined
;
4262 case DW_CFA_restore_extended
:
4264 frame_need_space (fc
, reg
);
4265 if (frame_need_space (fc
, reg
) >= 0)
4266 fc
->col_type
[reg
] = DW_CFA_undefined
;
4268 case DW_CFA_undefined
:
4270 if (frame_need_space (fc
, reg
) >= 0)
4271 fc
->col_type
[reg
] = DW_CFA_undefined
;
4273 case DW_CFA_same_value
:
4275 if (frame_need_space (fc
, reg
) >= 0)
4276 fc
->col_type
[reg
] = DW_CFA_undefined
;
4278 case DW_CFA_register
:
4279 reg
= LEB (); LEB ();
4280 if (frame_need_space (fc
, reg
) >= 0)
4281 fc
->col_type
[reg
] = DW_CFA_undefined
;
4283 case DW_CFA_def_cfa
:
4286 case DW_CFA_def_cfa_register
:
4289 case DW_CFA_def_cfa_offset
:
4292 case DW_CFA_def_cfa_expression
:
4296 case DW_CFA_expression
:
4297 case DW_CFA_val_expression
:
4301 if (frame_need_space (fc
, reg
) >= 0)
4302 fc
->col_type
[reg
] = DW_CFA_undefined
;
4304 case DW_CFA_offset_extended_sf
:
4305 case DW_CFA_val_offset_sf
:
4306 reg
= LEB (); SLEB ();
4307 if (frame_need_space (fc
, reg
) >= 0)
4308 fc
->col_type
[reg
] = DW_CFA_undefined
;
4310 case DW_CFA_def_cfa_sf
:
4313 case DW_CFA_def_cfa_offset_sf
:
4316 case DW_CFA_MIPS_advance_loc8
:
4319 case DW_CFA_GNU_args_size
:
4322 case DW_CFA_GNU_negative_offset_extended
:
4323 reg
= LEB (); LEB ();
4324 if (frame_need_space (fc
, reg
) >= 0)
4325 fc
->col_type
[reg
] = DW_CFA_undefined
;
4334 /* Now we know what registers are used, make a second pass over
4335 the chunk, this time actually printing out the info. */
4337 while (start
< block_end
)
4340 unsigned long ul
, reg
, roffs
;
4343 const char *reg_prefix
= "";
4350 /* Warning: if you add any more cases to this switch, be
4351 sure to add them to the corresponding switch above. */
4354 case DW_CFA_advance_loc
:
4355 if (do_debug_frames_interp
)
4356 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4358 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4359 opa
* fc
->code_factor
,
4360 fc
->pc_begin
+ opa
* fc
->code_factor
);
4361 fc
->pc_begin
+= opa
* fc
->code_factor
;
4366 if (opa
>= (unsigned int) fc
->ncols
)
4367 reg_prefix
= bad_reg
;
4368 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4369 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4370 reg_prefix
, regname (opa
, 0),
4371 roffs
* fc
->data_factor
);
4372 if (*reg_prefix
== '\0')
4374 fc
->col_type
[opa
] = DW_CFA_offset
;
4375 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
4379 case DW_CFA_restore
:
4380 if (opa
>= (unsigned int) cie
->ncols
4381 || opa
>= (unsigned int) fc
->ncols
)
4382 reg_prefix
= bad_reg
;
4383 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4384 printf (" DW_CFA_restore: %s%s\n",
4385 reg_prefix
, regname (opa
, 0));
4386 if (*reg_prefix
== '\0')
4388 fc
->col_type
[opa
] = cie
->col_type
[opa
];
4389 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
4393 case DW_CFA_set_loc
:
4394 vma
= get_encoded_value (start
, fc
->fde_encoding
);
4395 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4396 vma
+= section
->address
+ (start
- section_start
);
4397 start
+= encoded_ptr_size
;
4398 if (do_debug_frames_interp
)
4399 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4401 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
4405 case DW_CFA_advance_loc1
:
4406 ofs
= byte_get (start
, 1); start
+= 1;
4407 if (do_debug_frames_interp
)
4408 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4410 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4411 ofs
* fc
->code_factor
,
4412 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4413 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4416 case DW_CFA_advance_loc2
:
4417 ofs
= byte_get (start
, 2); start
+= 2;
4418 if (do_debug_frames_interp
)
4419 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4421 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4422 ofs
* fc
->code_factor
,
4423 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4424 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4427 case DW_CFA_advance_loc4
:
4428 ofs
= byte_get (start
, 4); start
+= 4;
4429 if (do_debug_frames_interp
)
4430 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4432 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4433 ofs
* fc
->code_factor
,
4434 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4435 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4438 case DW_CFA_offset_extended
:
4441 if (reg
>= (unsigned int) fc
->ncols
)
4442 reg_prefix
= bad_reg
;
4443 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4444 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4445 reg_prefix
, regname (reg
, 0),
4446 roffs
* fc
->data_factor
);
4447 if (*reg_prefix
== '\0')
4449 fc
->col_type
[reg
] = DW_CFA_offset
;
4450 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4454 case DW_CFA_val_offset
:
4457 if (reg
>= (unsigned int) fc
->ncols
)
4458 reg_prefix
= bad_reg
;
4459 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4460 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4461 reg_prefix
, regname (reg
, 0),
4462 roffs
* fc
->data_factor
);
4463 if (*reg_prefix
== '\0')
4465 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4466 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4470 case DW_CFA_restore_extended
:
4472 if (reg
>= (unsigned int) cie
->ncols
4473 || reg
>= (unsigned int) fc
->ncols
)
4474 reg_prefix
= bad_reg
;
4475 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4476 printf (" DW_CFA_restore_extended: %s%s\n",
4477 reg_prefix
, regname (reg
, 0));
4478 if (*reg_prefix
== '\0')
4480 fc
->col_type
[reg
] = cie
->col_type
[reg
];
4481 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
4485 case DW_CFA_undefined
:
4487 if (reg
>= (unsigned int) fc
->ncols
)
4488 reg_prefix
= bad_reg
;
4489 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4490 printf (" DW_CFA_undefined: %s%s\n",
4491 reg_prefix
, regname (reg
, 0));
4492 if (*reg_prefix
== '\0')
4494 fc
->col_type
[reg
] = DW_CFA_undefined
;
4495 fc
->col_offset
[reg
] = 0;
4499 case DW_CFA_same_value
:
4501 if (reg
>= (unsigned int) fc
->ncols
)
4502 reg_prefix
= bad_reg
;
4503 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4504 printf (" DW_CFA_same_value: %s%s\n",
4505 reg_prefix
, regname (reg
, 0));
4506 if (*reg_prefix
== '\0')
4508 fc
->col_type
[reg
] = DW_CFA_same_value
;
4509 fc
->col_offset
[reg
] = 0;
4513 case DW_CFA_register
:
4516 if (reg
>= (unsigned int) fc
->ncols
)
4517 reg_prefix
= bad_reg
;
4518 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4520 printf (" DW_CFA_register: %s%s in ",
4521 reg_prefix
, regname (reg
, 0));
4522 puts (regname (roffs
, 0));
4524 if (*reg_prefix
== '\0')
4526 fc
->col_type
[reg
] = DW_CFA_register
;
4527 fc
->col_offset
[reg
] = roffs
;
4531 case DW_CFA_remember_state
:
4532 if (! do_debug_frames_interp
)
4533 printf (" DW_CFA_remember_state\n");
4534 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4535 rs
->ncols
= fc
->ncols
;
4536 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
4537 sizeof (short int));
4538 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
4539 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
4540 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
4541 rs
->next
= remembered_state
;
4542 remembered_state
= rs
;
4545 case DW_CFA_restore_state
:
4546 if (! do_debug_frames_interp
)
4547 printf (" DW_CFA_restore_state\n");
4548 rs
= remembered_state
;
4551 remembered_state
= rs
->next
;
4552 frame_need_space (fc
, rs
->ncols
- 1);
4553 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
4554 memcpy (fc
->col_offset
, rs
->col_offset
,
4555 rs
->ncols
* sizeof (int));
4556 free (rs
->col_type
);
4557 free (rs
->col_offset
);
4560 else if (do_debug_frames_interp
)
4561 printf ("Mismatched DW_CFA_restore_state\n");
4564 case DW_CFA_def_cfa
:
4565 fc
->cfa_reg
= LEB ();
4566 fc
->cfa_offset
= LEB ();
4568 if (! do_debug_frames_interp
)
4569 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4570 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4573 case DW_CFA_def_cfa_register
:
4574 fc
->cfa_reg
= LEB ();
4576 if (! do_debug_frames_interp
)
4577 printf (" DW_CFA_def_cfa_register: %s\n",
4578 regname (fc
->cfa_reg
, 0));
4581 case DW_CFA_def_cfa_offset
:
4582 fc
->cfa_offset
= LEB ();
4583 if (! do_debug_frames_interp
)
4584 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
4588 if (! do_debug_frames_interp
)
4589 printf (" DW_CFA_nop\n");
4592 case DW_CFA_def_cfa_expression
:
4594 if (! do_debug_frames_interp
)
4596 printf (" DW_CFA_def_cfa_expression (");
4597 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4605 case DW_CFA_expression
:
4608 if (reg
>= (unsigned int) fc
->ncols
)
4609 reg_prefix
= bad_reg
;
4610 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4612 printf (" DW_CFA_expression: %s%s (",
4613 reg_prefix
, regname (reg
, 0));
4614 decode_location_expression (start
, eh_addr_size
,
4618 if (*reg_prefix
== '\0')
4619 fc
->col_type
[reg
] = DW_CFA_expression
;
4623 case DW_CFA_val_expression
:
4626 if (reg
>= (unsigned int) fc
->ncols
)
4627 reg_prefix
= bad_reg
;
4628 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4630 printf (" DW_CFA_val_expression: %s%s (",
4631 reg_prefix
, regname (reg
, 0));
4632 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4636 if (*reg_prefix
== '\0')
4637 fc
->col_type
[reg
] = DW_CFA_val_expression
;
4641 case DW_CFA_offset_extended_sf
:
4644 if (frame_need_space (fc
, reg
) < 0)
4645 reg_prefix
= bad_reg
;
4646 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4647 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4648 reg_prefix
, regname (reg
, 0),
4649 l
* fc
->data_factor
);
4650 if (*reg_prefix
== '\0')
4652 fc
->col_type
[reg
] = DW_CFA_offset
;
4653 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4657 case DW_CFA_val_offset_sf
:
4660 if (frame_need_space (fc
, reg
) < 0)
4661 reg_prefix
= bad_reg
;
4662 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4663 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4664 reg_prefix
, regname (reg
, 0),
4665 l
* fc
->data_factor
);
4666 if (*reg_prefix
== '\0')
4668 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4669 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4673 case DW_CFA_def_cfa_sf
:
4674 fc
->cfa_reg
= LEB ();
4675 fc
->cfa_offset
= SLEB ();
4676 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4678 if (! do_debug_frames_interp
)
4679 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4680 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4683 case DW_CFA_def_cfa_offset_sf
:
4684 fc
->cfa_offset
= SLEB ();
4685 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4686 if (! do_debug_frames_interp
)
4687 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
4690 case DW_CFA_MIPS_advance_loc8
:
4691 ofs
= byte_get (start
, 8); start
+= 8;
4692 if (do_debug_frames_interp
)
4693 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4695 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4696 ofs
* fc
->code_factor
,
4697 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4698 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4701 case DW_CFA_GNU_window_save
:
4702 if (! do_debug_frames_interp
)
4703 printf (" DW_CFA_GNU_window_save\n");
4706 case DW_CFA_GNU_args_size
:
4708 if (! do_debug_frames_interp
)
4709 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
4712 case DW_CFA_GNU_negative_offset_extended
:
4715 if (frame_need_space (fc
, reg
) < 0)
4716 reg_prefix
= bad_reg
;
4717 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4718 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4719 reg_prefix
, regname (reg
, 0),
4720 l
* fc
->data_factor
);
4721 if (*reg_prefix
== '\0')
4723 fc
->col_type
[reg
] = DW_CFA_offset
;
4724 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4729 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
4730 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
4732 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
4737 if (do_debug_frames_interp
)
4738 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4753 display_debug_not_supported (struct dwarf_section
*section
,
4754 void *file ATTRIBUTE_UNUSED
)
4756 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4763 cmalloc (size_t nmemb
, size_t size
)
4765 /* Check for overflow. */
4766 if (nmemb
>= ~(size_t) 0 / size
)
4769 return malloc (nmemb
* size
);
4773 xcmalloc (size_t nmemb
, size_t size
)
4775 /* Check for overflow. */
4776 if (nmemb
>= ~(size_t) 0 / size
)
4779 return xmalloc (nmemb
* size
);
4783 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
4785 /* Check for overflow. */
4786 if (nmemb
>= ~(size_t) 0 / size
)
4789 return xrealloc (ptr
, nmemb
* size
);
4793 error (const char *message
, ...)
4797 va_start (args
, message
);
4798 fprintf (stderr
, _("%s: Error: "), program_name
);
4799 vfprintf (stderr
, message
, args
);
4804 warn (const char *message
, ...)
4808 va_start (args
, message
);
4809 fprintf (stderr
, _("%s: Warning: "), program_name
);
4810 vfprintf (stderr
, message
, args
);
4815 free_debug_memory (void)
4821 for (i
= 0; i
< max
; i
++)
4822 free_debug_section ((enum dwarf_section_display_enum
) i
);
4824 if (debug_information
!= NULL
)
4826 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
4828 for (i
= 0; i
< num_debug_info_entries
; i
++)
4830 if (!debug_information
[i
].max_loc_offsets
)
4832 free (debug_information
[i
].loc_offsets
);
4833 free (debug_information
[i
].have_frame_base
);
4835 if (!debug_information
[i
].max_range_lists
)
4836 free (debug_information
[i
].range_lists
);
4840 free (debug_information
);
4841 debug_information
= NULL
;
4842 num_debug_info_entries
= 0;
4847 dwarf_select_sections_by_names (const char *names
)
4851 const char * option
;
4855 debug_dump_long_opts
;
4857 static const debug_dump_long_opts opts_table
[] =
4859 /* Please keep this table alpha- sorted. */
4860 { "Ranges", & do_debug_ranges
, 1 },
4861 { "abbrev", & do_debug_abbrevs
, 1 },
4862 { "aranges", & do_debug_aranges
, 1 },
4863 { "frames", & do_debug_frames
, 1 },
4864 { "frames-interp", & do_debug_frames_interp
, 1 },
4865 { "info", & do_debug_info
, 1 },
4866 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
4867 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
4868 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
4869 { "loc", & do_debug_loc
, 1 },
4870 { "macro", & do_debug_macinfo
, 1 },
4871 { "pubnames", & do_debug_pubnames
, 1 },
4872 { "pubtypes", & do_debug_pubtypes
, 1 },
4873 /* This entry is for compatability
4874 with earlier versions of readelf. */
4875 { "ranges", & do_debug_aranges
, 1 },
4876 { "str", & do_debug_str
, 1 },
4885 const debug_dump_long_opts
* entry
;
4887 for (entry
= opts_table
; entry
->option
; entry
++)
4889 size_t len
= strlen (entry
->option
);
4891 if (strncmp (p
, entry
->option
, len
) == 0
4892 && (p
[len
] == ',' || p
[len
] == '\0'))
4894 * entry
->variable
|= entry
->val
;
4896 /* The --debug-dump=frames-interp option also
4897 enables the --debug-dump=frames option. */
4898 if (do_debug_frames_interp
)
4899 do_debug_frames
= 1;
4906 if (entry
->option
== NULL
)
4908 warn (_("Unrecognized debug option '%s'\n"), p
);
4909 p
= strchr (p
, ',');
4920 dwarf_select_sections_by_letters (const char *letters
)
4922 unsigned int lindex
= 0;
4924 while (letters
[lindex
])
4925 switch (letters
[lindex
++])
4932 do_debug_abbrevs
= 1;
4936 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4940 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
4944 do_debug_pubnames
= 1;
4948 do_debug_pubtypes
= 1;
4952 do_debug_aranges
= 1;
4956 do_debug_ranges
= 1;
4960 do_debug_frames_interp
= 1;
4962 do_debug_frames
= 1;
4966 do_debug_macinfo
= 1;
4978 warn (_("Unrecognized debug option '%s'\n"), optarg
);
4984 dwarf_select_sections_all (void)
4987 do_debug_abbrevs
= 1;
4988 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
4989 do_debug_pubnames
= 1;
4990 do_debug_pubtypes
= 1;
4991 do_debug_aranges
= 1;
4992 do_debug_ranges
= 1;
4993 do_debug_frames
= 1;
4994 do_debug_macinfo
= 1;
4999 struct dwarf_section_display debug_displays
[] =
5001 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0 },
5002 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
5003 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0 },
5004 display_debug_aranges
, &do_debug_aranges
, 1 },
5005 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0 },
5006 display_debug_frames
, &do_debug_frames
, 1 },
5007 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0 },
5008 display_debug_info
, &do_debug_info
, 1 },
5009 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0 },
5010 display_debug_lines
, &do_debug_lines
, 1 },
5011 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0 },
5012 display_debug_pubnames
, &do_debug_pubnames
, 0 },
5013 { { ".eh_frame", "", NULL
, NULL
, 0, 0 },
5014 display_debug_frames
, &do_debug_frames
, 1 },
5015 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0 },
5016 display_debug_macinfo
, &do_debug_macinfo
, 0 },
5017 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0 },
5018 display_debug_str
, &do_debug_str
, 0 },
5019 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0 },
5020 display_debug_loc
, &do_debug_loc
, 1 },
5021 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0 },
5022 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
5023 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0 },
5024 display_debug_ranges
, &do_debug_ranges
, 1 },
5025 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0 },
5026 display_debug_not_supported
, NULL
, 0 },
5027 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0 },
5028 display_debug_not_supported
, NULL
, 0 },
5029 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0 },
5030 display_debug_types
, &do_debug_info
, 1 },
5031 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0 },
5032 display_debug_not_supported
, NULL
, 0 }