1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007
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/dwarf2.h"
29 static int have_frame_base
;
30 static int need_base_address
;
32 static unsigned int last_pointer_size
= 0;
33 static int warned_about_missing_comp_units
= FALSE
;
35 static unsigned int num_debug_info_entries
= 0;
36 static debug_info
*debug_information
= NULL
;
37 /* Special value for num_debug_info_entries to indicate
38 that the .debug_info section could not be loaded/parsed. */
39 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
41 dwarf_vma eh_addr_size
;
46 int do_debug_pubnames
;
50 int do_debug_frames_interp
;
55 dwarf_vma (*byte_get
) (unsigned char *, int);
58 byte_get_little_endian (unsigned char *field
, int size
)
66 return ((unsigned int) (field
[0]))
67 | (((unsigned int) (field
[1])) << 8);
70 return ((unsigned long) (field
[0]))
71 | (((unsigned long) (field
[1])) << 8)
72 | (((unsigned long) (field
[2])) << 16)
73 | (((unsigned long) (field
[3])) << 24);
76 if (sizeof (dwarf_vma
) == 8)
77 return ((dwarf_vma
) (field
[0]))
78 | (((dwarf_vma
) (field
[1])) << 8)
79 | (((dwarf_vma
) (field
[2])) << 16)
80 | (((dwarf_vma
) (field
[3])) << 24)
81 | (((dwarf_vma
) (field
[4])) << 32)
82 | (((dwarf_vma
) (field
[5])) << 40)
83 | (((dwarf_vma
) (field
[6])) << 48)
84 | (((dwarf_vma
) (field
[7])) << 56);
85 else if (sizeof (dwarf_vma
) == 4)
86 /* We want to extract data from an 8 byte wide field and
87 place it into a 4 byte wide field. Since this is a little
88 endian source we can just use the 4 byte extraction code. */
89 return ((unsigned long) (field
[0]))
90 | (((unsigned long) (field
[1])) << 8)
91 | (((unsigned long) (field
[2])) << 16)
92 | (((unsigned long) (field
[3])) << 24);
95 error (_("Unhandled data length: %d\n"), size
);
101 byte_get_big_endian (unsigned char *field
, int size
)
109 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
112 return ((unsigned long) (field
[3]))
113 | (((unsigned long) (field
[2])) << 8)
114 | (((unsigned long) (field
[1])) << 16)
115 | (((unsigned long) (field
[0])) << 24);
118 if (sizeof (dwarf_vma
) == 8)
119 return ((dwarf_vma
) (field
[7]))
120 | (((dwarf_vma
) (field
[6])) << 8)
121 | (((dwarf_vma
) (field
[5])) << 16)
122 | (((dwarf_vma
) (field
[4])) << 24)
123 | (((dwarf_vma
) (field
[3])) << 32)
124 | (((dwarf_vma
) (field
[2])) << 40)
125 | (((dwarf_vma
) (field
[1])) << 48)
126 | (((dwarf_vma
) (field
[0])) << 56);
127 else if (sizeof (dwarf_vma
) == 4)
129 /* Although we are extracing data from an 8 byte wide field,
130 we are returning only 4 bytes of data. */
132 return ((unsigned long) (field
[3]))
133 | (((unsigned long) (field
[2])) << 8)
134 | (((unsigned long) (field
[1])) << 16)
135 | (((unsigned long) (field
[0])) << 24);
139 error (_("Unhandled data length: %d\n"), size
);
145 byte_get_signed (unsigned char *field
, int size
)
147 dwarf_vma x
= byte_get (field
, size
);
152 return (x
^ 0x80) - 0x80;
154 return (x
^ 0x8000) - 0x8000;
156 return (x
^ 0x80000000) - 0x80000000;
164 static unsigned long int
165 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
167 unsigned long int result
= 0;
168 unsigned int num_read
= 0;
169 unsigned int shift
= 0;
177 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
184 if (length_return
!= NULL
)
185 *length_return
= num_read
;
187 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
188 result
|= -1L << shift
;
193 typedef struct State_Machine_Registers
195 unsigned long address
;
202 /* This variable hold the number of the last entry seen
203 in the File Table. */
204 unsigned int last_file_entry
;
207 static SMR state_machine_regs
;
210 reset_state_machine (int is_stmt
)
212 state_machine_regs
.address
= 0;
213 state_machine_regs
.file
= 1;
214 state_machine_regs
.line
= 1;
215 state_machine_regs
.column
= 0;
216 state_machine_regs
.is_stmt
= is_stmt
;
217 state_machine_regs
.basic_block
= 0;
218 state_machine_regs
.end_sequence
= 0;
219 state_machine_regs
.last_file_entry
= 0;
222 /* Handled an extend line op.
223 Returns the number of bytes read. */
226 process_extended_line_op (unsigned char *data
, int is_stmt
)
228 unsigned char op_code
;
229 unsigned int bytes_read
;
234 len
= read_leb128 (data
, & bytes_read
, 0);
239 warn (_("badly formed extended line op encountered!\n"));
246 printf (_(" Extended opcode %d: "), op_code
);
250 case DW_LNE_end_sequence
:
251 printf (_("End of Sequence\n\n"));
252 reset_state_machine (is_stmt
);
255 case DW_LNE_set_address
:
256 adr
= byte_get (data
, len
- bytes_read
- 1);
257 printf (_("set Address to 0x%lx\n"), adr
);
258 state_machine_regs
.address
= adr
;
261 case DW_LNE_define_file
:
262 printf (_(" define new File Table entry\n"));
263 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
265 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
267 data
+= strlen ((char *) data
) + 1;
268 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
270 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
272 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
273 printf (_("%s\n\n"), name
);
277 case DW_LNE_HP_negate_is_UV_update
:
278 printf ("DW_LNE_HP_negate_is_UV_update");
280 case DW_LNE_HP_push_context
:
281 printf ("DW_LNE_HP_push_context");
283 case DW_LNE_HP_pop_context
:
284 printf ("DW_LNE_HP_pop_context");
286 case DW_LNE_HP_set_file_line_column
:
287 printf ("DW_LNE_HP_set_file_line_column");
289 case DW_LNE_HP_set_routine_name
:
290 printf ("DW_LNE_HP_set_routine_name");
292 case DW_LNE_HP_set_sequence
:
293 printf ("DW_LNE_HP_set_sequence");
295 case DW_LNE_HP_negate_post_semantics
:
296 printf ("DW_LNE_HP_negate_post_semantics");
298 case DW_LNE_HP_negate_function_exit
:
299 printf ("DW_LNE_HP_negate_function_exit");
301 case DW_LNE_HP_negate_front_end_logical
:
302 printf ("DW_LNE_HP_negate_front_end_logical");
304 case DW_LNE_HP_define_proc
:
305 printf ("DW_LNE_HP_define_proc");
309 if (op_code
>= DW_LNE_lo_user
310 /* The test against DW_LNW_hi_user is redundant due to
311 the limited range of the unsigned char data type used
313 /*&& op_code <= DW_LNE_hi_user*/)
314 printf (_("user defined: length %d\n"), len
- bytes_read
);
316 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
324 fetch_indirect_string (unsigned long offset
)
326 struct dwarf_section
*section
= &debug_displays
[str
].section
;
328 if (section
->start
== NULL
)
329 return _("<no .debug_str section>");
331 /* DWARF sections under Mach-O have non-zero addresses. */
332 offset
-= section
->address
;
333 if (offset
> section
->size
)
335 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
336 return _("<offset is too big>");
339 return (const char *) section
->start
+ offset
;
342 /* FIXME: There are better and more efficient ways to handle
343 these structures. For now though, I just want something that
344 is simple to implement. */
345 typedef struct abbrev_attr
347 unsigned long attribute
;
349 struct abbrev_attr
*next
;
353 typedef struct abbrev_entry
358 struct abbrev_attr
*first_attr
;
359 struct abbrev_attr
*last_attr
;
360 struct abbrev_entry
*next
;
364 static abbrev_entry
*first_abbrev
= NULL
;
365 static abbrev_entry
*last_abbrev
= NULL
;
370 abbrev_entry
*abbrev
;
372 for (abbrev
= first_abbrev
; abbrev
;)
374 abbrev_entry
*next
= abbrev
->next
;
377 for (attr
= abbrev
->first_attr
; attr
;)
379 abbrev_attr
*next
= attr
->next
;
389 last_abbrev
= first_abbrev
= NULL
;
393 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
397 entry
= malloc (sizeof (*entry
));
403 entry
->entry
= number
;
405 entry
->children
= children
;
406 entry
->first_attr
= NULL
;
407 entry
->last_attr
= NULL
;
410 if (first_abbrev
== NULL
)
411 first_abbrev
= entry
;
413 last_abbrev
->next
= entry
;
419 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
423 attr
= malloc (sizeof (*attr
));
429 attr
->attribute
= attribute
;
433 if (last_abbrev
->first_attr
== NULL
)
434 last_abbrev
->first_attr
= attr
;
436 last_abbrev
->last_attr
->next
= attr
;
438 last_abbrev
->last_attr
= attr
;
441 /* Processes the (partial) contents of a .debug_abbrev section.
442 Returns NULL if the end of the section was encountered.
443 Returns the address after the last byte read if the end of
444 an abbreviation set was found. */
446 static unsigned char *
447 process_abbrev_section (unsigned char *start
, unsigned char *end
)
449 if (first_abbrev
!= NULL
)
454 unsigned int bytes_read
;
457 unsigned long attribute
;
460 entry
= read_leb128 (start
, & bytes_read
, 0);
463 /* A single zero is supposed to end the section according
464 to the standard. If there's more, then signal that to
467 return start
== end
? NULL
: start
;
469 tag
= read_leb128 (start
, & bytes_read
, 0);
474 add_abbrev (entry
, tag
, children
);
480 attribute
= read_leb128 (start
, & bytes_read
, 0);
483 form
= read_leb128 (start
, & bytes_read
, 0);
487 add_abbrev_attr (attribute
, form
);
489 while (attribute
!= 0);
496 get_TAG_name (unsigned long tag
)
500 case DW_TAG_padding
: return "DW_TAG_padding";
501 case DW_TAG_array_type
: return "DW_TAG_array_type";
502 case DW_TAG_class_type
: return "DW_TAG_class_type";
503 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
504 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
505 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
506 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
507 case DW_TAG_label
: return "DW_TAG_label";
508 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
509 case DW_TAG_member
: return "DW_TAG_member";
510 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
511 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
512 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
513 case DW_TAG_string_type
: return "DW_TAG_string_type";
514 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
515 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
516 case DW_TAG_typedef
: return "DW_TAG_typedef";
517 case DW_TAG_union_type
: return "DW_TAG_union_type";
518 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
519 case DW_TAG_variant
: return "DW_TAG_variant";
520 case DW_TAG_common_block
: return "DW_TAG_common_block";
521 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
522 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
523 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
524 case DW_TAG_module
: return "DW_TAG_module";
525 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
526 case DW_TAG_set_type
: return "DW_TAG_set_type";
527 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
528 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
529 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
530 case DW_TAG_base_type
: return "DW_TAG_base_type";
531 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
532 case DW_TAG_const_type
: return "DW_TAG_const_type";
533 case DW_TAG_constant
: return "DW_TAG_constant";
534 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
535 case DW_TAG_file_type
: return "DW_TAG_file_type";
536 case DW_TAG_friend
: return "DW_TAG_friend";
537 case DW_TAG_namelist
: return "DW_TAG_namelist";
538 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
539 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
540 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
541 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
542 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
543 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
544 case DW_TAG_try_block
: return "DW_TAG_try_block";
545 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
546 case DW_TAG_variable
: return "DW_TAG_variable";
547 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
548 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
549 case DW_TAG_format_label
: return "DW_TAG_format_label";
550 case DW_TAG_function_template
: return "DW_TAG_function_template";
551 case DW_TAG_class_template
: return "DW_TAG_class_template";
552 /* DWARF 2.1 values. */
553 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
554 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
555 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
556 case DW_TAG_namespace
: return "DW_TAG_namespace";
557 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
558 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
559 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
560 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
562 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
563 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
564 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
567 static char buffer
[100];
569 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
576 get_FORM_name (unsigned long form
)
580 case DW_FORM_addr
: return "DW_FORM_addr";
581 case DW_FORM_block2
: return "DW_FORM_block2";
582 case DW_FORM_block4
: return "DW_FORM_block4";
583 case DW_FORM_data2
: return "DW_FORM_data2";
584 case DW_FORM_data4
: return "DW_FORM_data4";
585 case DW_FORM_data8
: return "DW_FORM_data8";
586 case DW_FORM_string
: return "DW_FORM_string";
587 case DW_FORM_block
: return "DW_FORM_block";
588 case DW_FORM_block1
: return "DW_FORM_block1";
589 case DW_FORM_data1
: return "DW_FORM_data1";
590 case DW_FORM_flag
: return "DW_FORM_flag";
591 case DW_FORM_sdata
: return "DW_FORM_sdata";
592 case DW_FORM_strp
: return "DW_FORM_strp";
593 case DW_FORM_udata
: return "DW_FORM_udata";
594 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
595 case DW_FORM_ref1
: return "DW_FORM_ref1";
596 case DW_FORM_ref2
: return "DW_FORM_ref2";
597 case DW_FORM_ref4
: return "DW_FORM_ref4";
598 case DW_FORM_ref8
: return "DW_FORM_ref8";
599 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
600 case DW_FORM_indirect
: return "DW_FORM_indirect";
603 static char buffer
[100];
605 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
611 static unsigned char *
612 display_block (unsigned char *data
, unsigned long length
)
614 printf (_(" %lu byte block: "), length
);
617 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
623 decode_location_expression (unsigned char * data
,
624 unsigned int pointer_size
,
625 unsigned long length
,
626 unsigned long cu_offset
)
629 unsigned int bytes_read
;
630 unsigned long uvalue
;
631 unsigned char *end
= data
+ length
;
632 int need_frame_base
= 0;
641 printf ("DW_OP_addr: %lx",
642 (unsigned long) byte_get (data
, pointer_size
));
643 data
+= pointer_size
;
646 printf ("DW_OP_deref");
649 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
652 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
655 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
659 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
663 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
667 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
671 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
672 (unsigned long) byte_get (data
+ 4, 4));
676 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
677 (long) byte_get (data
+ 4, 4));
681 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
685 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
689 printf ("DW_OP_dup");
692 printf ("DW_OP_drop");
695 printf ("DW_OP_over");
698 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
701 printf ("DW_OP_swap");
704 printf ("DW_OP_rot");
707 printf ("DW_OP_xderef");
710 printf ("DW_OP_abs");
713 printf ("DW_OP_and");
716 printf ("DW_OP_div");
719 printf ("DW_OP_minus");
722 printf ("DW_OP_mod");
725 printf ("DW_OP_mul");
728 printf ("DW_OP_neg");
731 printf ("DW_OP_not");
737 printf ("DW_OP_plus");
739 case DW_OP_plus_uconst
:
740 printf ("DW_OP_plus_uconst: %lu",
741 read_leb128 (data
, &bytes_read
, 0));
745 printf ("DW_OP_shl");
748 printf ("DW_OP_shr");
751 printf ("DW_OP_shra");
754 printf ("DW_OP_xor");
757 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
779 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
815 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
850 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
885 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
886 read_leb128 (data
, &bytes_read
, 1));
891 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
896 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
900 uvalue
= read_leb128 (data
, &bytes_read
, 0);
902 printf ("DW_OP_bregx: %lu %ld", uvalue
,
903 read_leb128 (data
, &bytes_read
, 1));
907 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
910 case DW_OP_deref_size
:
911 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
913 case DW_OP_xderef_size
:
914 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
917 printf ("DW_OP_nop");
920 /* DWARF 3 extensions. */
921 case DW_OP_push_object_address
:
922 printf ("DW_OP_push_object_address");
925 /* XXX: Strictly speaking for 64-bit DWARF3 files
926 this ought to be an 8-byte wide computation. */
927 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
931 /* XXX: Strictly speaking for 64-bit DWARF3 files
932 this ought to be an 8-byte wide computation. */
933 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
937 /* XXX: Strictly speaking for 64-bit DWARF3 files
938 this ought to be an 8-byte wide computation. */
939 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
942 case DW_OP_form_tls_address
:
943 printf ("DW_OP_form_tls_address");
945 case DW_OP_call_frame_cfa
:
946 printf ("DW_OP_call_frame_cfa");
948 case DW_OP_bit_piece
:
949 printf ("DW_OP_bit_piece: ");
950 printf ("size: %lu ", read_leb128 (data
, &bytes_read
, 0));
952 printf ("offset: %lu ", read_leb128 (data
, &bytes_read
, 0));
956 /* GNU extensions. */
957 case DW_OP_GNU_push_tls_address
:
958 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
960 case DW_OP_GNU_uninit
:
961 printf ("DW_OP_GNU_uninit");
962 /* FIXME: Is there data associated with this OP ? */
966 case DW_OP_HP_is_value
:
967 printf ("DW_OP_HP_is_value");
968 /* FIXME: Is there data associated with this OP ? */
970 case DW_OP_HP_fltconst4
:
971 printf ("DW_OP_HP_fltconst4");
972 /* FIXME: Is there data associated with this OP ? */
974 case DW_OP_HP_fltconst8
:
975 printf ("DW_OP_HP_fltconst8");
976 /* FIXME: Is there data associated with this OP ? */
978 case DW_OP_HP_mod_range
:
979 printf ("DW_OP_HP_mod_range");
980 /* FIXME: Is there data associated with this OP ? */
982 case DW_OP_HP_unmod_range
:
983 printf ("DW_OP_HP_unmod_range");
984 /* FIXME: Is there data associated with this OP ? */
987 printf ("DW_OP_HP_tls");
988 /* FIXME: Is there data associated with this OP ? */
992 if (op
>= DW_OP_lo_user
993 && op
<= DW_OP_hi_user
)
994 printf (_("(User defined location op)"));
996 printf (_("(Unknown location op)"));
997 /* No way to tell where the next op is, so just bail. */
998 return need_frame_base
;
1001 /* Separate the ops. */
1006 return need_frame_base
;
1009 static unsigned char *
1010 read_and_display_attr_value (unsigned long attribute
,
1012 unsigned char * data
,
1013 unsigned long cu_offset
,
1014 unsigned long pointer_size
,
1015 unsigned long offset_size
,
1017 debug_info
* debug_info_p
,
1019 unsigned char * section_start
)
1021 unsigned long uvalue
= 0;
1022 unsigned char *block_start
= NULL
;
1023 unsigned int bytes_read
;
1030 case DW_FORM_ref_addr
:
1031 if (dwarf_version
== 2)
1033 uvalue
= byte_get (data
, pointer_size
);
1034 data
+= pointer_size
;
1036 else if (dwarf_version
== 3)
1038 uvalue
= byte_get (data
, offset_size
);
1039 data
+= offset_size
;
1043 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1048 uvalue
= byte_get (data
, pointer_size
);
1049 data
+= pointer_size
;
1053 uvalue
= byte_get (data
, offset_size
);
1054 data
+= offset_size
;
1060 uvalue
= byte_get (data
++, 1);
1065 uvalue
= byte_get (data
, 2);
1071 uvalue
= byte_get (data
, 4);
1076 uvalue
= read_leb128 (data
, & bytes_read
, 1);
1080 case DW_FORM_ref_udata
:
1082 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1086 case DW_FORM_indirect
:
1087 form
= read_leb128 (data
, & bytes_read
, 0);
1090 printf (" %s", get_FORM_name (form
));
1091 return read_and_display_attr_value (attribute
, form
, data
,
1092 cu_offset
, pointer_size
,
1093 offset_size
, dwarf_version
,
1094 debug_info_p
, do_loc
,
1100 case DW_FORM_ref_addr
:
1102 printf (" <0x%lx>", uvalue
);
1108 case DW_FORM_ref_udata
:
1110 printf (" <0x%lx>", uvalue
+ cu_offset
);
1116 printf (" 0x%lx", uvalue
);
1125 printf (" %ld", uvalue
);
1132 uvalue
= byte_get (data
, 4);
1133 printf (" 0x%lx", uvalue
);
1134 printf (" 0x%lx", (unsigned long) byte_get (data
+ 4, 4));
1136 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1137 && num_debug_info_entries
== 0)
1139 if (sizeof (uvalue
) == 8)
1140 uvalue
= byte_get (data
, 8);
1142 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1147 case DW_FORM_string
:
1149 printf (" %s", data
);
1150 data
+= strlen ((char *) data
) + 1;
1154 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1155 block_start
= data
+ bytes_read
;
1157 data
= block_start
+ uvalue
;
1159 data
= display_block (block_start
, uvalue
);
1162 case DW_FORM_block1
:
1163 uvalue
= byte_get (data
, 1);
1164 block_start
= data
+ 1;
1166 data
= block_start
+ uvalue
;
1168 data
= display_block (block_start
, uvalue
);
1171 case DW_FORM_block2
:
1172 uvalue
= byte_get (data
, 2);
1173 block_start
= data
+ 2;
1175 data
= block_start
+ uvalue
;
1177 data
= display_block (block_start
, uvalue
);
1180 case DW_FORM_block4
:
1181 uvalue
= byte_get (data
, 4);
1182 block_start
= data
+ 4;
1184 data
= block_start
+ uvalue
;
1186 data
= display_block (block_start
, uvalue
);
1191 printf (_(" (indirect string, offset: 0x%lx): %s"),
1192 uvalue
, fetch_indirect_string (uvalue
));
1195 case DW_FORM_indirect
:
1196 /* Handled above. */
1200 warn (_("Unrecognized form: %lu\n"), form
);
1204 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1205 && num_debug_info_entries
== 0)
1209 case DW_AT_frame_base
:
1210 have_frame_base
= 1;
1211 case DW_AT_location
:
1212 case DW_AT_string_length
:
1213 case DW_AT_return_addr
:
1214 case DW_AT_data_member_location
:
1215 case DW_AT_vtable_elem_location
:
1217 case DW_AT_static_link
:
1218 case DW_AT_use_location
:
1219 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1221 /* Process location list. */
1222 unsigned int max
= debug_info_p
->max_loc_offsets
;
1223 unsigned int num
= debug_info_p
->num_loc_offsets
;
1225 if (max
== 0 || num
>= max
)
1228 debug_info_p
->loc_offsets
1229 = xcrealloc (debug_info_p
->loc_offsets
,
1230 max
, sizeof (*debug_info_p
->loc_offsets
));
1231 debug_info_p
->have_frame_base
1232 = xcrealloc (debug_info_p
->have_frame_base
,
1233 max
, sizeof (*debug_info_p
->have_frame_base
));
1234 debug_info_p
->max_loc_offsets
= max
;
1236 debug_info_p
->loc_offsets
[num
] = uvalue
;
1237 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1238 debug_info_p
->num_loc_offsets
++;
1243 if (need_base_address
)
1244 debug_info_p
->base_address
= uvalue
;
1248 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1250 /* Process range list. */
1251 unsigned int max
= debug_info_p
->max_range_lists
;
1252 unsigned int num
= debug_info_p
->num_range_lists
;
1254 if (max
== 0 || num
>= max
)
1257 debug_info_p
->range_lists
1258 = xcrealloc (debug_info_p
->range_lists
,
1259 max
, sizeof (*debug_info_p
->range_lists
));
1260 debug_info_p
->max_range_lists
= max
;
1262 debug_info_p
->range_lists
[num
] = uvalue
;
1263 debug_info_p
->num_range_lists
++;
1275 /* For some attributes we can display further information. */
1283 case DW_INL_not_inlined
:
1284 printf (_("(not inlined)"));
1286 case DW_INL_inlined
:
1287 printf (_("(inlined)"));
1289 case DW_INL_declared_not_inlined
:
1290 printf (_("(declared as inline but ignored)"));
1292 case DW_INL_declared_inlined
:
1293 printf (_("(declared as inline and inlined)"));
1296 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1301 case DW_AT_language
:
1304 /* Ordered by the numeric value of these constants. */
1305 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1306 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1307 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1308 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1309 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1310 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1311 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1312 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1313 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1314 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1315 /* DWARF 2.1 values. */
1316 case DW_LANG_Java
: printf ("(Java)"); break;
1317 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1318 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1319 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1320 /* DWARF 3 values. */
1321 case DW_LANG_PLI
: printf ("(PLI)"); break;
1322 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1323 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1324 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1325 case DW_LANG_D
: printf ("(D)"); break;
1326 /* MIPS extension. */
1327 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1328 /* UPC extension. */
1329 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1331 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1332 printf ("(implementation defined: %lx)", uvalue
);
1334 printf ("(Unknown: %lx)", uvalue
);
1339 case DW_AT_encoding
:
1342 case DW_ATE_void
: printf ("(void)"); break;
1343 case DW_ATE_address
: printf ("(machine address)"); break;
1344 case DW_ATE_boolean
: printf ("(boolean)"); break;
1345 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1346 case DW_ATE_float
: printf ("(float)"); break;
1347 case DW_ATE_signed
: printf ("(signed)"); break;
1348 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1349 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1350 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1351 /* DWARF 2.1 values: */
1352 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1353 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1354 /* DWARF 3 values: */
1355 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1356 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1357 case DW_ATE_edited
: printf ("(edited)"); break;
1358 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1359 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1360 /* HP extensions: */
1361 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1362 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1363 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1364 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1365 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1366 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1367 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1370 if (uvalue
>= DW_ATE_lo_user
1371 && uvalue
<= DW_ATE_hi_user
)
1372 printf ("(user defined type)");
1374 printf ("(unknown type)");
1379 case DW_AT_accessibility
:
1382 case DW_ACCESS_public
: printf ("(public)"); break;
1383 case DW_ACCESS_protected
: printf ("(protected)"); break;
1384 case DW_ACCESS_private
: printf ("(private)"); break;
1386 printf ("(unknown accessibility)");
1391 case DW_AT_visibility
:
1394 case DW_VIS_local
: printf ("(local)"); break;
1395 case DW_VIS_exported
: printf ("(exported)"); break;
1396 case DW_VIS_qualified
: printf ("(qualified)"); break;
1397 default: printf ("(unknown visibility)"); break;
1401 case DW_AT_virtuality
:
1404 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1405 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1406 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1407 default: printf ("(unknown virtuality)"); break;
1411 case DW_AT_identifier_case
:
1414 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1415 case DW_ID_up_case
: printf ("(up_case)"); break;
1416 case DW_ID_down_case
: printf ("(down_case)"); break;
1417 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1418 default: printf ("(unknown case)"); break;
1422 case DW_AT_calling_convention
:
1425 case DW_CC_normal
: printf ("(normal)"); break;
1426 case DW_CC_program
: printf ("(program)"); break;
1427 case DW_CC_nocall
: printf ("(nocall)"); break;
1429 if (uvalue
>= DW_CC_lo_user
1430 && uvalue
<= DW_CC_hi_user
)
1431 printf ("(user defined)");
1433 printf ("(unknown convention)");
1437 case DW_AT_ordering
:
1440 case -1: printf ("(undefined)"); break;
1441 case 0: printf ("(row major)"); break;
1442 case 1: printf ("(column major)"); break;
1446 case DW_AT_frame_base
:
1447 have_frame_base
= 1;
1448 case DW_AT_location
:
1449 case DW_AT_string_length
:
1450 case DW_AT_return_addr
:
1451 case DW_AT_data_member_location
:
1452 case DW_AT_vtable_elem_location
:
1454 case DW_AT_static_link
:
1455 case DW_AT_use_location
:
1456 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1457 printf (_("(location list)"));
1459 case DW_AT_allocated
:
1460 case DW_AT_associated
:
1461 case DW_AT_data_location
:
1463 case DW_AT_upper_bound
:
1464 case DW_AT_lower_bound
:
1467 int need_frame_base
;
1470 need_frame_base
= decode_location_expression (block_start
,
1475 if (need_frame_base
&& !have_frame_base
)
1476 printf (_(" [without DW_AT_frame_base]"));
1482 unsigned long abbrev_number
;
1483 abbrev_entry
* entry
;
1485 if (form
== DW_FORM_ref1
1486 || form
== DW_FORM_ref2
1487 || form
== DW_FORM_ref4
)
1488 uvalue
+= cu_offset
;
1490 abbrev_number
= read_leb128 (section_start
+ uvalue
, NULL
, 0);
1492 printf ("[Abbrev Number: %ld", abbrev_number
);
1493 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
1494 if (entry
->entry
== abbrev_number
)
1497 printf (" (%s)", get_TAG_name (entry
->tag
));
1510 get_AT_name (unsigned long attribute
)
1514 case DW_AT_sibling
: return "DW_AT_sibling";
1515 case DW_AT_location
: return "DW_AT_location";
1516 case DW_AT_name
: return "DW_AT_name";
1517 case DW_AT_ordering
: return "DW_AT_ordering";
1518 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1519 case DW_AT_byte_size
: return "DW_AT_byte_size";
1520 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1521 case DW_AT_bit_size
: return "DW_AT_bit_size";
1522 case DW_AT_element_list
: return "DW_AT_element_list";
1523 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1524 case DW_AT_low_pc
: return "DW_AT_low_pc";
1525 case DW_AT_high_pc
: return "DW_AT_high_pc";
1526 case DW_AT_language
: return "DW_AT_language";
1527 case DW_AT_member
: return "DW_AT_member";
1528 case DW_AT_discr
: return "DW_AT_discr";
1529 case DW_AT_discr_value
: return "DW_AT_discr_value";
1530 case DW_AT_visibility
: return "DW_AT_visibility";
1531 case DW_AT_import
: return "DW_AT_import";
1532 case DW_AT_string_length
: return "DW_AT_string_length";
1533 case DW_AT_common_reference
: return "DW_AT_common_reference";
1534 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1535 case DW_AT_const_value
: return "DW_AT_const_value";
1536 case DW_AT_containing_type
: return "DW_AT_containing_type";
1537 case DW_AT_default_value
: return "DW_AT_default_value";
1538 case DW_AT_inline
: return "DW_AT_inline";
1539 case DW_AT_is_optional
: return "DW_AT_is_optional";
1540 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1541 case DW_AT_producer
: return "DW_AT_producer";
1542 case DW_AT_prototyped
: return "DW_AT_prototyped";
1543 case DW_AT_return_addr
: return "DW_AT_return_addr";
1544 case DW_AT_start_scope
: return "DW_AT_start_scope";
1545 case DW_AT_stride_size
: return "DW_AT_stride_size";
1546 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1547 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1548 case DW_AT_accessibility
: return "DW_AT_accessibility";
1549 case DW_AT_address_class
: return "DW_AT_address_class";
1550 case DW_AT_artificial
: return "DW_AT_artificial";
1551 case DW_AT_base_types
: return "DW_AT_base_types";
1552 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1553 case DW_AT_count
: return "DW_AT_count";
1554 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1555 case DW_AT_decl_column
: return "DW_AT_decl_column";
1556 case DW_AT_decl_file
: return "DW_AT_decl_file";
1557 case DW_AT_decl_line
: return "DW_AT_decl_line";
1558 case DW_AT_declaration
: return "DW_AT_declaration";
1559 case DW_AT_discr_list
: return "DW_AT_discr_list";
1560 case DW_AT_encoding
: return "DW_AT_encoding";
1561 case DW_AT_external
: return "DW_AT_external";
1562 case DW_AT_frame_base
: return "DW_AT_frame_base";
1563 case DW_AT_friend
: return "DW_AT_friend";
1564 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1565 case DW_AT_macro_info
: return "DW_AT_macro_info";
1566 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1567 case DW_AT_priority
: return "DW_AT_priority";
1568 case DW_AT_segment
: return "DW_AT_segment";
1569 case DW_AT_specification
: return "DW_AT_specification";
1570 case DW_AT_static_link
: return "DW_AT_static_link";
1571 case DW_AT_type
: return "DW_AT_type";
1572 case DW_AT_use_location
: return "DW_AT_use_location";
1573 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1574 case DW_AT_virtuality
: return "DW_AT_virtuality";
1575 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1576 /* DWARF 2.1 values. */
1577 case DW_AT_allocated
: return "DW_AT_allocated";
1578 case DW_AT_associated
: return "DW_AT_associated";
1579 case DW_AT_data_location
: return "DW_AT_data_location";
1580 case DW_AT_stride
: return "DW_AT_stride";
1581 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1582 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1583 case DW_AT_extension
: return "DW_AT_extension";
1584 case DW_AT_ranges
: return "DW_AT_ranges";
1585 case DW_AT_trampoline
: return "DW_AT_trampoline";
1586 case DW_AT_call_column
: return "DW_AT_call_column";
1587 case DW_AT_call_file
: return "DW_AT_call_file";
1588 case DW_AT_call_line
: return "DW_AT_call_line";
1589 case DW_AT_description
: return "DW_AT_description";
1590 case DW_AT_binary_scale
: return "DW_AT_binary_scale";
1591 case DW_AT_decimal_scale
: return "DW_AT_decimal_scale";
1592 case DW_AT_small
: return "DW_AT_small";
1593 case DW_AT_decimal_sign
: return "DW_AT_decimal_sign";
1594 case DW_AT_digit_count
: return "DW_AT_digit_count";
1595 case DW_AT_picture_string
: return "DW_AT_picture_string";
1596 case DW_AT_mutable
: return "DW_AT_mutable";
1597 case DW_AT_threads_scaled
: return "DW_AT_threads_scaled";
1598 case DW_AT_explicit
: return "DW_AT_explicit";
1599 case DW_AT_object_pointer
: return "DW_AT_object_pointer";
1600 case DW_AT_endianity
: return "DW_AT_endianity";
1601 case DW_AT_elemental
: return "DW_AT_elemental";
1602 case DW_AT_pure
: return "DW_AT_pure";
1603 case DW_AT_recursive
: return "DW_AT_recursive";
1605 /* HP and SGI/MIPS extensions. */
1606 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1607 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1608 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1609 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1610 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
1611 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1612 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1613 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1614 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1615 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1617 /* HP Extensions. */
1618 case DW_AT_HP_block_index
: return "DW_AT_HP_block_index";
1619 case DW_AT_HP_actuals_stmt_list
: return "DW_AT_HP_actuals_stmt_list";
1620 case DW_AT_HP_proc_per_section
: return "DW_AT_HP_proc_per_section";
1621 case DW_AT_HP_raw_data_ptr
: return "DW_AT_HP_raw_data_ptr";
1622 case DW_AT_HP_pass_by_reference
: return "DW_AT_HP_pass_by_reference";
1623 case DW_AT_HP_opt_level
: return "DW_AT_HP_opt_level";
1624 case DW_AT_HP_prof_version_id
: return "DW_AT_HP_prof_version_id";
1625 case DW_AT_HP_opt_flags
: return "DW_AT_HP_opt_flags";
1626 case DW_AT_HP_cold_region_low_pc
: return "DW_AT_HP_cold_region_low_pc";
1627 case DW_AT_HP_cold_region_high_pc
: return "DW_AT_HP_cold_region_high_pc";
1628 case DW_AT_HP_all_variables_modifiable
: return "DW_AT_HP_all_variables_modifiable";
1629 case DW_AT_HP_linkage_name
: return "DW_AT_HP_linkage_name";
1630 case DW_AT_HP_prof_flags
: return "DW_AT_HP_prof_flags";
1632 /* One value is shared by the MIPS and HP extensions: */
1633 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1635 /* GNU extensions. */
1636 case DW_AT_sf_names
: return "DW_AT_sf_names";
1637 case DW_AT_src_info
: return "DW_AT_src_info";
1638 case DW_AT_mac_info
: return "DW_AT_mac_info";
1639 case DW_AT_src_coords
: return "DW_AT_src_coords";
1640 case DW_AT_body_begin
: return "DW_AT_body_begin";
1641 case DW_AT_body_end
: return "DW_AT_body_end";
1642 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1644 /* UPC extension. */
1645 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1647 /* PGI (STMicroelectronics) extensions. */
1648 case DW_AT_PGI_lbase
: return "DW_AT_PGI_lbase";
1649 case DW_AT_PGI_soffset
: return "DW_AT_PGI_soffset";
1650 case DW_AT_PGI_lstride
: return "DW_AT_PGI_lstride";
1654 static char buffer
[100];
1656 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1663 static unsigned char *
1664 read_and_display_attr (unsigned long attribute
,
1666 unsigned char * data
,
1667 unsigned long cu_offset
,
1668 unsigned long pointer_size
,
1669 unsigned long offset_size
,
1671 debug_info
* debug_info_p
,
1673 unsigned char * section_start
)
1676 printf (" %-18s:", get_AT_name (attribute
));
1677 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1678 pointer_size
, offset_size
,
1679 dwarf_version
, debug_info_p
,
1680 do_loc
, section_start
);
1687 /* Process the contents of a .debug_info section. If do_loc is non-zero
1688 then we are scanning for location lists and we do not want to display
1689 anything to the user. */
1692 process_debug_info (struct dwarf_section
*section
, void *file
,
1695 unsigned char *start
= section
->start
;
1696 unsigned char *end
= start
+ section
->size
;
1697 unsigned char *section_begin
;
1699 unsigned int num_units
= 0;
1701 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1702 && num_debug_info_entries
== 0)
1704 unsigned long length
;
1706 /* First scan the section to get the number of comp units. */
1707 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1710 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1711 will be the length. For a 64-bit DWARF section, it'll be
1712 the escape code 0xffffffff followed by an 8 byte length. */
1713 length
= byte_get (section_begin
, 4);
1715 if (length
== 0xffffffff)
1717 length
= byte_get (section_begin
+ 4, 8);
1718 section_begin
+= length
+ 12;
1720 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
1722 warn (_("Reserved length value (%lx) found in section %s\n"), length
, section
->name
);
1726 section_begin
+= length
+ 4;
1728 /* Negative values are illegal, they may even cause infinite
1729 looping. This can happen if we can't accurately apply
1730 relocations to an object file. */
1731 if ((signed long) length
<= 0)
1733 warn (_("Corrupt unit length (%lx) found in section %s\n"), length
, section
->name
);
1740 error (_("No comp units in %s section ?"), section
->name
);
1744 /* Then allocate an array to hold the information. */
1745 debug_information
= cmalloc (num_units
,
1746 sizeof (* debug_information
));
1747 if (debug_information
== NULL
)
1749 error (_("Not enough memory for a debug info array of %u entries"),
1757 printf (_("The section %s contains:\n\n"), section
->name
);
1759 load_debug_section (str
, file
);
1762 load_debug_section (abbrev
, file
);
1763 if (debug_displays
[abbrev
].section
.start
== NULL
)
1765 warn (_("Unable to locate %s section!\n"),
1766 debug_displays
[abbrev
].section
.name
);
1770 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1772 DWARF2_Internal_CompUnit compunit
;
1773 unsigned char *hdrptr
;
1774 unsigned char *cu_abbrev_offset_ptr
;
1775 unsigned char *tags
;
1777 unsigned long cu_offset
;
1779 int initial_length_size
;
1783 compunit
.cu_length
= byte_get (hdrptr
, 4);
1786 if (compunit
.cu_length
== 0xffffffff)
1788 compunit
.cu_length
= byte_get (hdrptr
, 8);
1791 initial_length_size
= 12;
1796 initial_length_size
= 4;
1799 compunit
.cu_version
= byte_get (hdrptr
, 2);
1802 cu_offset
= start
- section_begin
;
1804 cu_abbrev_offset_ptr
= hdrptr
;
1805 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
1806 hdrptr
+= offset_size
;
1808 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
1810 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1811 && num_debug_info_entries
== 0)
1813 debug_information
[unit
].cu_offset
= cu_offset
;
1814 debug_information
[unit
].pointer_size
1815 = compunit
.cu_pointer_size
;
1816 debug_information
[unit
].base_address
= 0;
1817 debug_information
[unit
].loc_offsets
= NULL
;
1818 debug_information
[unit
].have_frame_base
= NULL
;
1819 debug_information
[unit
].max_loc_offsets
= 0;
1820 debug_information
[unit
].num_loc_offsets
= 0;
1821 debug_information
[unit
].range_lists
= NULL
;
1822 debug_information
[unit
].max_range_lists
= 0;
1823 debug_information
[unit
].num_range_lists
= 0;
1828 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
1829 printf (_(" Length: 0x%lx (%s)\n"), compunit
.cu_length
,
1830 initial_length_size
== 8 ? "64-bit" : "32-bit");
1831 printf (_(" Version: %d\n"), compunit
.cu_version
);
1832 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
1833 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
1836 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
1839 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1840 cu_offset
, compunit
.cu_length
);
1844 start
+= compunit
.cu_length
+ initial_length_size
;
1846 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
1848 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1849 cu_offset
, compunit
.cu_version
);
1855 /* Process the abbrevs used by this compilation unit. DWARF
1856 sections under Mach-O have non-zero addresses. */
1857 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev
].section
.size
)
1858 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1859 (unsigned long) compunit
.cu_abbrev_offset
,
1860 (unsigned long) debug_displays
[abbrev
].section
.size
);
1862 process_abbrev_section
1863 ((unsigned char *) debug_displays
[abbrev
].section
.start
1864 + compunit
.cu_abbrev_offset
- debug_displays
[abbrev
].section
.address
,
1865 (unsigned char *) debug_displays
[abbrev
].section
.start
1866 + debug_displays
[abbrev
].section
.size
);
1869 while (tags
< start
)
1871 unsigned int bytes_read
;
1872 unsigned long abbrev_number
;
1873 unsigned long die_offset
;
1874 abbrev_entry
*entry
;
1877 die_offset
= tags
- section_begin
;
1879 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
1882 /* A null DIE marks the end of a list of siblings. */
1883 if (abbrev_number
== 0)
1888 static unsigned num_bogus_warns
= 0;
1890 if (num_bogus_warns
< 3)
1892 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1895 if (num_bogus_warns
== 3)
1896 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1903 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1904 level
, die_offset
, abbrev_number
);
1906 /* Scan through the abbreviation list until we reach the
1908 for (entry
= first_abbrev
;
1909 entry
&& entry
->entry
!= abbrev_number
;
1910 entry
= entry
->next
)
1920 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
1921 die_offset
, abbrev_number
);
1926 printf (_(" (%s)\n"), get_TAG_name (entry
->tag
));
1931 need_base_address
= 0;
1933 case DW_TAG_compile_unit
:
1934 need_base_address
= 1;
1936 case DW_TAG_entry_point
:
1937 case DW_TAG_subprogram
:
1938 need_base_address
= 0;
1939 /* Assuming that there is no DW_AT_frame_base. */
1940 have_frame_base
= 0;
1944 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
1947 /* Show the offset from where the tag was extracted. */
1948 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
1950 tags
= read_and_display_attr (attr
->attribute
,
1953 compunit
.cu_pointer_size
,
1955 compunit
.cu_version
,
1956 debug_information
+ unit
,
1957 do_loc
, section
->start
);
1960 if (entry
->children
)
1965 /* Set num_debug_info_entries here so that it can be used to check if
1966 we need to process .debug_loc and .debug_ranges sections. */
1967 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1968 && num_debug_info_entries
== 0)
1969 num_debug_info_entries
= num_units
;
1979 /* Locate and scan the .debug_info section in the file and record the pointer
1980 sizes and offsets for the compilation units in it. Usually an executable
1981 will have just one pointer size, but this is not guaranteed, and so we try
1982 not to make any assumptions. Returns zero upon failure, or the number of
1983 compilation units upon success. */
1986 load_debug_info (void * file
)
1988 /* Reset the last pointer size so that we can issue correct error
1989 messages if we are displaying the contents of more than one section. */
1990 last_pointer_size
= 0;
1991 warned_about_missing_comp_units
= FALSE
;
1993 /* If we have already tried and failed to load the .debug_info
1994 section then do not bother to repear the task. */
1995 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
1998 /* If we already have the information there is nothing else to do. */
1999 if (num_debug_info_entries
> 0)
2000 return num_debug_info_entries
;
2002 if (load_debug_section (info
, file
)
2003 && process_debug_info (&debug_displays
[info
].section
, file
, 1))
2004 return num_debug_info_entries
;
2006 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2011 display_debug_lines (struct dwarf_section
*section
, void *file
)
2013 unsigned char *start
= section
->start
;
2014 unsigned char *data
= start
;
2015 unsigned char *end
= start
+ section
->size
;
2017 printf (_("\nDump of debug contents of section %s:\n\n"),
2020 if (load_debug_info (file
) == 0)
2022 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2029 DWARF2_Internal_LineInfo info
;
2030 unsigned char *standard_opcodes
;
2031 unsigned char *end_of_sequence
;
2032 unsigned char *hdrptr
;
2033 unsigned long hdroff
;
2034 int initial_length_size
;
2039 hdroff
= hdrptr
- start
;
2041 /* Check the length of the block. */
2042 info
.li_length
= byte_get (hdrptr
, 4);
2045 if (info
.li_length
== 0xffffffff)
2047 /* This section is 64-bit DWARF 3. */
2048 info
.li_length
= byte_get (hdrptr
, 8);
2051 initial_length_size
= 12;
2056 initial_length_size
= 4;
2059 if (info
.li_length
+ initial_length_size
> section
->size
)
2062 (_("The line info appears to be corrupt - the section is too small\n"));
2066 /* Check its version number. */
2067 info
.li_version
= byte_get (hdrptr
, 2);
2069 if (info
.li_version
!= 2 && info
.li_version
!= 3)
2071 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2075 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2076 hdrptr
+= offset_size
;
2077 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
2079 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2081 info
.li_line_base
= byte_get (hdrptr
, 1);
2083 info
.li_line_range
= byte_get (hdrptr
, 1);
2085 info
.li_opcode_base
= byte_get (hdrptr
, 1);
2088 /* Sign extend the line base field. */
2089 info
.li_line_base
<<= 24;
2090 info
.li_line_base
>>= 24;
2092 printf (_(" Offset: 0x%lx\n"), hdroff
);
2093 printf (_(" Length: %ld\n"), info
.li_length
);
2094 printf (_(" DWARF Version: %d\n"), info
.li_version
);
2095 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
2096 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
2097 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
2098 printf (_(" Line Base: %d\n"), info
.li_line_base
);
2099 printf (_(" Line Range: %d\n"), info
.li_line_range
);
2100 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
2102 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
2104 reset_state_machine (info
.li_default_is_stmt
);
2106 /* Display the contents of the Opcodes table. */
2107 standard_opcodes
= hdrptr
;
2109 printf (_("\n Opcodes:\n"));
2111 for (i
= 1; i
< info
.li_opcode_base
; i
++)
2112 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2114 /* Display the contents of the Directory table. */
2115 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
2118 printf (_("\n The Directory Table is empty.\n"));
2121 printf (_("\n The Directory Table:\n"));
2125 printf (_(" %s\n"), data
);
2127 data
+= strlen ((char *) data
) + 1;
2131 /* Skip the NUL at the end of the table. */
2134 /* Display the contents of the File Name table. */
2136 printf (_("\n The File Name Table is empty.\n"));
2139 printf (_("\n The File Name Table:\n"));
2140 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2144 unsigned char *name
;
2145 unsigned int bytes_read
;
2147 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
2150 data
+= strlen ((char *) data
) + 1;
2152 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2154 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2156 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2158 printf (_("%s\n"), name
);
2162 /* Skip the NUL at the end of the table. */
2165 /* Now display the statements. */
2166 printf (_("\n Line Number Statements:\n"));
2168 while (data
< end_of_sequence
)
2170 unsigned char op_code
;
2172 unsigned long int uladv
;
2173 unsigned int bytes_read
;
2177 if (op_code
>= info
.li_opcode_base
)
2179 op_code
-= info
.li_opcode_base
;
2180 uladv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
2181 state_machine_regs
.address
+= uladv
;
2182 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2183 op_code
, uladv
, state_machine_regs
.address
);
2184 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
2185 state_machine_regs
.line
+= adv
;
2186 printf (_(" and Line by %d to %d\n"),
2187 adv
, state_machine_regs
.line
);
2189 else switch (op_code
)
2191 case DW_LNS_extended_op
:
2192 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
);
2196 printf (_(" Copy\n"));
2199 case DW_LNS_advance_pc
:
2200 uladv
= read_leb128 (data
, & bytes_read
, 0);
2201 uladv
*= info
.li_min_insn_length
;
2203 state_machine_regs
.address
+= uladv
;
2204 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
2205 state_machine_regs
.address
);
2208 case DW_LNS_advance_line
:
2209 adv
= read_leb128 (data
, & bytes_read
, 1);
2211 state_machine_regs
.line
+= adv
;
2212 printf (_(" Advance Line by %d to %d\n"), adv
,
2213 state_machine_regs
.line
);
2216 case DW_LNS_set_file
:
2217 adv
= read_leb128 (data
, & bytes_read
, 0);
2219 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2221 state_machine_regs
.file
= adv
;
2224 case DW_LNS_set_column
:
2225 uladv
= read_leb128 (data
, & bytes_read
, 0);
2227 printf (_(" Set column to %lu\n"), uladv
);
2228 state_machine_regs
.column
= uladv
;
2231 case DW_LNS_negate_stmt
:
2232 adv
= state_machine_regs
.is_stmt
;
2234 printf (_(" Set is_stmt to %d\n"), adv
);
2235 state_machine_regs
.is_stmt
= adv
;
2238 case DW_LNS_set_basic_block
:
2239 printf (_(" Set basic block\n"));
2240 state_machine_regs
.basic_block
= 1;
2243 case DW_LNS_const_add_pc
:
2244 uladv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
2245 * info
.li_min_insn_length
);
2246 state_machine_regs
.address
+= uladv
;
2247 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2248 state_machine_regs
.address
);
2251 case DW_LNS_fixed_advance_pc
:
2252 uladv
= byte_get (data
, 2);
2254 state_machine_regs
.address
+= uladv
;
2255 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2256 uladv
, state_machine_regs
.address
);
2259 case DW_LNS_set_prologue_end
:
2260 printf (_(" Set prologue_end to true\n"));
2263 case DW_LNS_set_epilogue_begin
:
2264 printf (_(" Set epilogue_begin to true\n"));
2267 case DW_LNS_set_isa
:
2268 uladv
= read_leb128 (data
, & bytes_read
, 0);
2270 printf (_(" Set ISA to %lu\n"), uladv
);
2274 printf (_(" Unknown opcode %d with operands: "), op_code
);
2276 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2278 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2279 i
== 1 ? "" : ", ");
2293 display_debug_pubnames (struct dwarf_section
*section
,
2294 void *file ATTRIBUTE_UNUSED
)
2296 DWARF2_Internal_PubNames pubnames
;
2297 unsigned char *start
= section
->start
;
2298 unsigned char *end
= start
+ section
->size
;
2300 printf (_("Contents of the %s section:\n\n"), section
->name
);
2304 unsigned char *data
;
2305 unsigned long offset
;
2306 int offset_size
, initial_length_size
;
2310 pubnames
.pn_length
= byte_get (data
, 4);
2312 if (pubnames
.pn_length
== 0xffffffff)
2314 pubnames
.pn_length
= byte_get (data
, 8);
2317 initial_length_size
= 12;
2322 initial_length_size
= 4;
2325 pubnames
.pn_version
= byte_get (data
, 2);
2327 pubnames
.pn_offset
= byte_get (data
, offset_size
);
2328 data
+= offset_size
;
2329 pubnames
.pn_size
= byte_get (data
, offset_size
);
2330 data
+= offset_size
;
2332 start
+= pubnames
.pn_length
+ initial_length_size
;
2334 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
2336 static int warned
= 0;
2340 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2347 printf (_(" Length: %ld\n"),
2348 pubnames
.pn_length
);
2349 printf (_(" Version: %d\n"),
2350 pubnames
.pn_version
);
2351 printf (_(" Offset into .debug_info section: %ld\n"),
2352 pubnames
.pn_offset
);
2353 printf (_(" Size of area in .debug_info section: %ld\n"),
2356 printf (_("\n Offset\tName\n"));
2360 offset
= byte_get (data
, offset_size
);
2364 data
+= offset_size
;
2365 printf (" %-6ld\t\t%s\n", offset
, data
);
2366 data
+= strlen ((char *) data
) + 1;
2369 while (offset
!= 0);
2377 display_debug_macinfo (struct dwarf_section
*section
,
2378 void *file ATTRIBUTE_UNUSED
)
2380 unsigned char *start
= section
->start
;
2381 unsigned char *end
= start
+ section
->size
;
2382 unsigned char *curr
= start
;
2383 unsigned int bytes_read
;
2384 enum dwarf_macinfo_record_type op
;
2386 printf (_("Contents of the %s section:\n\n"), section
->name
);
2390 unsigned int lineno
;
2398 case DW_MACINFO_start_file
:
2400 unsigned int filenum
;
2402 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2404 filenum
= read_leb128 (curr
, & bytes_read
, 0);
2407 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2412 case DW_MACINFO_end_file
:
2413 printf (_(" DW_MACINFO_end_file\n"));
2416 case DW_MACINFO_define
:
2417 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2419 string
= (char *) curr
;
2420 curr
+= strlen (string
) + 1;
2421 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2425 case DW_MACINFO_undef
:
2426 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2428 string
= (char *) curr
;
2429 curr
+= strlen (string
) + 1;
2430 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2434 case DW_MACINFO_vendor_ext
:
2436 unsigned int constant
;
2438 constant
= read_leb128 (curr
, & bytes_read
, 0);
2440 string
= (char *) curr
;
2441 curr
+= strlen (string
) + 1;
2442 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2453 display_debug_abbrev (struct dwarf_section
*section
,
2454 void *file ATTRIBUTE_UNUSED
)
2456 abbrev_entry
*entry
;
2457 unsigned char *start
= section
->start
;
2458 unsigned char *end
= start
+ section
->size
;
2460 printf (_("Contents of the %s section:\n\n"), section
->name
);
2466 start
= process_abbrev_section (start
, end
);
2468 if (first_abbrev
== NULL
)
2471 printf (_(" Number TAG\n"));
2473 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
2477 printf (_(" %ld %s [%s]\n"),
2479 get_TAG_name (entry
->tag
),
2480 entry
->children
? _("has children") : _("no children"));
2482 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2483 printf (_(" %-18s %s\n"),
2484 get_AT_name (attr
->attribute
),
2485 get_FORM_name (attr
->form
));
2496 display_debug_loc (struct dwarf_section
*section
, void *file
)
2498 unsigned char *start
= section
->start
;
2499 unsigned char *section_end
;
2500 unsigned long bytes
;
2501 unsigned char *section_begin
= start
;
2502 unsigned int num_loc_list
= 0;
2503 unsigned long last_offset
= 0;
2504 unsigned int first
= 0;
2507 int seen_first_offset
= 0;
2508 int use_debug_info
= 1;
2509 unsigned char *next
;
2511 bytes
= section
->size
;
2512 section_end
= start
+ bytes
;
2516 printf (_("\nThe %s section is empty.\n"), section
->name
);
2520 if (load_debug_info (file
) == 0)
2522 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2527 /* Check the order of location list in .debug_info section. If
2528 offsets of location lists are in the ascending order, we can
2529 use `debug_information' directly. */
2530 for (i
= 0; i
< num_debug_info_entries
; i
++)
2534 num
= debug_information
[i
].num_loc_offsets
;
2535 num_loc_list
+= num
;
2537 /* Check if we can use `debug_information' directly. */
2538 if (use_debug_info
&& num
!= 0)
2540 if (!seen_first_offset
)
2542 /* This is the first location list. */
2543 last_offset
= debug_information
[i
].loc_offsets
[0];
2545 seen_first_offset
= 1;
2551 for (; j
< num
; j
++)
2554 debug_information
[i
].loc_offsets
[j
])
2559 last_offset
= debug_information
[i
].loc_offsets
[j
];
2564 if (!use_debug_info
)
2565 /* FIXME: Should we handle this case? */
2566 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2568 if (!seen_first_offset
)
2569 error (_("No location lists in .debug_info section!\n"));
2571 /* DWARF sections under Mach-O have non-zero addresses. */
2572 if (debug_information
[first
].num_loc_offsets
> 0
2573 && debug_information
[first
].loc_offsets
[0] != section
->address
)
2574 warn (_("Location lists in %s section start at 0x%lx\n"),
2575 section
->name
, debug_information
[first
].loc_offsets
[0]);
2577 printf (_("Contents of the %s section:\n\n"), section
->name
);
2578 printf (_(" Offset Begin End Expression\n"));
2580 seen_first_offset
= 0;
2581 for (i
= first
; i
< num_debug_info_entries
; i
++)
2583 unsigned long begin
;
2585 unsigned short length
;
2586 unsigned long offset
;
2587 unsigned int pointer_size
;
2588 unsigned long cu_offset
;
2589 unsigned long base_address
;
2590 int need_frame_base
;
2593 pointer_size
= debug_information
[i
].pointer_size
;
2594 cu_offset
= debug_information
[i
].cu_offset
;
2596 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
2598 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
2599 /* DWARF sections under Mach-O have non-zero addresses. */
2600 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
2601 next
= section_begin
+ offset
;
2602 base_address
= debug_information
[i
].base_address
;
2604 if (!seen_first_offset
)
2605 seen_first_offset
= 1;
2609 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2610 (long)(start
- section_begin
), (long)(next
- section_begin
));
2611 else if (start
> next
)
2612 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2613 (long)(start
- section_begin
), (long)(next
- section_begin
));
2617 if (offset
>= bytes
)
2619 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2626 if (start
+ 2 * pointer_size
> section_end
)
2628 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2633 begin
= byte_get (start
, pointer_size
);
2634 start
+= pointer_size
;
2635 end
= byte_get (start
, pointer_size
);
2636 start
+= pointer_size
;
2638 if (begin
== 0 && end
== 0)
2640 printf (_(" %8.8lx <End of list>\n"), offset
);
2644 /* Check base address specifiers. */
2645 if (begin
== -1UL && end
!= -1UL)
2648 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2649 offset
, begin
, end
);
2653 if (start
+ 2 > section_end
)
2655 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2660 length
= byte_get (start
, 2);
2663 if (start
+ length
> section_end
)
2665 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2670 printf (" %8.8lx %8.8lx %8.8lx (",
2671 offset
, begin
+ base_address
, end
+ base_address
);
2672 need_frame_base
= decode_location_expression (start
,
2678 if (need_frame_base
&& !has_frame_base
)
2679 printf (_(" [without DW_AT_frame_base]"));
2682 fputs (_(" (start == end)"), stdout
);
2683 else if (begin
> end
)
2684 fputs (_(" (start > end)"), stdout
);
2693 if (start
< section_end
)
2694 warn (_("There are %ld unused bytes at the end of section %s\n"),
2695 (long) (section_end
- start
), section
->name
);
2700 display_debug_str (struct dwarf_section
*section
,
2701 void *file ATTRIBUTE_UNUSED
)
2703 unsigned char *start
= section
->start
;
2704 unsigned long bytes
= section
->size
;
2705 dwarf_vma addr
= section
->address
;
2709 printf (_("\nThe %s section is empty.\n"), section
->name
);
2713 printf (_("Contents of the %s section:\n\n"), section
->name
);
2721 lbytes
= (bytes
> 16 ? 16 : bytes
);
2723 printf (" 0x%8.8lx ", (unsigned long) addr
);
2725 for (j
= 0; j
< 16; j
++)
2728 printf ("%2.2x", start
[j
]);
2736 for (j
= 0; j
< lbytes
; j
++)
2739 if (k
>= ' ' && k
< 0x80)
2758 display_debug_info (struct dwarf_section
*section
, void *file
)
2760 return process_debug_info (section
, file
, 0);
2765 display_debug_aranges (struct dwarf_section
*section
,
2766 void *file ATTRIBUTE_UNUSED
)
2768 unsigned char *start
= section
->start
;
2769 unsigned char *end
= start
+ section
->size
;
2771 printf (_("The section %s contains:\n\n"), section
->name
);
2775 unsigned char *hdrptr
;
2776 DWARF2_Internal_ARange arange
;
2777 unsigned char *ranges
;
2778 unsigned long length
;
2779 unsigned long address
;
2780 unsigned char address_size
;
2783 int initial_length_size
;
2787 arange
.ar_length
= byte_get (hdrptr
, 4);
2790 if (arange
.ar_length
== 0xffffffff)
2792 arange
.ar_length
= byte_get (hdrptr
, 8);
2795 initial_length_size
= 12;
2800 initial_length_size
= 4;
2803 arange
.ar_version
= byte_get (hdrptr
, 2);
2806 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
2807 hdrptr
+= offset_size
;
2809 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
2812 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
2815 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
2817 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2821 printf (_(" Length: %ld\n"), arange
.ar_length
);
2822 printf (_(" Version: %d\n"), arange
.ar_version
);
2823 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
2824 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
2825 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
2827 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
2829 /* The DWARF spec does not require that the address size be a power
2830 of two, but we do. This will have to change if we ever encounter
2831 an uneven architecture. */
2832 if ((address_size
& (address_size
- 1)) != 0)
2834 warn (_("Pointer size + Segment size is not a power of two.\n"));
2838 if (address_size
> 4)
2839 printf (_("\n Address Length\n"));
2841 printf (_("\n Address Length\n"));
2845 /* Must pad to an alignment boundary that is twice the address size. */
2846 excess
= (hdrptr
- start
) % (2 * address_size
);
2848 ranges
+= (2 * address_size
) - excess
;
2850 start
+= arange
.ar_length
+ initial_length_size
;
2852 while (ranges
+ 2 * address_size
<= start
)
2854 address
= byte_get (ranges
, address_size
);
2856 ranges
+= address_size
;
2858 length
= byte_get (ranges
, address_size
);
2860 ranges
+= address_size
;
2862 if (address_size
> 4)
2863 printf (" 0x%16.16lx 0x%lx\n", address
, length
);
2865 printf (" 0x%8.8lx 0x%lx\n", address
, length
);
2875 display_debug_ranges (struct dwarf_section
*section
,
2876 void *file ATTRIBUTE_UNUSED
)
2878 unsigned char *start
= section
->start
;
2879 unsigned char *section_end
;
2880 unsigned long bytes
;
2881 unsigned char *section_begin
= start
;
2882 unsigned int num_range_list
= 0;
2883 unsigned long last_offset
= 0;
2884 unsigned int first
= 0;
2887 int seen_first_offset
= 0;
2888 int use_debug_info
= 1;
2889 unsigned char *next
;
2891 bytes
= section
->size
;
2892 section_end
= start
+ bytes
;
2896 printf (_("\nThe %s section is empty.\n"), section
->name
);
2900 if (load_debug_info (file
) == 0)
2902 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2907 /* Check the order of range list in .debug_info section. If
2908 offsets of range lists are in the ascending order, we can
2909 use `debug_information' directly. */
2910 for (i
= 0; i
< num_debug_info_entries
; i
++)
2914 num
= debug_information
[i
].num_range_lists
;
2915 num_range_list
+= num
;
2917 /* Check if we can use `debug_information' directly. */
2918 if (use_debug_info
&& num
!= 0)
2920 if (!seen_first_offset
)
2922 /* This is the first range list. */
2923 last_offset
= debug_information
[i
].range_lists
[0];
2925 seen_first_offset
= 1;
2931 for (; j
< num
; j
++)
2934 debug_information
[i
].range_lists
[j
])
2939 last_offset
= debug_information
[i
].range_lists
[j
];
2944 if (!use_debug_info
)
2945 /* FIXME: Should we handle this case? */
2946 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2948 if (!seen_first_offset
)
2949 error (_("No range lists in .debug_info section!\n"));
2951 /* DWARF sections under Mach-O have non-zero addresses. */
2952 if (debug_information
[first
].num_range_lists
> 0
2953 && debug_information
[first
].range_lists
[0] != section
->address
)
2954 warn (_("Range lists in %s section start at 0x%lx\n"),
2955 section
->name
, debug_information
[first
].range_lists
[0]);
2957 printf (_("Contents of the %s section:\n\n"), section
->name
);
2958 printf (_(" Offset Begin End\n"));
2960 seen_first_offset
= 0;
2961 for (i
= first
; i
< num_debug_info_entries
; i
++)
2963 unsigned long begin
;
2965 unsigned long offset
;
2966 unsigned int pointer_size
;
2967 unsigned long base_address
;
2969 pointer_size
= debug_information
[i
].pointer_size
;
2971 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
2973 /* DWARF sections under Mach-O have non-zero addresses. */
2974 offset
= debug_information
[i
].range_lists
[j
] - section
->address
;
2975 next
= section_begin
+ offset
;
2976 base_address
= debug_information
[i
].base_address
;
2978 if (!seen_first_offset
)
2979 seen_first_offset
= 1;
2983 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2984 (long)(start
- section_begin
),
2985 (long)(next
- section_begin
), section
->name
);
2986 else if (start
> next
)
2987 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2988 (long)(start
- section_begin
),
2989 (long)(next
- section_begin
), section
->name
);
2995 begin
= byte_get (start
, pointer_size
);
2996 start
+= pointer_size
;
2997 end
= byte_get (start
, pointer_size
);
2998 start
+= pointer_size
;
3000 if (begin
== 0 && end
== 0)
3002 printf (_(" %8.8lx <End of list>\n"), offset
);
3006 /* Check base address specifiers. */
3007 if (begin
== -1UL && end
!= -1UL)
3010 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
3011 offset
, begin
, end
);
3015 printf (" %8.8lx %8.8lx %8.8lx",
3016 offset
, begin
+ base_address
, end
+ base_address
);
3019 fputs (_(" (start == end)"), stdout
);
3020 else if (begin
> end
)
3021 fputs (_(" (start > end)"), stdout
);
3031 typedef struct Frame_Chunk
3033 struct Frame_Chunk
*next
;
3034 unsigned char *chunk_start
;
3036 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3037 short int *col_type
;
3040 unsigned int code_factor
;
3042 unsigned long pc_begin
;
3043 unsigned long pc_range
;
3047 unsigned char fde_encoding
;
3048 unsigned char cfa_exp
;
3052 /* A marker for a col_type that means this column was never referenced
3053 in the frame info. */
3054 #define DW_CFA_unreferenced (-1)
3057 frame_need_space (Frame_Chunk
*fc
, int reg
)
3059 int prev
= fc
->ncols
;
3061 if (reg
< fc
->ncols
)
3064 fc
->ncols
= reg
+ 1;
3065 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
3066 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
3068 while (prev
< fc
->ncols
)
3070 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
3071 fc
->col_offset
[prev
] = 0;
3077 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
3082 if (*max_regs
< fc
->ncols
)
3083 *max_regs
= fc
->ncols
;
3085 if (*need_col_headers
)
3087 *need_col_headers
= 0;
3089 printf (" LOC CFA ");
3091 for (r
= 0; r
< *max_regs
; r
++)
3092 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
3097 printf ("r%-4d", r
);
3103 printf ("%08lx ", fc
->pc_begin
);
3105 strcpy (tmp
, "exp");
3107 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
3108 printf ("%-8s ", tmp
);
3110 for (r
= 0; r
< fc
->ncols
; r
++)
3112 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
3114 switch (fc
->col_type
[r
])
3116 case DW_CFA_undefined
:
3119 case DW_CFA_same_value
:
3123 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
3125 case DW_CFA_val_offset
:
3126 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
3128 case DW_CFA_register
:
3129 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
3131 case DW_CFA_expression
:
3132 strcpy (tmp
, "exp");
3134 case DW_CFA_val_expression
:
3135 strcpy (tmp
, "vexp");
3138 strcpy (tmp
, "n/a");
3141 printf ("%-5s", tmp
);
3148 size_of_encoded_value (int encoding
)
3150 switch (encoding
& 0x7)
3153 case 0: return eh_addr_size
;
3161 get_encoded_value (unsigned char *data
, int encoding
)
3163 int size
= size_of_encoded_value (encoding
);
3165 if (encoding
& DW_EH_PE_signed
)
3166 return byte_get_signed (data
, size
);
3168 return byte_get (data
, size
);
3171 #define GET(N) byte_get (start, N); start += N
3172 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3173 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3176 display_debug_frames (struct dwarf_section
*section
,
3177 void *file ATTRIBUTE_UNUSED
)
3179 unsigned char *start
= section
->start
;
3180 unsigned char *end
= start
+ section
->size
;
3181 unsigned char *section_start
= start
;
3182 Frame_Chunk
*chunks
= 0;
3183 Frame_Chunk
*remembered_state
= 0;
3185 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
3186 unsigned int length_return
;
3189 printf (_("The section %s contains:\n"), section
->name
);
3193 unsigned char *saved_start
;
3194 unsigned char *block_end
;
3195 unsigned long length
;
3196 unsigned long cie_id
;
3199 int need_col_headers
= 1;
3200 unsigned char *augmentation_data
= NULL
;
3201 unsigned long augmentation_data_len
= 0;
3202 int encoded_ptr_size
= eh_addr_size
;
3204 int initial_length_size
;
3206 saved_start
= start
;
3207 length
= byte_get (start
, 4); start
+= 4;
3211 printf ("\n%08lx ZERO terminator\n\n",
3212 (unsigned long)(saved_start
- section_start
));
3216 if (length
== 0xffffffff)
3218 length
= byte_get (start
, 8);
3221 initial_length_size
= 12;
3226 initial_length_size
= 4;
3229 block_end
= saved_start
+ length
+ initial_length_size
;
3230 if (block_end
> end
)
3232 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3233 length
, (unsigned long)(saved_start
- section_start
));
3236 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
3238 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
3242 fc
= xmalloc (sizeof (Frame_Chunk
));
3243 memset (fc
, 0, sizeof (Frame_Chunk
));
3247 fc
->chunk_start
= saved_start
;
3249 fc
->col_type
= xmalloc (sizeof (short int));
3250 fc
->col_offset
= xmalloc (sizeof (int));
3251 frame_need_space (fc
, max_regs
- 1);
3255 fc
->augmentation
= (char *) start
;
3256 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
3258 if (fc
->augmentation
[0] == 'z')
3260 fc
->code_factor
= LEB ();
3261 fc
->data_factor
= SLEB ();
3270 augmentation_data_len
= LEB ();
3271 augmentation_data
= start
;
3272 start
+= augmentation_data_len
;
3274 else if (strcmp (fc
->augmentation
, "eh") == 0)
3276 start
+= eh_addr_size
;
3277 fc
->code_factor
= LEB ();
3278 fc
->data_factor
= SLEB ();
3290 fc
->code_factor
= LEB ();
3291 fc
->data_factor
= SLEB ();
3303 if (do_debug_frames_interp
)
3304 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3305 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3306 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
3310 printf ("\n%08lx %08lx %08lx CIE\n",
3311 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
3312 printf (" Version: %d\n", version
);
3313 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
3314 printf (" Code alignment factor: %u\n", fc
->code_factor
);
3315 printf (" Data alignment factor: %d\n", fc
->data_factor
);
3316 printf (" Return address column: %d\n", fc
->ra
);
3318 if (augmentation_data_len
)
3321 printf (" Augmentation data: ");
3322 for (i
= 0; i
< augmentation_data_len
; ++i
)
3323 printf (" %02x", augmentation_data
[i
]);
3329 if (augmentation_data_len
)
3331 unsigned char *p
, *q
;
3332 p
= (unsigned char *) fc
->augmentation
+ 1;
3333 q
= augmentation_data
;
3340 q
+= 1 + size_of_encoded_value (*q
);
3342 fc
->fde_encoding
= *q
++;
3348 if (fc
->fde_encoding
)
3349 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3352 frame_need_space (fc
, fc
->ra
);
3356 unsigned char *look_for
;
3357 static Frame_Chunk fde_fc
;
3360 memset (fc
, 0, sizeof (Frame_Chunk
));
3362 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
3364 for (cie
= chunks
; cie
; cie
= cie
->next
)
3365 if (cie
->chunk_start
== look_for
)
3370 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3371 cie_id
, (unsigned long)(saved_start
- section_start
));
3373 fc
->col_type
= xmalloc (sizeof (short int));
3374 fc
->col_offset
= xmalloc (sizeof (int));
3375 frame_need_space (fc
, max_regs
- 1);
3377 fc
->augmentation
= "";
3378 fc
->fde_encoding
= 0;
3382 fc
->ncols
= cie
->ncols
;
3383 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
3384 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
3385 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
3386 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
3387 fc
->augmentation
= cie
->augmentation
;
3388 fc
->code_factor
= cie
->code_factor
;
3389 fc
->data_factor
= cie
->data_factor
;
3390 fc
->cfa_reg
= cie
->cfa_reg
;
3391 fc
->cfa_offset
= cie
->cfa_offset
;
3393 frame_need_space (fc
, max_regs
- 1);
3394 fc
->fde_encoding
= cie
->fde_encoding
;
3397 if (fc
->fde_encoding
)
3398 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3400 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
3401 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
3402 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
3403 start
+= encoded_ptr_size
;
3404 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
3405 start
+= encoded_ptr_size
;
3407 if (cie
->augmentation
[0] == 'z')
3409 augmentation_data_len
= LEB ();
3410 augmentation_data
= start
;
3411 start
+= augmentation_data_len
;
3414 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3415 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3416 (unsigned long)(cie
->chunk_start
- section_start
),
3417 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
3418 if (! do_debug_frames_interp
&& augmentation_data_len
)
3422 printf (" Augmentation data: ");
3423 for (i
= 0; i
< augmentation_data_len
; ++i
)
3424 printf (" %02x", augmentation_data
[i
]);
3430 /* At this point, fc is the current chunk, cie (if any) is set, and
3431 we're about to interpret instructions for the chunk. */
3432 /* ??? At present we need to do this always, since this sizes the
3433 fc->col_type and fc->col_offset arrays, which we write into always.
3434 We should probably split the interpreted and non-interpreted bits
3435 into two different routines, since there's so much that doesn't
3436 really overlap between them. */
3437 if (1 || do_debug_frames_interp
)
3439 /* Start by making a pass over the chunk, allocating storage
3440 and taking note of what registers are used. */
3441 unsigned char *tmp
= start
;
3443 while (start
< block_end
)
3446 unsigned long reg
, tmp
;
3453 /* Warning: if you add any more cases to this switch, be
3454 sure to add them to the corresponding switch below. */
3457 case DW_CFA_advance_loc
:
3461 frame_need_space (fc
, opa
);
3462 fc
->col_type
[opa
] = DW_CFA_undefined
;
3464 case DW_CFA_restore
:
3465 frame_need_space (fc
, opa
);
3466 fc
->col_type
[opa
] = DW_CFA_undefined
;
3468 case DW_CFA_set_loc
:
3469 start
+= encoded_ptr_size
;
3471 case DW_CFA_advance_loc1
:
3474 case DW_CFA_advance_loc2
:
3477 case DW_CFA_advance_loc4
:
3480 case DW_CFA_offset_extended
:
3481 case DW_CFA_val_offset
:
3482 reg
= LEB (); LEB ();
3483 frame_need_space (fc
, reg
);
3484 fc
->col_type
[reg
] = DW_CFA_undefined
;
3486 case DW_CFA_restore_extended
:
3488 frame_need_space (fc
, reg
);
3489 fc
->col_type
[reg
] = DW_CFA_undefined
;
3491 case DW_CFA_undefined
:
3493 frame_need_space (fc
, reg
);
3494 fc
->col_type
[reg
] = DW_CFA_undefined
;
3496 case DW_CFA_same_value
:
3498 frame_need_space (fc
, reg
);
3499 fc
->col_type
[reg
] = DW_CFA_undefined
;
3501 case DW_CFA_register
:
3502 reg
= LEB (); LEB ();
3503 frame_need_space (fc
, reg
);
3504 fc
->col_type
[reg
] = DW_CFA_undefined
;
3506 case DW_CFA_def_cfa
:
3509 case DW_CFA_def_cfa_register
:
3512 case DW_CFA_def_cfa_offset
:
3515 case DW_CFA_def_cfa_expression
:
3519 case DW_CFA_expression
:
3520 case DW_CFA_val_expression
:
3524 frame_need_space (fc
, reg
);
3525 fc
->col_type
[reg
] = DW_CFA_undefined
;
3527 case DW_CFA_offset_extended_sf
:
3528 case DW_CFA_val_offset_sf
:
3529 reg
= LEB (); SLEB ();
3530 frame_need_space (fc
, reg
);
3531 fc
->col_type
[reg
] = DW_CFA_undefined
;
3533 case DW_CFA_def_cfa_sf
:
3536 case DW_CFA_def_cfa_offset_sf
:
3539 case DW_CFA_MIPS_advance_loc8
:
3542 case DW_CFA_GNU_args_size
:
3545 case DW_CFA_GNU_negative_offset_extended
:
3546 reg
= LEB (); LEB ();
3547 frame_need_space (fc
, reg
);
3548 fc
->col_type
[reg
] = DW_CFA_undefined
;
3557 /* Now we know what registers are used, make a second pass over
3558 the chunk, this time actually printing out the info. */
3560 while (start
< block_end
)
3563 unsigned long ul
, reg
, roffs
;
3572 /* Warning: if you add any more cases to this switch, be
3573 sure to add them to the corresponding switch above. */
3576 case DW_CFA_advance_loc
:
3577 if (do_debug_frames_interp
)
3578 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3580 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3581 opa
* fc
->code_factor
,
3582 fc
->pc_begin
+ opa
* fc
->code_factor
);
3583 fc
->pc_begin
+= opa
* fc
->code_factor
;
3588 if (! do_debug_frames_interp
)
3589 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3590 opa
, roffs
* fc
->data_factor
);
3591 fc
->col_type
[opa
] = DW_CFA_offset
;
3592 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
3595 case DW_CFA_restore
:
3596 if (! do_debug_frames_interp
)
3597 printf (" DW_CFA_restore: r%d\n", opa
);
3598 fc
->col_type
[opa
] = cie
->col_type
[opa
];
3599 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
3602 case DW_CFA_set_loc
:
3603 vma
= get_encoded_value (start
, fc
->fde_encoding
);
3604 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
3605 vma
+= section
->address
+ (start
- section_start
);
3606 start
+= encoded_ptr_size
;
3607 if (do_debug_frames_interp
)
3608 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3610 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
3614 case DW_CFA_advance_loc1
:
3615 ofs
= byte_get (start
, 1); start
+= 1;
3616 if (do_debug_frames_interp
)
3617 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3619 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3620 ofs
* fc
->code_factor
,
3621 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3622 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3625 case DW_CFA_advance_loc2
:
3626 ofs
= byte_get (start
, 2); start
+= 2;
3627 if (do_debug_frames_interp
)
3628 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3630 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3631 ofs
* fc
->code_factor
,
3632 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3633 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3636 case DW_CFA_advance_loc4
:
3637 ofs
= byte_get (start
, 4); start
+= 4;
3638 if (do_debug_frames_interp
)
3639 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3641 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3642 ofs
* fc
->code_factor
,
3643 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3644 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3647 case DW_CFA_offset_extended
:
3650 if (! do_debug_frames_interp
)
3651 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3652 reg
, roffs
* fc
->data_factor
);
3653 fc
->col_type
[reg
] = DW_CFA_offset
;
3654 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
3657 case DW_CFA_val_offset
:
3660 if (! do_debug_frames_interp
)
3661 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3662 reg
, roffs
* fc
->data_factor
);
3663 fc
->col_type
[reg
] = DW_CFA_val_offset
;
3664 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
3667 case DW_CFA_restore_extended
:
3669 if (! do_debug_frames_interp
)
3670 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
3671 fc
->col_type
[reg
] = cie
->col_type
[reg
];
3672 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
3675 case DW_CFA_undefined
:
3677 if (! do_debug_frames_interp
)
3678 printf (" DW_CFA_undefined: r%ld\n", reg
);
3679 fc
->col_type
[reg
] = DW_CFA_undefined
;
3680 fc
->col_offset
[reg
] = 0;
3683 case DW_CFA_same_value
:
3685 if (! do_debug_frames_interp
)
3686 printf (" DW_CFA_same_value: r%ld\n", reg
);
3687 fc
->col_type
[reg
] = DW_CFA_same_value
;
3688 fc
->col_offset
[reg
] = 0;
3691 case DW_CFA_register
:
3694 if (! do_debug_frames_interp
)
3695 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
3696 fc
->col_type
[reg
] = DW_CFA_register
;
3697 fc
->col_offset
[reg
] = roffs
;
3700 case DW_CFA_remember_state
:
3701 if (! do_debug_frames_interp
)
3702 printf (" DW_CFA_remember_state\n");
3703 rs
= xmalloc (sizeof (Frame_Chunk
));
3704 rs
->ncols
= fc
->ncols
;
3705 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
3706 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
3707 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
3708 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
3709 rs
->next
= remembered_state
;
3710 remembered_state
= rs
;
3713 case DW_CFA_restore_state
:
3714 if (! do_debug_frames_interp
)
3715 printf (" DW_CFA_restore_state\n");
3716 rs
= remembered_state
;
3719 remembered_state
= rs
->next
;
3720 frame_need_space (fc
, rs
->ncols
- 1);
3721 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
3722 memcpy (fc
->col_offset
, rs
->col_offset
,
3723 rs
->ncols
* sizeof (int));
3724 free (rs
->col_type
);
3725 free (rs
->col_offset
);
3728 else if (do_debug_frames_interp
)
3729 printf ("Mismatched DW_CFA_restore_state\n");
3732 case DW_CFA_def_cfa
:
3733 fc
->cfa_reg
= LEB ();
3734 fc
->cfa_offset
= LEB ();
3736 if (! do_debug_frames_interp
)
3737 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3738 fc
->cfa_reg
, fc
->cfa_offset
);
3741 case DW_CFA_def_cfa_register
:
3742 fc
->cfa_reg
= LEB ();
3744 if (! do_debug_frames_interp
)
3745 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
3748 case DW_CFA_def_cfa_offset
:
3749 fc
->cfa_offset
= LEB ();
3750 if (! do_debug_frames_interp
)
3751 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
3755 if (! do_debug_frames_interp
)
3756 printf (" DW_CFA_nop\n");
3759 case DW_CFA_def_cfa_expression
:
3761 if (! do_debug_frames_interp
)
3763 printf (" DW_CFA_def_cfa_expression (");
3764 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3771 case DW_CFA_expression
:
3774 if (! do_debug_frames_interp
)
3776 printf (" DW_CFA_expression: r%ld (", reg
);
3777 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3780 fc
->col_type
[reg
] = DW_CFA_expression
;
3784 case DW_CFA_val_expression
:
3787 if (! do_debug_frames_interp
)
3789 printf (" DW_CFA_val_expression: r%ld (", reg
);
3790 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3793 fc
->col_type
[reg
] = DW_CFA_val_expression
;
3797 case DW_CFA_offset_extended_sf
:
3800 frame_need_space (fc
, reg
);
3801 if (! do_debug_frames_interp
)
3802 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3803 reg
, l
* fc
->data_factor
);
3804 fc
->col_type
[reg
] = DW_CFA_offset
;
3805 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3808 case DW_CFA_val_offset_sf
:
3811 frame_need_space (fc
, reg
);
3812 if (! do_debug_frames_interp
)
3813 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3814 reg
, l
* fc
->data_factor
);
3815 fc
->col_type
[reg
] = DW_CFA_val_offset
;
3816 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3819 case DW_CFA_def_cfa_sf
:
3820 fc
->cfa_reg
= LEB ();
3821 fc
->cfa_offset
= SLEB ();
3822 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
3824 if (! do_debug_frames_interp
)
3825 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3826 fc
->cfa_reg
, fc
->cfa_offset
);
3829 case DW_CFA_def_cfa_offset_sf
:
3830 fc
->cfa_offset
= SLEB ();
3831 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
3832 if (! do_debug_frames_interp
)
3833 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
3836 case DW_CFA_MIPS_advance_loc8
:
3837 ofs
= byte_get (start
, 8); start
+= 8;
3838 if (do_debug_frames_interp
)
3839 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3841 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3842 ofs
* fc
->code_factor
,
3843 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3844 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3847 case DW_CFA_GNU_window_save
:
3848 if (! do_debug_frames_interp
)
3849 printf (" DW_CFA_GNU_window_save\n");
3852 case DW_CFA_GNU_args_size
:
3854 if (! do_debug_frames_interp
)
3855 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
3858 case DW_CFA_GNU_negative_offset_extended
:
3861 frame_need_space (fc
, reg
);
3862 if (! do_debug_frames_interp
)
3863 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3864 reg
, l
* fc
->data_factor
);
3865 fc
->col_type
[reg
] = DW_CFA_offset
;
3866 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3870 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
3871 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
3873 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
3878 if (do_debug_frames_interp
)
3879 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3894 display_debug_not_supported (struct dwarf_section
*section
,
3895 void *file ATTRIBUTE_UNUSED
)
3897 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3904 cmalloc (size_t nmemb
, size_t size
)
3906 /* Check for overflow. */
3907 if (nmemb
>= ~(size_t) 0 / size
)
3910 return malloc (nmemb
* size
);
3914 xcmalloc (size_t nmemb
, size_t size
)
3916 /* Check for overflow. */
3917 if (nmemb
>= ~(size_t) 0 / size
)
3920 return xmalloc (nmemb
* size
);
3924 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
3926 /* Check for overflow. */
3927 if (nmemb
>= ~(size_t) 0 / size
)
3930 return xrealloc (ptr
, nmemb
* size
);
3934 error (const char *message
, ...)
3938 va_start (args
, message
);
3939 fprintf (stderr
, _("%s: Error: "), program_name
);
3940 vfprintf (stderr
, message
, args
);
3945 warn (const char *message
, ...)
3949 va_start (args
, message
);
3950 fprintf (stderr
, _("%s: Warning: "), program_name
);
3951 vfprintf (stderr
, message
, args
);
3956 free_debug_memory (void)
3958 enum dwarf_section_display_enum i
;
3962 for (i
= 0; i
< max
; i
++)
3963 free_debug_section (i
);
3965 if (debug_information
!= NULL
)
3967 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
3969 for (i
= 0; i
< num_debug_info_entries
; i
++)
3971 if (!debug_information
[i
].max_loc_offsets
)
3973 free (debug_information
[i
].loc_offsets
);
3974 free (debug_information
[i
].have_frame_base
);
3976 if (!debug_information
[i
].max_range_lists
)
3977 free (debug_information
[i
].range_lists
);
3981 free (debug_information
);
3982 debug_information
= NULL
;
3983 num_debug_info_entries
= 0;
3987 struct dwarf_section_display debug_displays
[] =
3989 { { ".debug_abbrev", NULL
, 0, 0 },
3990 display_debug_abbrev
, 0, 0 },
3991 { { ".debug_aranges", NULL
, 0, 0 },
3992 display_debug_aranges
, 0, 0 },
3993 { { ".debug_frame", NULL
, 0, 0 },
3994 display_debug_frames
, 1, 0 },
3995 { { ".debug_info", NULL
, 0, 0 },
3996 display_debug_info
, 1, 0 },
3997 { { ".debug_line", NULL
, 0, 0 },
3998 display_debug_lines
, 0, 0 },
3999 { { ".debug_pubnames", NULL
, 0, 0 },
4000 display_debug_pubnames
, 0, 0 },
4001 { { ".eh_frame", NULL
, 0, 0 },
4002 display_debug_frames
, 1, 1 },
4003 { { ".debug_macinfo", NULL
, 0, 0 },
4004 display_debug_macinfo
, 0, 0 },
4005 { { ".debug_str", NULL
, 0, 0 },
4006 display_debug_str
, 0, 0 },
4007 { { ".debug_loc", NULL
, 0, 0 },
4008 display_debug_loc
, 0, 0 },
4009 { { ".debug_pubtypes", NULL
, 0, 0 },
4010 display_debug_pubnames
, 0, 0 },
4011 { { ".debug_ranges", NULL
, 0, 0 },
4012 display_debug_ranges
, 0, 0 },
4013 { { ".debug_static_func", NULL
, 0, 0 },
4014 display_debug_not_supported
, 0, 0 },
4015 { { ".debug_static_vars", NULL
, 0, 0 },
4016 display_debug_not_supported
, 0, 0 },
4017 { { ".debug_types", NULL
, 0, 0 },
4018 display_debug_not_supported
, 0, 0 },
4019 { { ".debug_weaknames", NULL
, 0, 0 },
4020 display_debug_not_supported
, 0, 0 }