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 struct dwarf_section * section)
1021 unsigned long uvalue = 0;
1022 unsigned char *block_start = NULL;
1023 unsigned char * orig_data = data;
1024 unsigned int bytes_read;
1031 case DW_FORM_ref_addr:
1032 if (dwarf_version == 2)
1034 uvalue = byte_get (data, pointer_size);
1035 data += pointer_size;
1037 else if (dwarf_version == 3)
1039 uvalue = byte_get (data, offset_size);
1040 data += offset_size;
1044 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1049 uvalue = byte_get (data, pointer_size);
1050 data += pointer_size;
1054 uvalue = byte_get (data, offset_size);
1055 data += offset_size;
1061 uvalue = byte_get (data++, 1);
1066 uvalue = byte_get (data, 2);
1072 uvalue = byte_get (data, 4);
1077 uvalue = read_leb128 (data, & bytes_read, 1);
1081 case DW_FORM_ref_udata:
1083 uvalue = read_leb128 (data, & bytes_read, 0);
1087 case DW_FORM_indirect:
1088 form = read_leb128 (data, & bytes_read, 0);
1091 printf (" %s", get_FORM_name (form));
1092 return read_and_display_attr_value (attribute, form, data,
1093 cu_offset, pointer_size,
1094 offset_size, dwarf_version,
1095 debug_info_p, do_loc,
1101 case DW_FORM_ref_addr:
1103 printf (" <0x%lx>", uvalue);
1109 case DW_FORM_ref_udata:
1111 printf (" <0x%lx>", uvalue + cu_offset);
1117 printf (" 0x%lx", uvalue);
1126 printf (" %ld", uvalue);
1133 uvalue = byte_get (data, 4);
1134 printf (" 0x%lx", uvalue);
1135 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1137 if ((do_loc || do_debug_loc || do_debug_ranges)
1138 && num_debug_info_entries == 0)
1140 if (sizeof (uvalue) == 8)
1141 uvalue = byte_get (data, 8);
1143 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1148 case DW_FORM_string:
1150 printf (" %s", data);
1151 data += strlen ((char *) data) + 1;
1155 uvalue = read_leb128 (data, & bytes_read, 0);
1156 block_start = data + bytes_read;
1158 data = block_start + uvalue;
1160 data = display_block (block_start, uvalue);
1163 case DW_FORM_block1:
1164 uvalue = byte_get (data, 1);
1165 block_start = data + 1;
1167 data = block_start + uvalue;
1169 data = display_block (block_start, uvalue);
1172 case DW_FORM_block2:
1173 uvalue = byte_get (data, 2);
1174 block_start = data + 2;
1176 data = block_start + uvalue;
1178 data = display_block (block_start, uvalue);
1181 case DW_FORM_block4:
1182 uvalue = byte_get (data, 4);
1183 block_start = data + 4;
1185 data = block_start + uvalue;
1187 data = display_block (block_start, uvalue);
1192 printf (_(" (indirect string, offset: 0x%lx): %s"),
1193 uvalue, fetch_indirect_string (uvalue));
1196 case DW_FORM_indirect:
1197 /* Handled above. */
1201 warn (_("Unrecognized form: %lu\n"), form);
1205 if ((do_loc || do_debug_loc || do_debug_ranges)
1206 && num_debug_info_entries == 0)
1210 case DW_AT_frame_base:
1211 have_frame_base = 1;
1212 case DW_AT_location:
1213 case DW_AT_string_length:
1214 case DW_AT_return_addr:
1215 case DW_AT_data_member_location:
1216 case DW_AT_vtable_elem_location:
1218 case DW_AT_static_link:
1219 case DW_AT_use_location:
1220 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1222 /* Process location list. */
1223 unsigned int max = debug_info_p->max_loc_offsets;
1224 unsigned int num = debug_info_p->num_loc_offsets;
1226 if (max == 0 || num >= max)
1229 debug_info_p->loc_offsets
1230 = xcrealloc (debug_info_p->loc_offsets,
1231 max, sizeof (*debug_info_p->loc_offsets));
1232 debug_info_p->have_frame_base
1233 = xcrealloc (debug_info_p->have_frame_base,
1234 max, sizeof (*debug_info_p->have_frame_base));
1235 debug_info_p->max_loc_offsets = max;
1237 debug_info_p->loc_offsets [num] = uvalue;
1238 debug_info_p->have_frame_base [num] = have_frame_base;
1239 debug_info_p->num_loc_offsets++;
1244 if (need_base_address)
1245 debug_info_p->base_address = uvalue;
1249 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1251 /* Process range list. */
1252 unsigned int max = debug_info_p->max_range_lists;
1253 unsigned int num = debug_info_p->num_range_lists;
1255 if (max == 0 || num >= max)
1258 debug_info_p->range_lists
1259 = xcrealloc (debug_info_p->range_lists,
1260 max, sizeof (*debug_info_p->range_lists));
1261 debug_info_p->max_range_lists = max;
1263 debug_info_p->range_lists [num] = uvalue;
1264 debug_info_p->num_range_lists++;
1276 /* For some attributes we can display further information. */
1284 case DW_INL_not_inlined:
1285 printf (_("(not inlined)"));
1287 case DW_INL_inlined:
1288 printf (_("(inlined)"));
1290 case DW_INL_declared_not_inlined:
1291 printf (_("(declared as inline but ignored)"));
1293 case DW_INL_declared_inlined:
1294 printf (_("(declared as inline and inlined)"));
1297 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1302 case DW_AT_language:
1305 /* Ordered by the numeric value of these constants. */
1306 case DW_LANG_C89: printf ("(ANSI C)"); break;
1307 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1308 case DW_LANG_Ada83: printf ("(Ada)"); break;
1309 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1310 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1311 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1312 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1313 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1314 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1315 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1316 /* DWARF 2.1 values. */
1317 case DW_LANG_Java: printf ("(Java)"); break;
1318 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1319 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1320 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1321 /* DWARF 3 values. */
1322 case DW_LANG_PLI: printf ("(PLI)"); break;
1323 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1324 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1325 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1326 case DW_LANG_D: printf ("(D)"); break;
1327 /* MIPS extension. */
1328 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1329 /* UPC extension. */
1330 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1332 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1333 printf ("(implementation defined: %lx)", uvalue);
1335 printf ("(Unknown: %lx)", uvalue);
1340 case DW_AT_encoding:
1343 case DW_ATE_void: printf ("(void)"); break;
1344 case DW_ATE_address: printf ("(machine address)"); break;
1345 case DW_ATE_boolean: printf ("(boolean)"); break;
1346 case DW_ATE_complex_float: printf ("(complex float)"); break;
1347 case DW_ATE_float: printf ("(float)"); break;
1348 case DW_ATE_signed: printf ("(signed)"); break;
1349 case DW_ATE_signed_char: printf ("(signed char)"); break;
1350 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1351 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1352 /* DWARF 2.1 values: */
1353 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1354 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1355 /* DWARF 3 values: */
1356 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1357 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1358 case DW_ATE_edited: printf ("(edited)"); break;
1359 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1360 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1361 /* HP extensions: */
1362 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1363 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1364 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1365 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1366 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1367 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1368 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1371 if (uvalue >= DW_ATE_lo_user
1372 && uvalue <= DW_ATE_hi_user)
1373 printf ("(user defined type)");
1375 printf ("(unknown type)");
1380 case DW_AT_accessibility:
1383 case DW_ACCESS_public: printf ("(public)"); break;
1384 case DW_ACCESS_protected: printf ("(protected)"); break;
1385 case DW_ACCESS_private: printf ("(private)"); break;
1387 printf ("(unknown accessibility)");
1392 case DW_AT_visibility:
1395 case DW_VIS_local: printf ("(local)"); break;
1396 case DW_VIS_exported: printf ("(exported)"); break;
1397 case DW_VIS_qualified: printf ("(qualified)"); break;
1398 default: printf ("(unknown visibility)"); break;
1402 case DW_AT_virtuality:
1405 case DW_VIRTUALITY_none: printf ("(none)"); break;
1406 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1407 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1408 default: printf ("(unknown virtuality)"); break;
1412 case DW_AT_identifier_case:
1415 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1416 case DW_ID_up_case: printf ("(up_case)"); break;
1417 case DW_ID_down_case: printf ("(down_case)"); break;
1418 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1419 default: printf ("(unknown case)"); break;
1423 case DW_AT_calling_convention:
1426 case DW_CC_normal: printf ("(normal)"); break;
1427 case DW_CC_program: printf ("(program)"); break;
1428 case DW_CC_nocall: printf ("(nocall)"); break;
1430 if (uvalue >= DW_CC_lo_user
1431 && uvalue <= DW_CC_hi_user)
1432 printf ("(user defined)");
1434 printf ("(unknown convention)");
1438 case DW_AT_ordering:
1441 case -1: printf ("(undefined)"); break;
1442 case 0: printf ("(row major)"); break;
1443 case 1: printf ("(column major)"); break;
1447 case DW_AT_frame_base:
1448 have_frame_base = 1;
1449 case DW_AT_location:
1450 case DW_AT_string_length:
1451 case DW_AT_return_addr:
1452 case DW_AT_data_member_location:
1453 case DW_AT_vtable_elem_location:
1455 case DW_AT_static_link:
1456 case DW_AT_use_location:
1457 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1458 printf (_("(location list)"));
1460 case DW_AT_allocated:
1461 case DW_AT_associated:
1462 case DW_AT_data_location:
1464 case DW_AT_upper_bound:
1465 case DW_AT_lower_bound:
1468 int need_frame_base;
1471 need_frame_base = decode_location_expression (block_start,
1476 if (need_frame_base && !have_frame_base)
1477 printf (_(" [without DW_AT_frame_base]"));
1483 if (form == DW_FORM_ref1
1484 || form == DW_FORM_ref2
1485 || form == DW_FORM_ref4)
1486 uvalue += cu_offset;
1488 if (uvalue >= section->size)
1489 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1490 uvalue, (long int)(orig_data - section->start));
1493 unsigned long abbrev_number;
1494 abbrev_entry * entry;
1496 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1498 printf ("[Abbrev Number: %ld", abbrev_number);
1499 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1500 if (entry->entry == abbrev_number)
1503 printf (" (%s)", get_TAG_name (entry->tag));
1517 get_AT_name (unsigned long attribute)
1521 case DW_AT_sibling: return "DW_AT_sibling";
1522 case DW_AT_location: return "DW_AT_location";
1523 case DW_AT_name: return "DW_AT_name";
1524 case DW_AT_ordering: return "DW_AT_ordering";
1525 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1526 case DW_AT_byte_size: return "DW_AT_byte_size";
1527 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1528 case DW_AT_bit_size: return "DW_AT_bit_size";
1529 case DW_AT_element_list: return "DW_AT_element_list";
1530 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1531 case DW_AT_low_pc: return "DW_AT_low_pc";
1532 case DW_AT_high_pc: return "DW_AT_high_pc";
1533 case DW_AT_language: return "DW_AT_language";
1534 case DW_AT_member: return "DW_AT_member";
1535 case DW_AT_discr: return "DW_AT_discr";
1536 case DW_AT_discr_value: return "DW_AT_discr_value";
1537 case DW_AT_visibility: return "DW_AT_visibility";
1538 case DW_AT_import: return "DW_AT_import";
1539 case DW_AT_string_length: return "DW_AT_string_length";
1540 case DW_AT_common_reference: return "DW_AT_common_reference";
1541 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1542 case DW_AT_const_value: return "DW_AT_const_value";
1543 case DW_AT_containing_type: return "DW_AT_containing_type";
1544 case DW_AT_default_value: return "DW_AT_default_value";
1545 case DW_AT_inline: return "DW_AT_inline";
1546 case DW_AT_is_optional: return "DW_AT_is_optional";
1547 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1548 case DW_AT_producer: return "DW_AT_producer";
1549 case DW_AT_prototyped: return "DW_AT_prototyped";
1550 case DW_AT_return_addr: return "DW_AT_return_addr";
1551 case DW_AT_start_scope: return "DW_AT_start_scope";
1552 case DW_AT_stride_size: return "DW_AT_stride_size";
1553 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1554 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1555 case DW_AT_accessibility: return "DW_AT_accessibility";
1556 case DW_AT_address_class: return "DW_AT_address_class";
1557 case DW_AT_artificial: return "DW_AT_artificial";
1558 case DW_AT_base_types: return "DW_AT_base_types";
1559 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1560 case DW_AT_count: return "DW_AT_count";
1561 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1562 case DW_AT_decl_column: return "DW_AT_decl_column";
1563 case DW_AT_decl_file: return "DW_AT_decl_file";
1564 case DW_AT_decl_line: return "DW_AT_decl_line";
1565 case DW_AT_declaration: return "DW_AT_declaration";
1566 case DW_AT_discr_list: return "DW_AT_discr_list";
1567 case DW_AT_encoding: return "DW_AT_encoding";
1568 case DW_AT_external: return "DW_AT_external";
1569 case DW_AT_frame_base: return "DW_AT_frame_base";
1570 case DW_AT_friend: return "DW_AT_friend";
1571 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1572 case DW_AT_macro_info: return "DW_AT_macro_info";
1573 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1574 case DW_AT_priority: return "DW_AT_priority";
1575 case DW_AT_segment: return "DW_AT_segment";
1576 case DW_AT_specification: return "DW_AT_specification";
1577 case DW_AT_static_link: return "DW_AT_static_link";
1578 case DW_AT_type: return "DW_AT_type";
1579 case DW_AT_use_location: return "DW_AT_use_location";
1580 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1581 case DW_AT_virtuality: return "DW_AT_virtuality";
1582 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1583 /* DWARF 2.1 values. */
1584 case DW_AT_allocated: return "DW_AT_allocated";
1585 case DW_AT_associated: return "DW_AT_associated";
1586 case DW_AT_data_location: return "DW_AT_data_location";
1587 case DW_AT_stride: return "DW_AT_stride";
1588 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1589 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1590 case DW_AT_extension: return "DW_AT_extension";
1591 case DW_AT_ranges: return "DW_AT_ranges";
1592 case DW_AT_trampoline: return "DW_AT_trampoline";
1593 case DW_AT_call_column: return "DW_AT_call_column";
1594 case DW_AT_call_file: return "DW_AT_call_file";
1595 case DW_AT_call_line: return "DW_AT_call_line";
1596 case DW_AT_description: return "DW_AT_description";
1597 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1598 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1599 case DW_AT_small: return "DW_AT_small";
1600 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1601 case DW_AT_digit_count: return "DW_AT_digit_count";
1602 case DW_AT_picture_string: return "DW_AT_picture_string";
1603 case DW_AT_mutable: return "DW_AT_mutable";
1604 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1605 case DW_AT_explicit: return "DW_AT_explicit";
1606 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1607 case DW_AT_endianity: return "DW_AT_endianity";
1608 case DW_AT_elemental: return "DW_AT_elemental";
1609 case DW_AT_pure: return "DW_AT_pure";
1610 case DW_AT_recursive: return "DW_AT_recursive";
1612 /* HP and SGI/MIPS extensions. */
1613 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1614 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1615 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1616 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1617 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1618 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1619 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1620 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1621 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1622 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1624 /* HP Extensions. */
1625 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1626 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1627 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1628 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1629 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1630 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1631 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1632 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1633 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1634 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1635 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1636 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1637 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1639 /* One value is shared by the MIPS and HP extensions: */
1640 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1642 /* GNU extensions. */
1643 case DW_AT_sf_names: return "DW_AT_sf_names";
1644 case DW_AT_src_info: return "DW_AT_src_info";
1645 case DW_AT_mac_info: return "DW_AT_mac_info";
1646 case DW_AT_src_coords: return "DW_AT_src_coords";
1647 case DW_AT_body_begin: return "DW_AT_body_begin";
1648 case DW_AT_body_end: return "DW_AT_body_end";
1649 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1651 /* UPC extension. */
1652 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1654 /* PGI (STMicroelectronics) extensions. */
1655 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1656 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1657 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1661 static char buffer[100];
1663 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1670 static unsigned char *
1671 read_and_display_attr (unsigned long attribute,
1673 unsigned char * data,
1674 unsigned long cu_offset,
1675 unsigned long pointer_size,
1676 unsigned long offset_size,
1678 debug_info * debug_info_p,
1680 struct dwarf_section * section)
1683 printf (" %-18s:", get_AT_name (attribute));
1684 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1685 pointer_size, offset_size,
1686 dwarf_version, debug_info_p,
1694 /* Process the contents of a .debug_info section. If do_loc is non-zero
1695 then we are scanning for location lists and we do not want to display
1696 anything to the user. */
1699 process_debug_info (struct dwarf_section *section,
1703 unsigned char *start = section->start;
1704 unsigned char *end = start + section->size;
1705 unsigned char *section_begin;
1707 unsigned int num_units = 0;
1709 if ((do_loc || do_debug_loc || do_debug_ranges)
1710 && num_debug_info_entries == 0)
1712 unsigned long length;
1714 /* First scan the section to get the number of comp units. */
1715 for (section_begin = start, num_units = 0; section_begin < end;
1718 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1719 will be the length. For a 64-bit DWARF section, it'll be
1720 the escape code 0xffffffff followed by an 8 byte length. */
1721 length = byte_get (section_begin, 4);
1723 if (length == 0xffffffff)
1725 length = byte_get (section_begin + 4, 8);
1726 section_begin += length + 12;
1728 else if (length >= 0xfffffff0 && length < 0xffffffff)
1730 warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1734 section_begin += length + 4;
1736 /* Negative values are illegal, they may even cause infinite
1737 looping. This can happen if we can't accurately apply
1738 relocations to an object file. */
1739 if ((signed long) length <= 0)
1741 warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1748 error (_("No comp units in %s section ?"), section->name);
1752 /* Then allocate an array to hold the information. */
1753 debug_information = cmalloc (num_units,
1754 sizeof (* debug_information));
1755 if (debug_information == NULL)
1757 error (_("Not enough memory for a debug info array of %u entries"),
1765 printf (_("The section %s contains:\n\n"), section->name);
1767 load_debug_section (str, file);
1770 load_debug_section (abbrev, file);
1771 if (debug_displays [abbrev].section.start == NULL)
1773 warn (_("Unable to locate %s section!\n"),
1774 debug_displays [abbrev].section.name);
1778 for (section_begin = start, unit = 0; start < end; unit++)
1780 DWARF2_Internal_CompUnit compunit;
1781 unsigned char *hdrptr;
1782 unsigned char *cu_abbrev_offset_ptr;
1783 unsigned char *tags;
1785 unsigned long cu_offset;
1787 int initial_length_size;
1791 compunit.cu_length = byte_get (hdrptr, 4);
1794 if (compunit.cu_length == 0xffffffff)
1796 compunit.cu_length = byte_get (hdrptr, 8);
1799 initial_length_size = 12;
1804 initial_length_size = 4;
1807 compunit.cu_version = byte_get (hdrptr, 2);
1810 cu_offset = start - section_begin;
1812 cu_abbrev_offset_ptr = hdrptr;
1813 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1814 hdrptr += offset_size;
1816 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1818 if ((do_loc || do_debug_loc || do_debug_ranges)
1819 && num_debug_info_entries == 0)
1821 debug_information [unit].cu_offset = cu_offset;
1822 debug_information [unit].pointer_size
1823 = compunit.cu_pointer_size;
1824 debug_information [unit].base_address = 0;
1825 debug_information [unit].loc_offsets = NULL;
1826 debug_information [unit].have_frame_base = NULL;
1827 debug_information [unit].max_loc_offsets = 0;
1828 debug_information [unit].num_loc_offsets = 0;
1829 debug_information [unit].range_lists = NULL;
1830 debug_information [unit].max_range_lists= 0;
1831 debug_information [unit].num_range_lists = 0;
1836 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1837 printf (_(" Length: 0x%lx (%s)\n"), compunit.cu_length,
1838 initial_length_size == 8 ? "64-bit" : "32-bit");
1839 printf (_(" Version: %d\n"), compunit.cu_version);
1840 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1841 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1844 if (cu_offset + compunit.cu_length + initial_length_size
1847 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1848 cu_offset, compunit.cu_length);
1852 start += compunit.cu_length + initial_length_size;
1854 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1856 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1857 cu_offset, compunit.cu_version);
1863 /* Process the abbrevs used by this compilation unit. DWARF
1864 sections under Mach-O have non-zero addresses. */
1865 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1866 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1867 (unsigned long) compunit.cu_abbrev_offset,
1868 (unsigned long) debug_displays [abbrev].section.size);
1870 process_abbrev_section
1871 ((unsigned char *) debug_displays [abbrev].section.start
1872 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1873 (unsigned char *) debug_displays [abbrev].section.start
1874 + debug_displays [abbrev].section.size);
1877 while (tags < start)
1879 unsigned int bytes_read;
1880 unsigned long abbrev_number;
1881 unsigned long die_offset;
1882 abbrev_entry *entry;
1885 die_offset = tags - section_begin;
1887 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1890 /* A null DIE marks the end of a list of siblings. */
1891 if (abbrev_number == 0)
1896 static unsigned num_bogus_warns = 0;
1898 if (num_bogus_warns < 3)
1900 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1903 if (num_bogus_warns == 3)
1904 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1911 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1912 level, die_offset, abbrev_number);
1914 /* Scan through the abbreviation list until we reach the
1916 for (entry = first_abbrev;
1917 entry && entry->entry != abbrev_number;
1918 entry = entry->next)
1928 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
1929 die_offset, abbrev_number);
1934 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1939 need_base_address = 0;
1941 case DW_TAG_compile_unit:
1942 need_base_address = 1;
1944 case DW_TAG_entry_point:
1945 case DW_TAG_subprogram:
1946 need_base_address = 0;
1947 /* Assuming that there is no DW_AT_frame_base. */
1948 have_frame_base = 0;
1952 for (attr = entry->first_attr; attr; attr = attr->next)
1955 /* Show the offset from where the tag was extracted. */
1956 printf (" <%2lx>", (unsigned long)(tags - section_begin));
1958 tags = read_and_display_attr (attr->attribute,
1961 compunit.cu_pointer_size,
1963 compunit.cu_version,
1964 debug_information + unit,
1968 if (entry->children)
1973 /* Set num_debug_info_entries here so that it can be used to check if
1974 we need to process .debug_loc and .debug_ranges sections. */
1975 if ((do_loc || do_debug_loc || do_debug_ranges)
1976 && num_debug_info_entries == 0)
1977 num_debug_info_entries = num_units;
1987 /* Locate and scan the .debug_info section in the file and record the pointer
1988 sizes and offsets for the compilation units in it. Usually an executable
1989 will have just one pointer size, but this is not guaranteed, and so we try
1990 not to make any assumptions. Returns zero upon failure, or the number of
1991 compilation units upon success. */
1994 load_debug_info (void * file)
1996 /* Reset the last pointer size so that we can issue correct error
1997 messages if we are displaying the contents of more than one section. */
1998 last_pointer_size = 0;
1999 warned_about_missing_comp_units = FALSE;
2001 /* If we have already tried and failed to load the .debug_info
2002 section then do not bother to repear the task. */
2003 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2006 /* If we already have the information there is nothing else to do. */
2007 if (num_debug_info_entries > 0)
2008 return num_debug_info_entries;
2010 if (load_debug_section (info, file)
2011 && process_debug_info (&debug_displays [info].section, file, 1))
2012 return num_debug_info_entries;
2014 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2019 display_debug_lines (struct dwarf_section *section, void *file)
2021 unsigned char *start = section->start;
2022 unsigned char *data = start;
2023 unsigned char *end = start + section->size;
2025 printf (_("\nDump of debug contents of section %s:\n\n"),
2028 if (load_debug_info (file) == 0)
2030 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2037 DWARF2_Internal_LineInfo info;
2038 unsigned char *standard_opcodes;
2039 unsigned char *end_of_sequence;
2040 unsigned char *hdrptr;
2041 unsigned long hdroff;
2042 int initial_length_size;
2047 hdroff = hdrptr - start;
2049 /* Check the length of the block. */
2050 info.li_length = byte_get (hdrptr, 4);
2053 if (info.li_length == 0xffffffff)
2055 /* This section is 64-bit DWARF 3. */
2056 info.li_length = byte_get (hdrptr, 8);
2059 initial_length_size = 12;
2064 initial_length_size = 4;
2067 if (info.li_length + initial_length_size > section->size)
2070 (_("The line info appears to be corrupt - the section is too small\n"));
2074 /* Check its version number. */
2075 info.li_version = byte_get (hdrptr, 2);
2077 if (info.li_version != 2 && info.li_version != 3)
2079 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2083 info.li_prologue_length = byte_get (hdrptr, offset_size);
2084 hdrptr += offset_size;
2085 info.li_min_insn_length = byte_get (hdrptr, 1);
2087 info.li_default_is_stmt = byte_get (hdrptr, 1);
2089 info.li_line_base = byte_get (hdrptr, 1);
2091 info.li_line_range = byte_get (hdrptr, 1);
2093 info.li_opcode_base = byte_get (hdrptr, 1);
2096 /* Sign extend the line base field. */
2097 info.li_line_base <<= 24;
2098 info.li_line_base >>= 24;
2100 printf (_(" Offset: 0x%lx\n"), hdroff);
2101 printf (_(" Length: %ld\n"), info.li_length);
2102 printf (_(" DWARF Version: %d\n"), info.li_version);
2103 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
2104 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
2105 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
2106 printf (_(" Line Base: %d\n"), info.li_line_base);
2107 printf (_(" Line Range: %d\n"), info.li_line_range);
2108 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
2110 end_of_sequence = data + info.li_length + initial_length_size;
2112 reset_state_machine (info.li_default_is_stmt);
2114 /* Display the contents of the Opcodes table. */
2115 standard_opcodes = hdrptr;
2117 printf (_("\n Opcodes:\n"));
2119 for (i = 1; i < info.li_opcode_base; i++)
2120 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2122 /* Display the contents of the Directory table. */
2123 data = standard_opcodes + info.li_opcode_base - 1;
2126 printf (_("\n The Directory Table is empty.\n"));
2129 printf (_("\n The Directory Table:\n"));
2133 printf (_(" %s\n"), data);
2135 data += strlen ((char *) data) + 1;
2139 /* Skip the NUL at the end of the table. */
2142 /* Display the contents of the File Name table. */
2144 printf (_("\n The File Name Table is empty.\n"));
2147 printf (_("\n The File Name Table:\n"));
2148 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2152 unsigned char *name;
2153 unsigned int bytes_read;
2155 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
2158 data += strlen ((char *) data) + 1;
2160 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2162 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2164 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2166 printf (_("%s\n"), name);
2170 /* Skip the NUL at the end of the table. */
2173 /* Now display the statements. */
2174 printf (_("\n Line Number Statements:\n"));
2176 while (data < end_of_sequence)
2178 unsigned char op_code;
2180 unsigned long int uladv;
2181 unsigned int bytes_read;
2185 if (op_code >= info.li_opcode_base)
2187 op_code -= info.li_opcode_base;
2188 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2189 state_machine_regs.address += uladv;
2190 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2191 op_code, uladv, state_machine_regs.address);
2192 adv = (op_code % info.li_line_range) + info.li_line_base;
2193 state_machine_regs.line += adv;
2194 printf (_(" and Line by %d to %d\n"),
2195 adv, state_machine_regs.line);
2197 else switch (op_code)
2199 case DW_LNS_extended_op:
2200 data += process_extended_line_op (data, info.li_default_is_stmt);
2204 printf (_(" Copy\n"));
2207 case DW_LNS_advance_pc:
2208 uladv = read_leb128 (data, & bytes_read, 0);
2209 uladv *= info.li_min_insn_length;
2211 state_machine_regs.address += uladv;
2212 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
2213 state_machine_regs.address);
2216 case DW_LNS_advance_line:
2217 adv = read_leb128 (data, & bytes_read, 1);
2219 state_machine_regs.line += adv;
2220 printf (_(" Advance Line by %d to %d\n"), adv,
2221 state_machine_regs.line);
2224 case DW_LNS_set_file:
2225 adv = read_leb128 (data, & bytes_read, 0);
2227 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2229 state_machine_regs.file = adv;
2232 case DW_LNS_set_column:
2233 uladv = read_leb128 (data, & bytes_read, 0);
2235 printf (_(" Set column to %lu\n"), uladv);
2236 state_machine_regs.column = uladv;
2239 case DW_LNS_negate_stmt:
2240 adv = state_machine_regs.is_stmt;
2242 printf (_(" Set is_stmt to %d\n"), adv);
2243 state_machine_regs.is_stmt = adv;
2246 case DW_LNS_set_basic_block:
2247 printf (_(" Set basic block\n"));
2248 state_machine_regs.basic_block = 1;
2251 case DW_LNS_const_add_pc:
2252 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2253 * info.li_min_insn_length);
2254 state_machine_regs.address += uladv;
2255 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2256 state_machine_regs.address);
2259 case DW_LNS_fixed_advance_pc:
2260 uladv = byte_get (data, 2);
2262 state_machine_regs.address += uladv;
2263 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2264 uladv, state_machine_regs.address);
2267 case DW_LNS_set_prologue_end:
2268 printf (_(" Set prologue_end to true\n"));
2271 case DW_LNS_set_epilogue_begin:
2272 printf (_(" Set epilogue_begin to true\n"));
2275 case DW_LNS_set_isa:
2276 uladv = read_leb128 (data, & bytes_read, 0);
2278 printf (_(" Set ISA to %lu\n"), uladv);
2282 printf (_(" Unknown opcode %d with operands: "), op_code);
2284 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2286 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2287 i == 1 ? "" : ", ");
2301 find_debug_info_for_offset (unsigned long offset)
2305 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2308 for (i = 0; i < num_debug_info_entries; i++)
2309 if (debug_information[i].cu_offset == offset)
2310 return debug_information + i;
2316 display_debug_pubnames (struct dwarf_section *section,
2317 void *file ATTRIBUTE_UNUSED)
2319 DWARF2_Internal_PubNames pubnames;
2320 unsigned char *start = section->start;
2321 unsigned char *end = start + section->size;
2323 /* It does not matter if this load fails,
2324 we test for that later on. */
2325 load_debug_info (file);
2327 printf (_("Contents of the %s section:\n\n"), section->name);
2331 unsigned char *data;
2332 unsigned long offset;
2333 int offset_size, initial_length_size;
2337 pubnames.pn_length = byte_get (data, 4);
2339 if (pubnames.pn_length == 0xffffffff)
2341 pubnames.pn_length = byte_get (data, 8);
2344 initial_length_size = 12;
2349 initial_length_size = 4;
2352 pubnames.pn_version = byte_get (data, 2);
2355 pubnames.pn_offset = byte_get (data, offset_size);
2356 data += offset_size;
2358 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2359 && num_debug_info_entries > 0
2360 && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
2361 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2362 pubnames.pn_offset, section->name);
2364 pubnames.pn_size = byte_get (data, offset_size);
2365 data += offset_size;
2367 start += pubnames.pn_length + initial_length_size;
2369 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2371 static int warned = 0;
2375 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2382 printf (_(" Length: %ld\n"),
2383 pubnames.pn_length);
2384 printf (_(" Version: %d\n"),
2385 pubnames.pn_version);
2386 printf (_(" Offset into .debug_info section: 0x%lx\n"),
2387 pubnames.pn_offset);
2388 printf (_(" Size of area in .debug_info section: %ld\n"),
2391 printf (_("\n Offset\tName\n"));
2395 offset = byte_get (data, offset_size);
2399 data += offset_size;
2400 printf (" %-6ld\t\t%s\n", offset, data);
2401 data += strlen ((char *) data) + 1;
2404 while (offset != 0);
2412 display_debug_macinfo (struct dwarf_section *section,
2413 void *file ATTRIBUTE_UNUSED)
2415 unsigned char *start = section->start;
2416 unsigned char *end = start + section->size;
2417 unsigned char *curr = start;
2418 unsigned int bytes_read;
2419 enum dwarf_macinfo_record_type op;
2421 printf (_("Contents of the %s section:\n\n"), section->name);
2425 unsigned int lineno;
2433 case DW_MACINFO_start_file:
2435 unsigned int filenum;
2437 lineno = read_leb128 (curr, & bytes_read, 0);
2439 filenum = read_leb128 (curr, & bytes_read, 0);
2442 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2447 case DW_MACINFO_end_file:
2448 printf (_(" DW_MACINFO_end_file\n"));
2451 case DW_MACINFO_define:
2452 lineno = read_leb128 (curr, & bytes_read, 0);
2454 string = (char *) curr;
2455 curr += strlen (string) + 1;
2456 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2460 case DW_MACINFO_undef:
2461 lineno = read_leb128 (curr, & bytes_read, 0);
2463 string = (char *) curr;
2464 curr += strlen (string) + 1;
2465 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2469 case DW_MACINFO_vendor_ext:
2471 unsigned int constant;
2473 constant = read_leb128 (curr, & bytes_read, 0);
2475 string = (char *) curr;
2476 curr += strlen (string) + 1;
2477 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2488 display_debug_abbrev (struct dwarf_section *section,
2489 void *file ATTRIBUTE_UNUSED)
2491 abbrev_entry *entry;
2492 unsigned char *start = section->start;
2493 unsigned char *end = start + section->size;
2495 printf (_("Contents of the %s section:\n\n"), section->name);
2501 start = process_abbrev_section (start, end);
2503 if (first_abbrev == NULL)
2506 printf (_(" Number TAG\n"));
2508 for (entry = first_abbrev; entry; entry = entry->next)
2512 printf (_(" %ld %s [%s]\n"),
2514 get_TAG_name (entry->tag),
2515 entry->children ? _("has children") : _("no children"));
2517 for (attr = entry->first_attr; attr; attr = attr->next)
2518 printf (_(" %-18s %s\n"),
2519 get_AT_name (attr->attribute),
2520 get_FORM_name (attr->form));
2531 display_debug_loc (struct dwarf_section *section, void *file)
2533 unsigned char *start = section->start;
2534 unsigned char *section_end;
2535 unsigned long bytes;
2536 unsigned char *section_begin = start;
2537 unsigned int num_loc_list = 0;
2538 unsigned long last_offset = 0;
2539 unsigned int first = 0;
2542 int seen_first_offset = 0;
2543 int use_debug_info = 1;
2544 unsigned char *next;
2546 bytes = section->size;
2547 section_end = start + bytes;
2551 printf (_("\nThe %s section is empty.\n"), section->name);
2555 if (load_debug_info (file) == 0)
2557 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2562 /* Check the order of location list in .debug_info section. If
2563 offsets of location lists are in the ascending order, we can
2564 use `debug_information' directly. */
2565 for (i = 0; i < num_debug_info_entries; i++)
2569 num = debug_information [i].num_loc_offsets;
2570 num_loc_list += num;
2572 /* Check if we can use `debug_information' directly. */
2573 if (use_debug_info && num != 0)
2575 if (!seen_first_offset)
2577 /* This is the first location list. */
2578 last_offset = debug_information [i].loc_offsets [0];
2580 seen_first_offset = 1;
2586 for (; j < num; j++)
2589 debug_information [i].loc_offsets [j])
2594 last_offset = debug_information [i].loc_offsets [j];
2599 if (!use_debug_info)
2600 /* FIXME: Should we handle this case? */
2601 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2603 if (!seen_first_offset)
2604 error (_("No location lists in .debug_info section!\n"));
2606 /* DWARF sections under Mach-O have non-zero addresses. */
2607 if (debug_information [first].num_loc_offsets > 0
2608 && debug_information [first].loc_offsets [0] != section->address)
2609 warn (_("Location lists in %s section start at 0x%lx\n"),
2610 section->name, debug_information [first].loc_offsets [0]);
2612 printf (_("Contents of the %s section:\n\n"), section->name);
2613 printf (_(" Offset Begin End Expression\n"));
2615 seen_first_offset = 0;
2616 for (i = first; i < num_debug_info_entries; i++)
2618 unsigned long begin;
2620 unsigned short length;
2621 unsigned long offset;
2622 unsigned int pointer_size;
2623 unsigned long cu_offset;
2624 unsigned long base_address;
2625 int need_frame_base;
2628 pointer_size = debug_information [i].pointer_size;
2629 cu_offset = debug_information [i].cu_offset;
2631 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2633 has_frame_base = debug_information [i].have_frame_base [j];
2634 /* DWARF sections under Mach-O have non-zero addresses. */
2635 offset = debug_information [i].loc_offsets [j] - section->address;
2636 next = section_begin + offset;
2637 base_address = debug_information [i].base_address;
2639 if (!seen_first_offset)
2640 seen_first_offset = 1;
2644 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2645 (long)(start - section_begin), (long)(next - section_begin));
2646 else if (start > next)
2647 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2648 (long)(start - section_begin), (long)(next - section_begin));
2652 if (offset >= bytes)
2654 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2661 if (start + 2 * pointer_size > section_end)
2663 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2668 begin = byte_get (start, pointer_size);
2669 start += pointer_size;
2670 end = byte_get (start, pointer_size);
2671 start += pointer_size;
2673 if (begin == 0 && end == 0)
2675 printf (_(" %8.8lx <End of list>\n"), offset);
2679 /* Check base address specifiers. */
2680 if (begin == -1UL && end != -1UL)
2683 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2684 offset, begin, end);
2688 if (start + 2 > section_end)
2690 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2695 length = byte_get (start, 2);
2698 if (start + length > section_end)
2700 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2705 printf (" %8.8lx %8.8lx %8.8lx (",
2706 offset, begin + base_address, end + base_address);
2707 need_frame_base = decode_location_expression (start,
2713 if (need_frame_base && !has_frame_base)
2714 printf (_(" [without DW_AT_frame_base]"));
2717 fputs (_(" (start == end)"), stdout);
2718 else if (begin > end)
2719 fputs (_(" (start > end)"), stdout);
2728 if (start < section_end)
2729 warn (_("There are %ld unused bytes at the end of section %s\n"),
2730 (long) (section_end - start), section->name);
2735 display_debug_str (struct dwarf_section *section,
2736 void *file ATTRIBUTE_UNUSED)
2738 unsigned char *start = section->start;
2739 unsigned long bytes = section->size;
2740 dwarf_vma addr = section->address;
2744 printf (_("\nThe %s section is empty.\n"), section->name);
2748 printf (_("Contents of the %s section:\n\n"), section->name);
2756 lbytes = (bytes > 16 ? 16 : bytes);
2758 printf (" 0x%8.8lx ", (unsigned long) addr);
2760 for (j = 0; j < 16; j++)
2763 printf ("%2.2x", start[j]);
2771 for (j = 0; j < lbytes; j++)
2774 if (k >= ' ' && k < 0x80)
2793 display_debug_info (struct dwarf_section *section, void *file)
2795 return process_debug_info (section, file, 0);
2800 display_debug_aranges (struct dwarf_section *section,
2801 void *file ATTRIBUTE_UNUSED)
2803 unsigned char *start = section->start;
2804 unsigned char *end = start + section->size;
2806 printf (_("The section %s contains:\n\n"), section->name);
2808 /* It does not matter if this load fails,
2809 we test for that later on. */
2810 load_debug_info (file);
2814 unsigned char *hdrptr;
2815 DWARF2_Internal_ARange arange;
2816 unsigned char *ranges;
2817 unsigned long length;
2818 unsigned long address;
2819 unsigned char address_size;
2822 int initial_length_size;
2826 arange.ar_length = byte_get (hdrptr, 4);
2829 if (arange.ar_length == 0xffffffff)
2831 arange.ar_length = byte_get (hdrptr, 8);
2834 initial_length_size = 12;
2839 initial_length_size = 4;
2842 arange.ar_version = byte_get (hdrptr, 2);
2845 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2846 hdrptr += offset_size;
2848 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2849 && num_debug_info_entries > 0
2850 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
2851 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2852 arange.ar_info_offset, section->name);
2854 arange.ar_pointer_size = byte_get (hdrptr, 1);
2857 arange.ar_segment_size = byte_get (hdrptr, 1);
2860 if (arange.ar_version != 2 && arange.ar_version != 3)
2862 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2866 printf (_(" Length: %ld\n"), arange.ar_length);
2867 printf (_(" Version: %d\n"), arange.ar_version);
2868 printf (_(" Offset into .debug_info: 0x%lx\n"), arange.ar_info_offset);
2869 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2870 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2872 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2874 /* The DWARF spec does not require that the address size be a power
2875 of two, but we do. This will have to change if we ever encounter
2876 an uneven architecture. */
2877 if ((address_size & (address_size - 1)) != 0)
2879 warn (_("Pointer size + Segment size is not a power of two.\n"));
2883 if (address_size > 4)
2884 printf (_("\n Address Length\n"));
2886 printf (_("\n Address Length\n"));
2890 /* Must pad to an alignment boundary that is twice the address size. */
2891 excess = (hdrptr - start) % (2 * address_size);
2893 ranges += (2 * address_size) - excess;
2895 start += arange.ar_length + initial_length_size;
2897 while (ranges + 2 * address_size <= start)
2899 address = byte_get (ranges, address_size);
2901 ranges += address_size;
2903 length = byte_get (ranges, address_size);
2905 ranges += address_size;
2907 if (address_size > 4)
2908 printf (" 0x%16.16lx 0x%lx\n", address, length);
2910 printf (" 0x%8.8lx 0x%lx\n", address, length);
2920 display_debug_ranges (struct dwarf_section *section,
2921 void *file ATTRIBUTE_UNUSED)
2923 unsigned char *start = section->start;
2924 unsigned char *section_end;
2925 unsigned long bytes;
2926 unsigned char *section_begin = start;
2927 unsigned int num_range_list = 0;
2928 unsigned long last_offset = 0;
2929 unsigned int first = 0;
2932 int seen_first_offset = 0;
2933 int use_debug_info = 1;
2934 unsigned char *next;
2936 bytes = section->size;
2937 section_end = start + bytes;
2941 printf (_("\nThe %s section is empty.\n"), section->name);
2945 if (load_debug_info (file) == 0)
2947 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2952 /* Check the order of range list in .debug_info section. If
2953 offsets of range lists are in the ascending order, we can
2954 use `debug_information' directly. */
2955 for (i = 0; i < num_debug_info_entries; i++)
2959 num = debug_information [i].num_range_lists;
2960 num_range_list += num;
2962 /* Check if we can use `debug_information' directly. */
2963 if (use_debug_info && num != 0)
2965 if (!seen_first_offset)
2967 /* This is the first range list. */
2968 last_offset = debug_information [i].range_lists [0];
2970 seen_first_offset = 1;
2976 for (; j < num; j++)
2979 debug_information [i].range_lists [j])
2984 last_offset = debug_information [i].range_lists [j];
2989 if (!use_debug_info)
2990 /* FIXME: Should we handle this case? */
2991 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2993 if (!seen_first_offset)
2994 error (_("No range lists in .debug_info section!\n"));
2996 /* DWARF sections under Mach-O have non-zero addresses. */
2997 if (debug_information [first].num_range_lists > 0
2998 && debug_information [first].range_lists [0] != section->address)
2999 warn (_("Range lists in %s section start at 0x%lx\n"),
3000 section->name, debug_information [first].range_lists [0]);
3002 printf (_("Contents of the %s section:\n\n"), section->name);
3003 printf (_(" Offset Begin End\n"));
3005 seen_first_offset = 0;
3006 for (i = first; i < num_debug_info_entries; i++)
3008 unsigned long begin;
3010 unsigned long offset;
3011 unsigned int pointer_size;
3012 unsigned long base_address;
3014 pointer_size = debug_information [i].pointer_size;
3016 for (j = 0; j < debug_information [i].num_range_lists; j++)
3018 /* DWARF sections under Mach-O have non-zero addresses. */
3019 offset = debug_information [i].range_lists [j] - section->address;
3020 next = section_begin + offset;
3021 base_address = debug_information [i].base_address;
3023 if (!seen_first_offset)
3024 seen_first_offset = 1;
3028 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3029 (long)(start - section_begin),
3030 (long)(next - section_begin), section->name);
3031 else if (start > next)
3032 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3033 (long)(start - section_begin),
3034 (long)(next - section_begin), section->name);
3040 begin = byte_get (start, pointer_size);
3041 start += pointer_size;
3042 end = byte_get (start, pointer_size);
3043 start += pointer_size;
3045 if (begin == 0 && end == 0)
3047 printf (_(" %8.8lx <End of list>\n"), offset);
3051 /* Check base address specifiers. */
3052 if (begin == -1UL && end != -1UL)
3055 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
3056 offset, begin, end);
3060 printf (" %8.8lx %8.8lx %8.8lx",
3061 offset, begin + base_address, end + base_address);
3064 fputs (_(" (start == end)"), stdout);
3065 else if (begin > end)
3066 fputs (_(" (start > end)"), stdout);
3076 typedef struct Frame_Chunk
3078 struct Frame_Chunk *next;
3079 unsigned char *chunk_start;
3081 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3082 short int *col_type;
3085 unsigned int code_factor;
3087 unsigned long pc_begin;
3088 unsigned long pc_range;
3092 unsigned char fde_encoding;
3093 unsigned char cfa_exp;
3097 /* A marker for a col_type that means this column was never referenced
3098 in the frame info. */
3099 #define DW_CFA_unreferenced (-1)
3102 frame_need_space (Frame_Chunk *fc, int reg)
3104 int prev = fc->ncols;
3106 if (reg < fc->ncols)
3109 fc->ncols = reg + 1;
3110 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3111 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3113 while (prev < fc->ncols)
3115 fc->col_type[prev] = DW_CFA_unreferenced;
3116 fc->col_offset[prev] = 0;
3122 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3127 if (*max_regs < fc->ncols)
3128 *max_regs = fc->ncols;
3130 if (*need_col_headers)
3132 *need_col_headers = 0;
3134 printf (" LOC CFA ");
3136 for (r = 0; r < *max_regs; r++)
3137 if (fc->col_type[r] != DW_CFA_unreferenced)
3142 printf ("r%-4d", r);
3148 printf ("%08lx ", fc->pc_begin);
3150 strcpy (tmp, "exp");
3152 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
3153 printf ("%-8s ", tmp);
3155 for (r = 0; r < fc->ncols; r++)
3157 if (fc->col_type[r] != DW_CFA_unreferenced)
3159 switch (fc->col_type[r])
3161 case DW_CFA_undefined:
3164 case DW_CFA_same_value:
3168 sprintf (tmp, "c%+d", fc->col_offset[r]);
3170 case DW_CFA_val_offset:
3171 sprintf (tmp, "v%+d", fc->col_offset[r]);
3173 case DW_CFA_register:
3174 sprintf (tmp, "r%d", fc->col_offset[r]);
3176 case DW_CFA_expression:
3177 strcpy (tmp, "exp");
3179 case DW_CFA_val_expression:
3180 strcpy (tmp, "vexp");
3183 strcpy (tmp, "n/a");
3186 printf ("%-5s", tmp);
3193 size_of_encoded_value (int encoding)
3195 switch (encoding & 0x7)
3198 case 0: return eh_addr_size;
3206 get_encoded_value (unsigned char *data, int encoding)
3208 int size = size_of_encoded_value (encoding);
3210 if (encoding & DW_EH_PE_signed)
3211 return byte_get_signed (data, size);
3213 return byte_get (data, size);
3216 #define GET(N) byte_get (start, N); start += N
3217 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3218 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3221 display_debug_frames (struct dwarf_section *section,
3222 void *file ATTRIBUTE_UNUSED)
3224 unsigned char *start = section->start;
3225 unsigned char *end = start + section->size;
3226 unsigned char *section_start = start;
3227 Frame_Chunk *chunks = 0;
3228 Frame_Chunk *remembered_state = 0;
3230 int is_eh = strcmp (section->name, ".eh_frame") == 0;
3231 unsigned int length_return;
3234 printf (_("The section %s contains:\n"), section->name);
3238 unsigned char *saved_start;
3239 unsigned char *block_end;
3240 unsigned long length;
3241 unsigned long cie_id;
3244 int need_col_headers = 1;
3245 unsigned char *augmentation_data = NULL;
3246 unsigned long augmentation_data_len = 0;
3247 int encoded_ptr_size = eh_addr_size;
3249 int initial_length_size;
3251 saved_start = start;
3252 length = byte_get (start, 4); start += 4;
3256 printf ("\n%08lx ZERO terminator\n\n",
3257 (unsigned long)(saved_start - section_start));
3261 if (length == 0xffffffff)
3263 length = byte_get (start, 8);
3266 initial_length_size = 12;
3271 initial_length_size = 4;
3274 block_end = saved_start + length + initial_length_size;
3275 if (block_end > end)
3277 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3278 length, (unsigned long)(saved_start - section_start));
3281 cie_id = byte_get (start, offset_size); start += offset_size;
3283 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3287 fc = xmalloc (sizeof (Frame_Chunk));
3288 memset (fc, 0, sizeof (Frame_Chunk));
3292 fc->chunk_start = saved_start;
3294 fc->col_type = xmalloc (sizeof (short int));
3295 fc->col_offset = xmalloc (sizeof (int));
3296 frame_need_space (fc, max_regs - 1);
3300 fc->augmentation = (char *) start;
3301 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3303 if (fc->augmentation[0] == 'z')
3305 fc->code_factor = LEB ();
3306 fc->data_factor = SLEB ();
3315 augmentation_data_len = LEB ();
3316 augmentation_data = start;
3317 start += augmentation_data_len;
3319 else if (strcmp (fc->augmentation, "eh") == 0)
3321 start += eh_addr_size;
3322 fc->code_factor = LEB ();
3323 fc->data_factor = SLEB ();
3335 fc->code_factor = LEB ();
3336 fc->data_factor = SLEB ();
3348 if (do_debug_frames_interp)
3349 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3350 (unsigned long)(saved_start - section_start), length, cie_id,
3351 fc->augmentation, fc->code_factor, fc->data_factor,
3355 printf ("\n%08lx %08lx %08lx CIE\n",
3356 (unsigned long)(saved_start - section_start), length, cie_id);
3357 printf (" Version: %d\n", version);
3358 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3359 printf (" Code alignment factor: %u\n", fc->code_factor);
3360 printf (" Data alignment factor: %d\n", fc->data_factor);
3361 printf (" Return address column: %d\n", fc->ra);
3363 if (augmentation_data_len)
3366 printf (" Augmentation data: ");
3367 for (i = 0; i < augmentation_data_len; ++i)
3368 printf (" %02x", augmentation_data[i]);
3374 if (augmentation_data_len)
3376 unsigned char *p, *q;
3377 p = (unsigned char *) fc->augmentation + 1;
3378 q = augmentation_data;
3385 q += 1 + size_of_encoded_value (*q);
3387 fc->fde_encoding = *q++;
3393 if (fc->fde_encoding)
3394 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3397 frame_need_space (fc, fc->ra);
3401 unsigned char *look_for;
3402 static Frame_Chunk fde_fc;
3405 memset (fc, 0, sizeof (Frame_Chunk));
3407 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3409 for (cie = chunks; cie ; cie = cie->next)
3410 if (cie->chunk_start == look_for)
3415 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3416 cie_id, (unsigned long)(saved_start - section_start));
3418 fc->col_type = xmalloc (sizeof (short int));
3419 fc->col_offset = xmalloc (sizeof (int));
3420 frame_need_space (fc, max_regs - 1);
3422 fc->augmentation = "";
3423 fc->fde_encoding = 0;
3427 fc->ncols = cie->ncols;
3428 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3429 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3430 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3431 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3432 fc->augmentation = cie->augmentation;
3433 fc->code_factor = cie->code_factor;
3434 fc->data_factor = cie->data_factor;
3435 fc->cfa_reg = cie->cfa_reg;
3436 fc->cfa_offset = cie->cfa_offset;
3438 frame_need_space (fc, max_regs - 1);
3439 fc->fde_encoding = cie->fde_encoding;
3442 if (fc->fde_encoding)
3443 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3445 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3446 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3447 fc->pc_begin += section->address + (start - section_start);
3448 start += encoded_ptr_size;
3449 fc->pc_range = byte_get (start, encoded_ptr_size);
3450 start += encoded_ptr_size;
3452 if (cie->augmentation[0] == 'z')
3454 augmentation_data_len = LEB ();
3455 augmentation_data = start;
3456 start += augmentation_data_len;
3459 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3460 (unsigned long)(saved_start - section_start), length, cie_id,
3461 (unsigned long)(cie->chunk_start - section_start),
3462 fc->pc_begin, fc->pc_begin + fc->pc_range);
3463 if (! do_debug_frames_interp && augmentation_data_len)
3467 printf (" Augmentation data: ");
3468 for (i = 0; i < augmentation_data_len; ++i)
3469 printf (" %02x", augmentation_data[i]);
3475 /* At this point, fc is the current chunk, cie (if any) is set, and
3476 we're about to interpret instructions for the chunk. */
3477 /* ??? At present we need to do this always, since this sizes the
3478 fc->col_type and fc->col_offset arrays, which we write into always.
3479 We should probably split the interpreted and non-interpreted bits
3480 into two different routines, since there's so much that doesn't
3481 really overlap between them. */
3482 if (1 || do_debug_frames_interp)
3484 /* Start by making a pass over the chunk, allocating storage
3485 and taking note of what registers are used. */
3486 unsigned char *tmp = start;
3488 while (start < block_end)
3491 unsigned long reg, tmp;
3498 /* Warning: if you add any more cases to this switch, be
3499 sure to add them to the corresponding switch below. */
3502 case DW_CFA_advance_loc:
3506 frame_need_space (fc, opa);
3507 fc->col_type[opa] = DW_CFA_undefined;
3509 case DW_CFA_restore:
3510 frame_need_space (fc, opa);
3511 fc->col_type[opa] = DW_CFA_undefined;
3513 case DW_CFA_set_loc:
3514 start += encoded_ptr_size;
3516 case DW_CFA_advance_loc1:
3519 case DW_CFA_advance_loc2:
3522 case DW_CFA_advance_loc4:
3525 case DW_CFA_offset_extended:
3526 case DW_CFA_val_offset:
3527 reg = LEB (); LEB ();
3528 frame_need_space (fc, reg);
3529 fc->col_type[reg] = DW_CFA_undefined;
3531 case DW_CFA_restore_extended:
3533 frame_need_space (fc, reg);
3534 fc->col_type[reg] = DW_CFA_undefined;
3536 case DW_CFA_undefined:
3538 frame_need_space (fc, reg);
3539 fc->col_type[reg] = DW_CFA_undefined;
3541 case DW_CFA_same_value:
3543 frame_need_space (fc, reg);
3544 fc->col_type[reg] = DW_CFA_undefined;
3546 case DW_CFA_register:
3547 reg = LEB (); LEB ();
3548 frame_need_space (fc, reg);
3549 fc->col_type[reg] = DW_CFA_undefined;
3551 case DW_CFA_def_cfa:
3554 case DW_CFA_def_cfa_register:
3557 case DW_CFA_def_cfa_offset:
3560 case DW_CFA_def_cfa_expression:
3564 case DW_CFA_expression:
3565 case DW_CFA_val_expression:
3569 frame_need_space (fc, reg);
3570 fc->col_type[reg] = DW_CFA_undefined;
3572 case DW_CFA_offset_extended_sf:
3573 case DW_CFA_val_offset_sf:
3574 reg = LEB (); SLEB ();
3575 frame_need_space (fc, reg);
3576 fc->col_type[reg] = DW_CFA_undefined;
3578 case DW_CFA_def_cfa_sf:
3581 case DW_CFA_def_cfa_offset_sf:
3584 case DW_CFA_MIPS_advance_loc8:
3587 case DW_CFA_GNU_args_size:
3590 case DW_CFA_GNU_negative_offset_extended:
3591 reg = LEB (); LEB ();
3592 frame_need_space (fc, reg);
3593 fc->col_type[reg] = DW_CFA_undefined;
3602 /* Now we know what registers are used, make a second pass over
3603 the chunk, this time actually printing out the info. */
3605 while (start < block_end)
3608 unsigned long ul, reg, roffs;
3617 /* Warning: if you add any more cases to this switch, be
3618 sure to add them to the corresponding switch above. */
3621 case DW_CFA_advance_loc:
3622 if (do_debug_frames_interp)
3623 frame_display_row (fc, &need_col_headers, &max_regs);
3625 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3626 opa * fc->code_factor,
3627 fc->pc_begin + opa * fc->code_factor);
3628 fc->pc_begin += opa * fc->code_factor;
3633 if (! do_debug_frames_interp)
3634 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3635 opa, roffs * fc->data_factor);
3636 fc->col_type[opa] = DW_CFA_offset;
3637 fc->col_offset[opa] = roffs * fc->data_factor;
3640 case DW_CFA_restore:
3641 if (! do_debug_frames_interp)
3642 printf (" DW_CFA_restore: r%d\n", opa);
3643 fc->col_type[opa] = cie->col_type[opa];
3644 fc->col_offset[opa] = cie->col_offset[opa];
3647 case DW_CFA_set_loc:
3648 vma = get_encoded_value (start, fc->fde_encoding);
3649 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3650 vma += section->address + (start - section_start);
3651 start += encoded_ptr_size;
3652 if (do_debug_frames_interp)
3653 frame_display_row (fc, &need_col_headers, &max_regs);
3655 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3659 case DW_CFA_advance_loc1:
3660 ofs = byte_get (start, 1); start += 1;
3661 if (do_debug_frames_interp)
3662 frame_display_row (fc, &need_col_headers, &max_regs);
3664 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3665 ofs * fc->code_factor,
3666 fc->pc_begin + ofs * fc->code_factor);
3667 fc->pc_begin += ofs * fc->code_factor;
3670 case DW_CFA_advance_loc2:
3671 ofs = byte_get (start, 2); start += 2;
3672 if (do_debug_frames_interp)
3673 frame_display_row (fc, &need_col_headers, &max_regs);
3675 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3676 ofs * fc->code_factor,
3677 fc->pc_begin + ofs * fc->code_factor);
3678 fc->pc_begin += ofs * fc->code_factor;
3681 case DW_CFA_advance_loc4:
3682 ofs = byte_get (start, 4); start += 4;
3683 if (do_debug_frames_interp)
3684 frame_display_row (fc, &need_col_headers, &max_regs);
3686 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3687 ofs * fc->code_factor,
3688 fc->pc_begin + ofs * fc->code_factor);
3689 fc->pc_begin += ofs * fc->code_factor;
3692 case DW_CFA_offset_extended:
3695 if (! do_debug_frames_interp)
3696 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3697 reg, roffs * fc->data_factor);
3698 fc->col_type[reg] = DW_CFA_offset;
3699 fc->col_offset[reg] = roffs * fc->data_factor;
3702 case DW_CFA_val_offset:
3705 if (! do_debug_frames_interp)
3706 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3707 reg, roffs * fc->data_factor);
3708 fc->col_type[reg] = DW_CFA_val_offset;
3709 fc->col_offset[reg] = roffs * fc->data_factor;
3712 case DW_CFA_restore_extended:
3714 if (! do_debug_frames_interp)
3715 printf (" DW_CFA_restore_extended: r%ld\n", reg);
3716 fc->col_type[reg] = cie->col_type[reg];
3717 fc->col_offset[reg] = cie->col_offset[reg];
3720 case DW_CFA_undefined:
3722 if (! do_debug_frames_interp)
3723 printf (" DW_CFA_undefined: r%ld\n", reg);
3724 fc->col_type[reg] = DW_CFA_undefined;
3725 fc->col_offset[reg] = 0;
3728 case DW_CFA_same_value:
3730 if (! do_debug_frames_interp)
3731 printf (" DW_CFA_same_value: r%ld\n", reg);
3732 fc->col_type[reg] = DW_CFA_same_value;
3733 fc->col_offset[reg] = 0;
3736 case DW_CFA_register:
3739 if (! do_debug_frames_interp)
3740 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3741 fc->col_type[reg] = DW_CFA_register;
3742 fc->col_offset[reg] = roffs;
3745 case DW_CFA_remember_state:
3746 if (! do_debug_frames_interp)
3747 printf (" DW_CFA_remember_state\n");
3748 rs = xmalloc (sizeof (Frame_Chunk));
3749 rs->ncols = fc->ncols;
3750 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3751 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3752 memcpy (rs->col_type, fc->col_type, rs->ncols);
3753 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3754 rs->next = remembered_state;
3755 remembered_state = rs;
3758 case DW_CFA_restore_state:
3759 if (! do_debug_frames_interp)
3760 printf (" DW_CFA_restore_state\n");
3761 rs = remembered_state;
3764 remembered_state = rs->next;
3765 frame_need_space (fc, rs->ncols - 1);
3766 memcpy (fc->col_type, rs->col_type, rs->ncols);
3767 memcpy (fc->col_offset, rs->col_offset,
3768 rs->ncols * sizeof (int));
3769 free (rs->col_type);
3770 free (rs->col_offset);
3773 else if (do_debug_frames_interp)
3774 printf ("Mismatched DW_CFA_restore_state\n");
3777 case DW_CFA_def_cfa:
3778 fc->cfa_reg = LEB ();
3779 fc->cfa_offset = LEB ();
3781 if (! do_debug_frames_interp)
3782 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3783 fc->cfa_reg, fc->cfa_offset);
3786 case DW_CFA_def_cfa_register:
3787 fc->cfa_reg = LEB ();
3789 if (! do_debug_frames_interp)
3790 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3793 case DW_CFA_def_cfa_offset:
3794 fc->cfa_offset = LEB ();
3795 if (! do_debug_frames_interp)
3796 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3800 if (! do_debug_frames_interp)
3801 printf (" DW_CFA_nop\n");
3804 case DW_CFA_def_cfa_expression:
3806 if (! do_debug_frames_interp)
3808 printf (" DW_CFA_def_cfa_expression (");
3809 decode_location_expression (start, eh_addr_size, ul, 0);
3816 case DW_CFA_expression:
3819 if (! do_debug_frames_interp)
3821 printf (" DW_CFA_expression: r%ld (", reg);
3822 decode_location_expression (start, eh_addr_size, ul, 0);
3825 fc->col_type[reg] = DW_CFA_expression;
3829 case DW_CFA_val_expression:
3832 if (! do_debug_frames_interp)
3834 printf (" DW_CFA_val_expression: r%ld (", reg);
3835 decode_location_expression (start, eh_addr_size, ul, 0);
3838 fc->col_type[reg] = DW_CFA_val_expression;
3842 case DW_CFA_offset_extended_sf:
3845 frame_need_space (fc, reg);
3846 if (! do_debug_frames_interp)
3847 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3848 reg, l * fc->data_factor);
3849 fc->col_type[reg] = DW_CFA_offset;
3850 fc->col_offset[reg] = l * fc->data_factor;
3853 case DW_CFA_val_offset_sf:
3856 frame_need_space (fc, reg);
3857 if (! do_debug_frames_interp)
3858 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3859 reg, l * fc->data_factor);
3860 fc->col_type[reg] = DW_CFA_val_offset;
3861 fc->col_offset[reg] = l * fc->data_factor;
3864 case DW_CFA_def_cfa_sf:
3865 fc->cfa_reg = LEB ();
3866 fc->cfa_offset = SLEB ();
3867 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3869 if (! do_debug_frames_interp)
3870 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3871 fc->cfa_reg, fc->cfa_offset);
3874 case DW_CFA_def_cfa_offset_sf:
3875 fc->cfa_offset = SLEB ();
3876 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3877 if (! do_debug_frames_interp)
3878 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3881 case DW_CFA_MIPS_advance_loc8:
3882 ofs = byte_get (start, 8); start += 8;
3883 if (do_debug_frames_interp)
3884 frame_display_row (fc, &need_col_headers, &max_regs);
3886 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3887 ofs * fc->code_factor,
3888 fc->pc_begin + ofs * fc->code_factor);
3889 fc->pc_begin += ofs * fc->code_factor;
3892 case DW_CFA_GNU_window_save:
3893 if (! do_debug_frames_interp)
3894 printf (" DW_CFA_GNU_window_save\n");
3897 case DW_CFA_GNU_args_size:
3899 if (! do_debug_frames_interp)
3900 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
3903 case DW_CFA_GNU_negative_offset_extended:
3906 frame_need_space (fc, reg);
3907 if (! do_debug_frames_interp)
3908 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3909 reg, l * fc->data_factor);
3910 fc->col_type[reg] = DW_CFA_offset;
3911 fc->col_offset[reg] = l * fc->data_factor;
3915 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3916 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3918 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3923 if (do_debug_frames_interp)
3924 frame_display_row (fc, &need_col_headers, &max_regs);
3939 display_debug_not_supported (struct dwarf_section *section,
3940 void *file ATTRIBUTE_UNUSED)
3942 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3949 cmalloc (size_t nmemb, size_t size)
3951 /* Check for overflow. */
3952 if (nmemb >= ~(size_t) 0 / size)
3955 return malloc (nmemb * size);
3959 xcmalloc (size_t nmemb, size_t size)
3961 /* Check for overflow. */
3962 if (nmemb >= ~(size_t) 0 / size)
3965 return xmalloc (nmemb * size);
3969 xcrealloc (void *ptr, size_t nmemb, size_t size)
3971 /* Check for overflow. */
3972 if (nmemb >= ~(size_t) 0 / size)
3975 return xrealloc (ptr, nmemb * size);
3979 error (const char *message, ...)
3983 va_start (args, message);
3984 fprintf (stderr, _("%s: Error: "), program_name);
3985 vfprintf (stderr, message, args);
3990 warn (const char *message, ...)
3994 va_start (args, message);
3995 fprintf (stderr, _("%s: Warning: "), program_name);
3996 vfprintf (stderr, message, args);
4001 free_debug_memory (void)
4003 enum dwarf_section_display_enum i;
4007 for (i = 0; i < max; i++)
4008 free_debug_section (i);
4010 if (debug_information != NULL)
4012 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
4014 for (i = 0; i < num_debug_info_entries; i++)
4016 if (!debug_information [i].max_loc_offsets)
4018 free (debug_information [i].loc_offsets);
4019 free (debug_information [i].have_frame_base);
4021 if (!debug_information [i].max_range_lists)
4022 free (debug_information [i].range_lists);
4026 free (debug_information);
4027 debug_information = NULL;
4028 num_debug_info_entries = 0;
4032 struct dwarf_section_display debug_displays[] =
4034 { { ".debug_abbrev", NULL, 0, 0 },
4035 display_debug_abbrev, 0, 0 },
4036 { { ".debug_aranges", NULL, 0, 0 },
4037 display_debug_aranges, 0, 0 },
4038 { { ".debug_frame", NULL, 0, 0 },
4039 display_debug_frames, 1, 0 },
4040 { { ".debug_info", NULL, 0, 0 },
4041 display_debug_info, 1, 0 },
4042 { { ".debug_line", NULL, 0, 0 },
4043 display_debug_lines, 0, 0 },
4044 { { ".debug_pubnames", NULL, 0, 0 },
4045 display_debug_pubnames, 0, 0 },
4046 { { ".eh_frame", NULL, 0, 0 },
4047 display_debug_frames, 1, 1 },
4048 { { ".debug_macinfo", NULL, 0, 0 },
4049 display_debug_macinfo, 0, 0 },
4050 { { ".debug_str", NULL, 0, 0 },
4051 display_debug_str, 0, 0 },
4052 { { ".debug_loc", NULL, 0, 0 },
4053 display_debug_loc, 0, 0 },
4054 { { ".debug_pubtypes", NULL, 0, 0 },
4055 display_debug_pubnames, 0, 0 },
4056 { { ".debug_ranges", NULL, 0, 0 },
4057 display_debug_ranges, 0, 0 },
4058 { { ".debug_static_func", NULL, 0, 0 },
4059 display_debug_not_supported, 0, 0 },
4060 { { ".debug_static_vars", NULL, 0, 0 },
4061 display_debug_not_supported, 0, 0 },
4062 { { ".debug_types", NULL, 0, 0 },
4063 display_debug_not_supported, 0, 0 },
4064 { { ".debug_weaknames", NULL, 0, 0 },
4065 display_debug_not_supported, 0, 0 }