1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/common.h"
27 #include "elf/dwarf2.h"
30 static int have_frame_base;
31 static int need_base_address;
33 static unsigned int last_pointer_size = 0;
34 static int warned_about_missing_comp_units = FALSE;
36 static unsigned int num_debug_info_entries = 0;
37 static debug_info *debug_information = NULL;
38 /* Special value for num_debug_info_entries to indicate
39 that the .debug_info section could not be loaded/parsed. */
40 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
47 int do_debug_pubnames;
51 int do_debug_frames_interp;
56 dwarf_vma (*byte_get) (unsigned char *, int);
59 byte_get_little_endian (unsigned char *field, int size)
67 return ((unsigned int) (field[0]))
68 | (((unsigned int) (field[1])) << 8);
71 return ((unsigned long) (field[0]))
72 | (((unsigned long) (field[1])) << 8)
73 | (((unsigned long) (field[2])) << 16)
74 | (((unsigned long) (field[3])) << 24);
77 if (sizeof (dwarf_vma) == 8)
78 return ((dwarf_vma) (field[0]))
79 | (((dwarf_vma) (field[1])) << 8)
80 | (((dwarf_vma) (field[2])) << 16)
81 | (((dwarf_vma) (field[3])) << 24)
82 | (((dwarf_vma) (field[4])) << 32)
83 | (((dwarf_vma) (field[5])) << 40)
84 | (((dwarf_vma) (field[6])) << 48)
85 | (((dwarf_vma) (field[7])) << 56);
86 else if (sizeof (dwarf_vma) == 4)
87 /* We want to extract data from an 8 byte wide field and
88 place it into a 4 byte wide field. Since this is a little
89 endian source we can just use the 4 byte extraction code. */
90 return ((unsigned long) (field[0]))
91 | (((unsigned long) (field[1])) << 8)
92 | (((unsigned long) (field[2])) << 16)
93 | (((unsigned long) (field[3])) << 24);
96 error (_("Unhandled data length: %d\n"), size);
102 byte_get_big_endian (unsigned char *field, int size)
110 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
113 return ((unsigned long) (field[3]))
114 | (((unsigned long) (field[2])) << 8)
115 | (((unsigned long) (field[1])) << 16)
116 | (((unsigned long) (field[0])) << 24);
119 if (sizeof (dwarf_vma) == 8)
120 return ((dwarf_vma) (field[7]))
121 | (((dwarf_vma) (field[6])) << 8)
122 | (((dwarf_vma) (field[5])) << 16)
123 | (((dwarf_vma) (field[4])) << 24)
124 | (((dwarf_vma) (field[3])) << 32)
125 | (((dwarf_vma) (field[2])) << 40)
126 | (((dwarf_vma) (field[1])) << 48)
127 | (((dwarf_vma) (field[0])) << 56);
128 else if (sizeof (dwarf_vma) == 4)
130 /* Although we are extracing data from an 8 byte wide field,
131 we are returning only 4 bytes of data. */
133 return ((unsigned long) (field[3]))
134 | (((unsigned long) (field[2])) << 8)
135 | (((unsigned long) (field[1])) << 16)
136 | (((unsigned long) (field[0])) << 24);
140 error (_("Unhandled data length: %d\n"), size);
146 byte_get_signed (unsigned char *field, int size)
148 dwarf_vma x = byte_get (field, size);
153 return (x ^ 0x80) - 0x80;
155 return (x ^ 0x8000) - 0x8000;
157 return (x ^ 0x80000000) - 0x80000000;
165 /* Print a dwarf_vma value (typically an address, offset or length) in
166 hexadecimal format, followed by a space. The length of the value (and
167 hence the precision displayed) is determined by the byte_size parameter. */
170 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
172 static char buff[18];
174 /* Printf does not have a way of specifiying a maximum field width for an
175 integer value, so we print the full value into a buffer and then select
176 the precision we need. */
177 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
178 snprintf (buff, sizeof (buff), "%16.16llx ", val);
180 snprintf (buff, sizeof (buff), "%16.16lx ", val);
183 printf (buff + (byte_size == 4 ? 8 : 0));
186 static unsigned long int
187 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
189 unsigned long int result = 0;
190 unsigned int num_read = 0;
191 unsigned int shift = 0;
199 result |= ((unsigned long int) (byte & 0x7f)) << shift;
206 if (length_return != NULL)
207 *length_return = num_read;
209 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
210 result |= -1L << shift;
215 typedef struct State_Machine_Registers
217 unsigned long address;
224 /* This variable hold the number of the last entry seen
225 in the File Table. */
226 unsigned int last_file_entry;
229 static SMR state_machine_regs;
232 reset_state_machine (int is_stmt)
234 state_machine_regs.address = 0;
235 state_machine_regs.file = 1;
236 state_machine_regs.line = 1;
237 state_machine_regs.column = 0;
238 state_machine_regs.is_stmt = is_stmt;
239 state_machine_regs.basic_block = 0;
240 state_machine_regs.end_sequence = 0;
241 state_machine_regs.last_file_entry = 0;
244 /* Handled an extend line op.
245 Returns the number of bytes read. */
248 process_extended_line_op (unsigned char *data, int is_stmt)
250 unsigned char op_code;
251 unsigned int bytes_read;
256 len = read_leb128 (data, & bytes_read, 0);
261 warn (_("badly formed extended line op encountered!\n"));
268 printf (_(" Extended opcode %d: "), op_code);
272 case DW_LNE_end_sequence:
273 printf (_("End of Sequence\n\n"));
274 reset_state_machine (is_stmt);
277 case DW_LNE_set_address:
278 adr = byte_get (data, len - bytes_read - 1);
279 printf (_("set Address to 0x%lx\n"), adr);
280 state_machine_regs.address = adr;
283 case DW_LNE_define_file:
284 printf (_(" define new File Table entry\n"));
285 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
287 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
289 data += strlen ((char *) data) + 1;
290 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
292 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
294 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
295 printf (_("%s\n\n"), name);
299 case DW_LNE_HP_negate_is_UV_update:
300 printf ("DW_LNE_HP_negate_is_UV_update");
302 case DW_LNE_HP_push_context:
303 printf ("DW_LNE_HP_push_context");
305 case DW_LNE_HP_pop_context:
306 printf ("DW_LNE_HP_pop_context");
308 case DW_LNE_HP_set_file_line_column:
309 printf ("DW_LNE_HP_set_file_line_column");
311 case DW_LNE_HP_set_routine_name:
312 printf ("DW_LNE_HP_set_routine_name");
314 case DW_LNE_HP_set_sequence:
315 printf ("DW_LNE_HP_set_sequence");
317 case DW_LNE_HP_negate_post_semantics:
318 printf ("DW_LNE_HP_negate_post_semantics");
320 case DW_LNE_HP_negate_function_exit:
321 printf ("DW_LNE_HP_negate_function_exit");
323 case DW_LNE_HP_negate_front_end_logical:
324 printf ("DW_LNE_HP_negate_front_end_logical");
326 case DW_LNE_HP_define_proc:
327 printf ("DW_LNE_HP_define_proc");
331 if (op_code >= DW_LNE_lo_user
332 /* The test against DW_LNW_hi_user is redundant due to
333 the limited range of the unsigned char data type used
335 /*&& op_code <= DW_LNE_hi_user*/)
336 printf (_("user defined: length %d\n"), len - bytes_read);
338 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
346 fetch_indirect_string (unsigned long offset)
348 struct dwarf_section *section = &debug_displays [str].section;
350 if (section->start == NULL)
351 return _("<no .debug_str section>");
353 /* DWARF sections under Mach-O have non-zero addresses. */
354 offset -= section->address;
355 if (offset > section->size)
357 warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
358 return _("<offset is too big>");
361 return (const char *) section->start + offset;
364 /* FIXME: There are better and more efficient ways to handle
365 these structures. For now though, I just want something that
366 is simple to implement. */
367 typedef struct abbrev_attr
369 unsigned long attribute;
371 struct abbrev_attr *next;
375 typedef struct abbrev_entry
380 struct abbrev_attr *first_attr;
381 struct abbrev_attr *last_attr;
382 struct abbrev_entry *next;
386 static abbrev_entry *first_abbrev = NULL;
387 static abbrev_entry *last_abbrev = NULL;
392 abbrev_entry *abbrev;
394 for (abbrev = first_abbrev; abbrev;)
396 abbrev_entry *next = abbrev->next;
399 for (attr = abbrev->first_attr; attr;)
401 abbrev_attr *next = attr->next;
411 last_abbrev = first_abbrev = NULL;
415 add_abbrev (unsigned long number, unsigned long tag, int children)
419 entry = malloc (sizeof (*entry));
425 entry->entry = number;
427 entry->children = children;
428 entry->first_attr = NULL;
429 entry->last_attr = NULL;
432 if (first_abbrev == NULL)
433 first_abbrev = entry;
435 last_abbrev->next = entry;
441 add_abbrev_attr (unsigned long attribute, unsigned long form)
445 attr = malloc (sizeof (*attr));
451 attr->attribute = attribute;
455 if (last_abbrev->first_attr == NULL)
456 last_abbrev->first_attr = attr;
458 last_abbrev->last_attr->next = attr;
460 last_abbrev->last_attr = attr;
463 /* Processes the (partial) contents of a .debug_abbrev section.
464 Returns NULL if the end of the section was encountered.
465 Returns the address after the last byte read if the end of
466 an abbreviation set was found. */
468 static unsigned char *
469 process_abbrev_section (unsigned char *start, unsigned char *end)
471 if (first_abbrev != NULL)
476 unsigned int bytes_read;
479 unsigned long attribute;
482 entry = read_leb128 (start, & bytes_read, 0);
485 /* A single zero is supposed to end the section according
486 to the standard. If there's more, then signal that to
489 return start == end ? NULL : start;
491 tag = read_leb128 (start, & bytes_read, 0);
496 add_abbrev (entry, tag, children);
502 attribute = read_leb128 (start, & bytes_read, 0);
505 form = read_leb128 (start, & bytes_read, 0);
509 add_abbrev_attr (attribute, form);
511 while (attribute != 0);
518 get_TAG_name (unsigned long tag)
522 case DW_TAG_padding: return "DW_TAG_padding";
523 case DW_TAG_array_type: return "DW_TAG_array_type";
524 case DW_TAG_class_type: return "DW_TAG_class_type";
525 case DW_TAG_entry_point: return "DW_TAG_entry_point";
526 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
527 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
528 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
529 case DW_TAG_label: return "DW_TAG_label";
530 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
531 case DW_TAG_member: return "DW_TAG_member";
532 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
533 case DW_TAG_reference_type: return "DW_TAG_reference_type";
534 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
535 case DW_TAG_string_type: return "DW_TAG_string_type";
536 case DW_TAG_structure_type: return "DW_TAG_structure_type";
537 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
538 case DW_TAG_typedef: return "DW_TAG_typedef";
539 case DW_TAG_union_type: return "DW_TAG_union_type";
540 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
541 case DW_TAG_variant: return "DW_TAG_variant";
542 case DW_TAG_common_block: return "DW_TAG_common_block";
543 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
544 case DW_TAG_inheritance: return "DW_TAG_inheritance";
545 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
546 case DW_TAG_module: return "DW_TAG_module";
547 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
548 case DW_TAG_set_type: return "DW_TAG_set_type";
549 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
550 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
551 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
552 case DW_TAG_base_type: return "DW_TAG_base_type";
553 case DW_TAG_catch_block: return "DW_TAG_catch_block";
554 case DW_TAG_const_type: return "DW_TAG_const_type";
555 case DW_TAG_constant: return "DW_TAG_constant";
556 case DW_TAG_enumerator: return "DW_TAG_enumerator";
557 case DW_TAG_file_type: return "DW_TAG_file_type";
558 case DW_TAG_friend: return "DW_TAG_friend";
559 case DW_TAG_namelist: return "DW_TAG_namelist";
560 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
561 case DW_TAG_packed_type: return "DW_TAG_packed_type";
562 case DW_TAG_subprogram: return "DW_TAG_subprogram";
563 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
564 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
565 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
566 case DW_TAG_try_block: return "DW_TAG_try_block";
567 case DW_TAG_variant_part: return "DW_TAG_variant_part";
568 case DW_TAG_variable: return "DW_TAG_variable";
569 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
570 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
571 case DW_TAG_format_label: return "DW_TAG_format_label";
572 case DW_TAG_function_template: return "DW_TAG_function_template";
573 case DW_TAG_class_template: return "DW_TAG_class_template";
574 /* DWARF 2.1 values. */
575 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
576 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
577 case DW_TAG_interface_type: return "DW_TAG_interface_type";
578 case DW_TAG_namespace: return "DW_TAG_namespace";
579 case DW_TAG_imported_module: return "DW_TAG_imported_module";
580 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
581 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
582 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
584 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
585 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
586 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
589 static char buffer[100];
591 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
598 get_FORM_name (unsigned long form)
602 case DW_FORM_addr: return "DW_FORM_addr";
603 case DW_FORM_block2: return "DW_FORM_block2";
604 case DW_FORM_block4: return "DW_FORM_block4";
605 case DW_FORM_data2: return "DW_FORM_data2";
606 case DW_FORM_data4: return "DW_FORM_data4";
607 case DW_FORM_data8: return "DW_FORM_data8";
608 case DW_FORM_string: return "DW_FORM_string";
609 case DW_FORM_block: return "DW_FORM_block";
610 case DW_FORM_block1: return "DW_FORM_block1";
611 case DW_FORM_data1: return "DW_FORM_data1";
612 case DW_FORM_flag: return "DW_FORM_flag";
613 case DW_FORM_sdata: return "DW_FORM_sdata";
614 case DW_FORM_strp: return "DW_FORM_strp";
615 case DW_FORM_udata: return "DW_FORM_udata";
616 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
617 case DW_FORM_ref1: return "DW_FORM_ref1";
618 case DW_FORM_ref2: return "DW_FORM_ref2";
619 case DW_FORM_ref4: return "DW_FORM_ref4";
620 case DW_FORM_ref8: return "DW_FORM_ref8";
621 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
622 case DW_FORM_indirect: return "DW_FORM_indirect";
625 static char buffer[100];
627 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
633 static unsigned char *
634 display_block (unsigned char *data, unsigned long length)
636 printf (_(" %lu byte block: "), length);
639 printf ("%lx ", (unsigned long) byte_get (data++, 1));
645 decode_location_expression (unsigned char * data,
646 unsigned int pointer_size,
647 unsigned long length,
648 unsigned long cu_offset)
651 unsigned int bytes_read;
652 unsigned long uvalue;
653 unsigned char *end = data + length;
654 int need_frame_base = 0;
663 printf ("DW_OP_addr: %lx",
664 (unsigned long) byte_get (data, pointer_size));
665 data += pointer_size;
668 printf ("DW_OP_deref");
671 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
674 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
677 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
681 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
685 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
689 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
693 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
694 (unsigned long) byte_get (data + 4, 4));
698 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
699 (long) byte_get (data + 4, 4));
703 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
707 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
711 printf ("DW_OP_dup");
714 printf ("DW_OP_drop");
717 printf ("DW_OP_over");
720 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
723 printf ("DW_OP_swap");
726 printf ("DW_OP_rot");
729 printf ("DW_OP_xderef");
732 printf ("DW_OP_abs");
735 printf ("DW_OP_and");
738 printf ("DW_OP_div");
741 printf ("DW_OP_minus");
744 printf ("DW_OP_mod");
747 printf ("DW_OP_mul");
750 printf ("DW_OP_neg");
753 printf ("DW_OP_not");
759 printf ("DW_OP_plus");
761 case DW_OP_plus_uconst:
762 printf ("DW_OP_plus_uconst: %lu",
763 read_leb128 (data, &bytes_read, 0));
767 printf ("DW_OP_shl");
770 printf ("DW_OP_shr");
773 printf ("DW_OP_shra");
776 printf ("DW_OP_xor");
779 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
801 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
837 printf ("DW_OP_lit%d", op - DW_OP_lit0);
872 printf ("DW_OP_reg%d", op - DW_OP_reg0);
907 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
908 read_leb128 (data, &bytes_read, 1));
913 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
918 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
922 uvalue = read_leb128 (data, &bytes_read, 0);
924 printf ("DW_OP_bregx: %lu %ld", uvalue,
925 read_leb128 (data, &bytes_read, 1));
929 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
932 case DW_OP_deref_size:
933 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
935 case DW_OP_xderef_size:
936 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
939 printf ("DW_OP_nop");
942 /* DWARF 3 extensions. */
943 case DW_OP_push_object_address:
944 printf ("DW_OP_push_object_address");
947 /* XXX: Strictly speaking for 64-bit DWARF3 files
948 this ought to be an 8-byte wide computation. */
949 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
953 /* XXX: Strictly speaking for 64-bit DWARF3 files
954 this ought to be an 8-byte wide computation. */
955 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
959 /* XXX: Strictly speaking for 64-bit DWARF3 files
960 this ought to be an 8-byte wide computation. */
961 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
964 case DW_OP_form_tls_address:
965 printf ("DW_OP_form_tls_address");
967 case DW_OP_call_frame_cfa:
968 printf ("DW_OP_call_frame_cfa");
970 case DW_OP_bit_piece:
971 printf ("DW_OP_bit_piece: ");
972 printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
974 printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
978 /* GNU extensions. */
979 case DW_OP_GNU_push_tls_address:
980 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
982 case DW_OP_GNU_uninit:
983 printf ("DW_OP_GNU_uninit");
984 /* FIXME: Is there data associated with this OP ? */
988 case DW_OP_HP_is_value:
989 printf ("DW_OP_HP_is_value");
990 /* FIXME: Is there data associated with this OP ? */
992 case DW_OP_HP_fltconst4:
993 printf ("DW_OP_HP_fltconst4");
994 /* FIXME: Is there data associated with this OP ? */
996 case DW_OP_HP_fltconst8:
997 printf ("DW_OP_HP_fltconst8");
998 /* FIXME: Is there data associated with this OP ? */
1000 case DW_OP_HP_mod_range:
1001 printf ("DW_OP_HP_mod_range");
1002 /* FIXME: Is there data associated with this OP ? */
1004 case DW_OP_HP_unmod_range:
1005 printf ("DW_OP_HP_unmod_range");
1006 /* FIXME: Is there data associated with this OP ? */
1009 printf ("DW_OP_HP_tls");
1010 /* FIXME: Is there data associated with this OP ? */
1014 if (op >= DW_OP_lo_user
1015 && op <= DW_OP_hi_user)
1016 printf (_("(User defined location op)"));
1018 printf (_("(Unknown location op)"));
1019 /* No way to tell where the next op is, so just bail. */
1020 return need_frame_base;
1023 /* Separate the ops. */
1028 return need_frame_base;
1031 static unsigned char *
1032 read_and_display_attr_value (unsigned long attribute,
1034 unsigned char * data,
1035 unsigned long cu_offset,
1036 unsigned long pointer_size,
1037 unsigned long offset_size,
1039 debug_info * debug_info_p,
1041 struct dwarf_section * section)
1043 unsigned long uvalue = 0;
1044 unsigned char *block_start = NULL;
1045 unsigned char * orig_data = data;
1046 unsigned int bytes_read;
1053 case DW_FORM_ref_addr:
1054 if (dwarf_version == 2)
1056 uvalue = byte_get (data, pointer_size);
1057 data += pointer_size;
1059 else if (dwarf_version == 3)
1061 uvalue = byte_get (data, offset_size);
1062 data += offset_size;
1066 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1071 uvalue = byte_get (data, pointer_size);
1072 data += pointer_size;
1076 uvalue = byte_get (data, offset_size);
1077 data += offset_size;
1083 uvalue = byte_get (data++, 1);
1088 uvalue = byte_get (data, 2);
1094 uvalue = byte_get (data, 4);
1099 uvalue = read_leb128 (data, & bytes_read, 1);
1103 case DW_FORM_ref_udata:
1105 uvalue = read_leb128 (data, & bytes_read, 0);
1109 case DW_FORM_indirect:
1110 form = read_leb128 (data, & bytes_read, 0);
1113 printf (" %s", get_FORM_name (form));
1114 return read_and_display_attr_value (attribute, form, data,
1115 cu_offset, pointer_size,
1116 offset_size, dwarf_version,
1117 debug_info_p, do_loc,
1123 case DW_FORM_ref_addr:
1125 printf (" <0x%lx>", uvalue);
1131 case DW_FORM_ref_udata:
1133 printf (" <0x%lx>", uvalue + cu_offset);
1139 printf (" 0x%lx", uvalue);
1148 printf (" %ld", uvalue);
1155 uvalue = byte_get (data, 4);
1156 printf (" 0x%lx", uvalue);
1157 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1159 if ((do_loc || do_debug_loc || do_debug_ranges)
1160 && num_debug_info_entries == 0)
1162 if (sizeof (uvalue) == 8)
1163 uvalue = byte_get (data, 8);
1165 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1170 case DW_FORM_string:
1172 printf (" %s", data);
1173 data += strlen ((char *) data) + 1;
1177 uvalue = read_leb128 (data, & bytes_read, 0);
1178 block_start = data + bytes_read;
1180 data = block_start + uvalue;
1182 data = display_block (block_start, uvalue);
1185 case DW_FORM_block1:
1186 uvalue = byte_get (data, 1);
1187 block_start = data + 1;
1189 data = block_start + uvalue;
1191 data = display_block (block_start, uvalue);
1194 case DW_FORM_block2:
1195 uvalue = byte_get (data, 2);
1196 block_start = data + 2;
1198 data = block_start + uvalue;
1200 data = display_block (block_start, uvalue);
1203 case DW_FORM_block4:
1204 uvalue = byte_get (data, 4);
1205 block_start = data + 4;
1207 data = block_start + uvalue;
1209 data = display_block (block_start, uvalue);
1214 printf (_(" (indirect string, offset: 0x%lx): %s"),
1215 uvalue, fetch_indirect_string (uvalue));
1218 case DW_FORM_indirect:
1219 /* Handled above. */
1223 warn (_("Unrecognized form: %lu\n"), form);
1227 if ((do_loc || do_debug_loc || do_debug_ranges)
1228 && num_debug_info_entries == 0)
1232 case DW_AT_frame_base:
1233 have_frame_base = 1;
1234 case DW_AT_location:
1235 case DW_AT_string_length:
1236 case DW_AT_return_addr:
1237 case DW_AT_data_member_location:
1238 case DW_AT_vtable_elem_location:
1240 case DW_AT_static_link:
1241 case DW_AT_use_location:
1242 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1244 /* Process location list. */
1245 unsigned int max = debug_info_p->max_loc_offsets;
1246 unsigned int num = debug_info_p->num_loc_offsets;
1248 if (max == 0 || num >= max)
1251 debug_info_p->loc_offsets
1252 = xcrealloc (debug_info_p->loc_offsets,
1253 max, sizeof (*debug_info_p->loc_offsets));
1254 debug_info_p->have_frame_base
1255 = xcrealloc (debug_info_p->have_frame_base,
1256 max, sizeof (*debug_info_p->have_frame_base));
1257 debug_info_p->max_loc_offsets = max;
1259 debug_info_p->loc_offsets [num] = uvalue;
1260 debug_info_p->have_frame_base [num] = have_frame_base;
1261 debug_info_p->num_loc_offsets++;
1266 if (need_base_address)
1267 debug_info_p->base_address = uvalue;
1271 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1273 /* Process range list. */
1274 unsigned int max = debug_info_p->max_range_lists;
1275 unsigned int num = debug_info_p->num_range_lists;
1277 if (max == 0 || num >= max)
1280 debug_info_p->range_lists
1281 = xcrealloc (debug_info_p->range_lists,
1282 max, sizeof (*debug_info_p->range_lists));
1283 debug_info_p->max_range_lists = max;
1285 debug_info_p->range_lists [num] = uvalue;
1286 debug_info_p->num_range_lists++;
1298 /* For some attributes we can display further information. */
1306 case DW_INL_not_inlined:
1307 printf (_("(not inlined)"));
1309 case DW_INL_inlined:
1310 printf (_("(inlined)"));
1312 case DW_INL_declared_not_inlined:
1313 printf (_("(declared as inline but ignored)"));
1315 case DW_INL_declared_inlined:
1316 printf (_("(declared as inline and inlined)"));
1319 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1324 case DW_AT_language:
1327 /* Ordered by the numeric value of these constants. */
1328 case DW_LANG_C89: printf ("(ANSI C)"); break;
1329 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1330 case DW_LANG_Ada83: printf ("(Ada)"); break;
1331 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1332 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1333 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1334 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1335 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1336 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1337 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1338 /* DWARF 2.1 values. */
1339 case DW_LANG_Java: printf ("(Java)"); break;
1340 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1341 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1342 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1343 /* DWARF 3 values. */
1344 case DW_LANG_PLI: printf ("(PLI)"); break;
1345 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1346 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1347 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1348 case DW_LANG_D: printf ("(D)"); break;
1349 /* MIPS extension. */
1350 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1351 /* UPC extension. */
1352 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1354 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1355 printf ("(implementation defined: %lx)", uvalue);
1357 printf ("(Unknown: %lx)", uvalue);
1362 case DW_AT_encoding:
1365 case DW_ATE_void: printf ("(void)"); break;
1366 case DW_ATE_address: printf ("(machine address)"); break;
1367 case DW_ATE_boolean: printf ("(boolean)"); break;
1368 case DW_ATE_complex_float: printf ("(complex float)"); break;
1369 case DW_ATE_float: printf ("(float)"); break;
1370 case DW_ATE_signed: printf ("(signed)"); break;
1371 case DW_ATE_signed_char: printf ("(signed char)"); break;
1372 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1373 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1374 /* DWARF 2.1 values: */
1375 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1376 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1377 /* DWARF 3 values: */
1378 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1379 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1380 case DW_ATE_edited: printf ("(edited)"); break;
1381 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1382 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1383 /* HP extensions: */
1384 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1385 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1386 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1387 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1388 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1389 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1390 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1393 if (uvalue >= DW_ATE_lo_user
1394 && uvalue <= DW_ATE_hi_user)
1395 printf ("(user defined type)");
1397 printf ("(unknown type)");
1402 case DW_AT_accessibility:
1405 case DW_ACCESS_public: printf ("(public)"); break;
1406 case DW_ACCESS_protected: printf ("(protected)"); break;
1407 case DW_ACCESS_private: printf ("(private)"); break;
1409 printf ("(unknown accessibility)");
1414 case DW_AT_visibility:
1417 case DW_VIS_local: printf ("(local)"); break;
1418 case DW_VIS_exported: printf ("(exported)"); break;
1419 case DW_VIS_qualified: printf ("(qualified)"); break;
1420 default: printf ("(unknown visibility)"); break;
1424 case DW_AT_virtuality:
1427 case DW_VIRTUALITY_none: printf ("(none)"); break;
1428 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1429 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1430 default: printf ("(unknown virtuality)"); break;
1434 case DW_AT_identifier_case:
1437 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1438 case DW_ID_up_case: printf ("(up_case)"); break;
1439 case DW_ID_down_case: printf ("(down_case)"); break;
1440 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1441 default: printf ("(unknown case)"); break;
1445 case DW_AT_calling_convention:
1448 case DW_CC_normal: printf ("(normal)"); break;
1449 case DW_CC_program: printf ("(program)"); break;
1450 case DW_CC_nocall: printf ("(nocall)"); break;
1452 if (uvalue >= DW_CC_lo_user
1453 && uvalue <= DW_CC_hi_user)
1454 printf ("(user defined)");
1456 printf ("(unknown convention)");
1460 case DW_AT_ordering:
1463 case -1: printf ("(undefined)"); break;
1464 case 0: printf ("(row major)"); break;
1465 case 1: printf ("(column major)"); break;
1469 case DW_AT_frame_base:
1470 have_frame_base = 1;
1471 case DW_AT_location:
1472 case DW_AT_string_length:
1473 case DW_AT_return_addr:
1474 case DW_AT_data_member_location:
1475 case DW_AT_vtable_elem_location:
1477 case DW_AT_static_link:
1478 case DW_AT_use_location:
1479 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1480 printf (_("(location list)"));
1482 case DW_AT_allocated:
1483 case DW_AT_associated:
1484 case DW_AT_data_location:
1486 case DW_AT_upper_bound:
1487 case DW_AT_lower_bound:
1490 int need_frame_base;
1493 need_frame_base = decode_location_expression (block_start,
1498 if (need_frame_base && !have_frame_base)
1499 printf (_(" [without DW_AT_frame_base]"));
1505 if (form == DW_FORM_ref1
1506 || form == DW_FORM_ref2
1507 || form == DW_FORM_ref4)
1508 uvalue += cu_offset;
1510 if (uvalue >= section->size)
1511 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1512 uvalue, (long int)(orig_data - section->start));
1515 unsigned long abbrev_number;
1516 abbrev_entry * entry;
1518 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1520 printf ("[Abbrev Number: %ld", abbrev_number);
1521 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1522 if (entry->entry == abbrev_number)
1525 printf (" (%s)", get_TAG_name (entry->tag));
1539 get_AT_name (unsigned long attribute)
1543 case DW_AT_sibling: return "DW_AT_sibling";
1544 case DW_AT_location: return "DW_AT_location";
1545 case DW_AT_name: return "DW_AT_name";
1546 case DW_AT_ordering: return "DW_AT_ordering";
1547 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1548 case DW_AT_byte_size: return "DW_AT_byte_size";
1549 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1550 case DW_AT_bit_size: return "DW_AT_bit_size";
1551 case DW_AT_element_list: return "DW_AT_element_list";
1552 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1553 case DW_AT_low_pc: return "DW_AT_low_pc";
1554 case DW_AT_high_pc: return "DW_AT_high_pc";
1555 case DW_AT_language: return "DW_AT_language";
1556 case DW_AT_member: return "DW_AT_member";
1557 case DW_AT_discr: return "DW_AT_discr";
1558 case DW_AT_discr_value: return "DW_AT_discr_value";
1559 case DW_AT_visibility: return "DW_AT_visibility";
1560 case DW_AT_import: return "DW_AT_import";
1561 case DW_AT_string_length: return "DW_AT_string_length";
1562 case DW_AT_common_reference: return "DW_AT_common_reference";
1563 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1564 case DW_AT_const_value: return "DW_AT_const_value";
1565 case DW_AT_containing_type: return "DW_AT_containing_type";
1566 case DW_AT_default_value: return "DW_AT_default_value";
1567 case DW_AT_inline: return "DW_AT_inline";
1568 case DW_AT_is_optional: return "DW_AT_is_optional";
1569 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1570 case DW_AT_producer: return "DW_AT_producer";
1571 case DW_AT_prototyped: return "DW_AT_prototyped";
1572 case DW_AT_return_addr: return "DW_AT_return_addr";
1573 case DW_AT_start_scope: return "DW_AT_start_scope";
1574 case DW_AT_stride_size: return "DW_AT_stride_size";
1575 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1576 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1577 case DW_AT_accessibility: return "DW_AT_accessibility";
1578 case DW_AT_address_class: return "DW_AT_address_class";
1579 case DW_AT_artificial: return "DW_AT_artificial";
1580 case DW_AT_base_types: return "DW_AT_base_types";
1581 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1582 case DW_AT_count: return "DW_AT_count";
1583 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1584 case DW_AT_decl_column: return "DW_AT_decl_column";
1585 case DW_AT_decl_file: return "DW_AT_decl_file";
1586 case DW_AT_decl_line: return "DW_AT_decl_line";
1587 case DW_AT_declaration: return "DW_AT_declaration";
1588 case DW_AT_discr_list: return "DW_AT_discr_list";
1589 case DW_AT_encoding: return "DW_AT_encoding";
1590 case DW_AT_external: return "DW_AT_external";
1591 case DW_AT_frame_base: return "DW_AT_frame_base";
1592 case DW_AT_friend: return "DW_AT_friend";
1593 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1594 case DW_AT_macro_info: return "DW_AT_macro_info";
1595 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1596 case DW_AT_priority: return "DW_AT_priority";
1597 case DW_AT_segment: return "DW_AT_segment";
1598 case DW_AT_specification: return "DW_AT_specification";
1599 case DW_AT_static_link: return "DW_AT_static_link";
1600 case DW_AT_type: return "DW_AT_type";
1601 case DW_AT_use_location: return "DW_AT_use_location";
1602 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1603 case DW_AT_virtuality: return "DW_AT_virtuality";
1604 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1605 /* DWARF 2.1 values. */
1606 case DW_AT_allocated: return "DW_AT_allocated";
1607 case DW_AT_associated: return "DW_AT_associated";
1608 case DW_AT_data_location: return "DW_AT_data_location";
1609 case DW_AT_stride: return "DW_AT_stride";
1610 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1611 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1612 case DW_AT_extension: return "DW_AT_extension";
1613 case DW_AT_ranges: return "DW_AT_ranges";
1614 case DW_AT_trampoline: return "DW_AT_trampoline";
1615 case DW_AT_call_column: return "DW_AT_call_column";
1616 case DW_AT_call_file: return "DW_AT_call_file";
1617 case DW_AT_call_line: return "DW_AT_call_line";
1618 case DW_AT_description: return "DW_AT_description";
1619 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1620 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1621 case DW_AT_small: return "DW_AT_small";
1622 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1623 case DW_AT_digit_count: return "DW_AT_digit_count";
1624 case DW_AT_picture_string: return "DW_AT_picture_string";
1625 case DW_AT_mutable: return "DW_AT_mutable";
1626 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1627 case DW_AT_explicit: return "DW_AT_explicit";
1628 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1629 case DW_AT_endianity: return "DW_AT_endianity";
1630 case DW_AT_elemental: return "DW_AT_elemental";
1631 case DW_AT_pure: return "DW_AT_pure";
1632 case DW_AT_recursive: return "DW_AT_recursive";
1634 /* HP and SGI/MIPS extensions. */
1635 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1636 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1637 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1638 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1639 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1640 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1641 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1642 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1643 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1644 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1646 /* HP Extensions. */
1647 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1648 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1649 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1650 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1651 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1652 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1653 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1654 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1655 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1656 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1657 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1658 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1659 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1661 /* One value is shared by the MIPS and HP extensions: */
1662 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1664 /* GNU extensions. */
1665 case DW_AT_sf_names: return "DW_AT_sf_names";
1666 case DW_AT_src_info: return "DW_AT_src_info";
1667 case DW_AT_mac_info: return "DW_AT_mac_info";
1668 case DW_AT_src_coords: return "DW_AT_src_coords";
1669 case DW_AT_body_begin: return "DW_AT_body_begin";
1670 case DW_AT_body_end: return "DW_AT_body_end";
1671 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1673 /* UPC extension. */
1674 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1676 /* PGI (STMicroelectronics) extensions. */
1677 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1678 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1679 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1683 static char buffer[100];
1685 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1692 static unsigned char *
1693 read_and_display_attr (unsigned long attribute,
1695 unsigned char * data,
1696 unsigned long cu_offset,
1697 unsigned long pointer_size,
1698 unsigned long offset_size,
1700 debug_info * debug_info_p,
1702 struct dwarf_section * section)
1705 printf (" %-18s:", get_AT_name (attribute));
1706 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1707 pointer_size, offset_size,
1708 dwarf_version, debug_info_p,
1716 /* Process the contents of a .debug_info section. If do_loc is non-zero
1717 then we are scanning for location lists and we do not want to display
1718 anything to the user. */
1721 process_debug_info (struct dwarf_section *section,
1725 unsigned char *start = section->start;
1726 unsigned char *end = start + section->size;
1727 unsigned char *section_begin;
1729 unsigned int num_units = 0;
1731 if ((do_loc || do_debug_loc || do_debug_ranges)
1732 && num_debug_info_entries == 0)
1734 unsigned long length;
1736 /* First scan the section to get the number of comp units. */
1737 for (section_begin = start, num_units = 0; section_begin < end;
1740 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1741 will be the length. For a 64-bit DWARF section, it'll be
1742 the escape code 0xffffffff followed by an 8 byte length. */
1743 length = byte_get (section_begin, 4);
1745 if (length == 0xffffffff)
1747 length = byte_get (section_begin + 4, 8);
1748 section_begin += length + 12;
1750 else if (length >= 0xfffffff0 && length < 0xffffffff)
1752 warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1756 section_begin += length + 4;
1758 /* Negative values are illegal, they may even cause infinite
1759 looping. This can happen if we can't accurately apply
1760 relocations to an object file. */
1761 if ((signed long) length <= 0)
1763 warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1770 error (_("No comp units in %s section ?"), section->name);
1774 /* Then allocate an array to hold the information. */
1775 debug_information = cmalloc (num_units,
1776 sizeof (* debug_information));
1777 if (debug_information == NULL)
1779 error (_("Not enough memory for a debug info array of %u entries"),
1787 printf (_("The section %s contains:\n\n"), section->name);
1789 load_debug_section (str, file);
1792 load_debug_section (abbrev, file);
1793 if (debug_displays [abbrev].section.start == NULL)
1795 warn (_("Unable to locate %s section!\n"),
1796 debug_displays [abbrev].section.name);
1800 for (section_begin = start, unit = 0; start < end; unit++)
1802 DWARF2_Internal_CompUnit compunit;
1803 unsigned char *hdrptr;
1804 unsigned char *cu_abbrev_offset_ptr;
1805 unsigned char *tags;
1807 unsigned long cu_offset;
1809 int initial_length_size;
1813 compunit.cu_length = byte_get (hdrptr, 4);
1816 if (compunit.cu_length == 0xffffffff)
1818 compunit.cu_length = byte_get (hdrptr, 8);
1821 initial_length_size = 12;
1826 initial_length_size = 4;
1829 compunit.cu_version = byte_get (hdrptr, 2);
1832 cu_offset = start - section_begin;
1834 cu_abbrev_offset_ptr = hdrptr;
1835 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1836 hdrptr += offset_size;
1838 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1840 if ((do_loc || do_debug_loc || do_debug_ranges)
1841 && num_debug_info_entries == 0)
1843 debug_information [unit].cu_offset = cu_offset;
1844 debug_information [unit].pointer_size
1845 = compunit.cu_pointer_size;
1846 debug_information [unit].base_address = 0;
1847 debug_information [unit].loc_offsets = NULL;
1848 debug_information [unit].have_frame_base = NULL;
1849 debug_information [unit].max_loc_offsets = 0;
1850 debug_information [unit].num_loc_offsets = 0;
1851 debug_information [unit].range_lists = NULL;
1852 debug_information [unit].max_range_lists= 0;
1853 debug_information [unit].num_range_lists = 0;
1858 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1859 printf (_(" Length: 0x%lx (%s)\n"), compunit.cu_length,
1860 initial_length_size == 8 ? "64-bit" : "32-bit");
1861 printf (_(" Version: %d\n"), compunit.cu_version);
1862 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1863 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1866 if (cu_offset + compunit.cu_length + initial_length_size
1869 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1870 cu_offset, compunit.cu_length);
1874 start += compunit.cu_length + initial_length_size;
1876 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1878 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1879 cu_offset, compunit.cu_version);
1885 /* Process the abbrevs used by this compilation unit. DWARF
1886 sections under Mach-O have non-zero addresses. */
1887 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1888 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1889 (unsigned long) compunit.cu_abbrev_offset,
1890 (unsigned long) debug_displays [abbrev].section.size);
1892 process_abbrev_section
1893 ((unsigned char *) debug_displays [abbrev].section.start
1894 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1895 (unsigned char *) debug_displays [abbrev].section.start
1896 + debug_displays [abbrev].section.size);
1899 while (tags < start)
1901 unsigned int bytes_read;
1902 unsigned long abbrev_number;
1903 unsigned long die_offset;
1904 abbrev_entry *entry;
1907 die_offset = tags - section_begin;
1909 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1912 /* A null DIE marks the end of a list of siblings. */
1913 if (abbrev_number == 0)
1918 static unsigned num_bogus_warns = 0;
1920 if (num_bogus_warns < 3)
1922 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1925 if (num_bogus_warns == 3)
1926 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1933 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1934 level, die_offset, abbrev_number);
1936 /* Scan through the abbreviation list until we reach the
1938 for (entry = first_abbrev;
1939 entry && entry->entry != abbrev_number;
1940 entry = entry->next)
1950 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
1951 die_offset, abbrev_number);
1956 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1961 need_base_address = 0;
1963 case DW_TAG_compile_unit:
1964 need_base_address = 1;
1966 case DW_TAG_entry_point:
1967 case DW_TAG_subprogram:
1968 need_base_address = 0;
1969 /* Assuming that there is no DW_AT_frame_base. */
1970 have_frame_base = 0;
1974 for (attr = entry->first_attr; attr; attr = attr->next)
1977 /* Show the offset from where the tag was extracted. */
1978 printf (" <%2lx>", (unsigned long)(tags - section_begin));
1980 tags = read_and_display_attr (attr->attribute,
1983 compunit.cu_pointer_size,
1985 compunit.cu_version,
1986 debug_information + unit,
1990 if (entry->children)
1995 /* Set num_debug_info_entries here so that it can be used to check if
1996 we need to process .debug_loc and .debug_ranges sections. */
1997 if ((do_loc || do_debug_loc || do_debug_ranges)
1998 && num_debug_info_entries == 0)
1999 num_debug_info_entries = num_units;
2009 /* Locate and scan the .debug_info section in the file and record the pointer
2010 sizes and offsets for the compilation units in it. Usually an executable
2011 will have just one pointer size, but this is not guaranteed, and so we try
2012 not to make any assumptions. Returns zero upon failure, or the number of
2013 compilation units upon success. */
2016 load_debug_info (void * file)
2018 /* Reset the last pointer size so that we can issue correct error
2019 messages if we are displaying the contents of more than one section. */
2020 last_pointer_size = 0;
2021 warned_about_missing_comp_units = FALSE;
2023 /* If we have already tried and failed to load the .debug_info
2024 section then do not bother to repear the task. */
2025 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2028 /* If we already have the information there is nothing else to do. */
2029 if (num_debug_info_entries > 0)
2030 return num_debug_info_entries;
2032 if (load_debug_section (info, file)
2033 && process_debug_info (&debug_displays [info].section, file, 1))
2034 return num_debug_info_entries;
2036 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2041 display_debug_lines (struct dwarf_section *section, void *file)
2043 unsigned char *start = section->start;
2044 unsigned char *data = start;
2045 unsigned char *end = start + section->size;
2047 printf (_("\nDump of debug contents of section %s:\n\n"),
2050 if (load_debug_info (file) == 0)
2052 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2059 DWARF2_Internal_LineInfo info;
2060 unsigned char *standard_opcodes;
2061 unsigned char *end_of_sequence;
2062 unsigned char *hdrptr;
2063 unsigned long hdroff;
2064 int initial_length_size;
2069 hdroff = hdrptr - start;
2071 /* Check the length of the block. */
2072 info.li_length = byte_get (hdrptr, 4);
2075 if (info.li_length == 0xffffffff)
2077 /* This section is 64-bit DWARF 3. */
2078 info.li_length = byte_get (hdrptr, 8);
2081 initial_length_size = 12;
2086 initial_length_size = 4;
2089 if (info.li_length + initial_length_size > section->size)
2092 (_("The line info appears to be corrupt - the section is too small\n"));
2096 /* Check its version number. */
2097 info.li_version = byte_get (hdrptr, 2);
2099 if (info.li_version != 2 && info.li_version != 3)
2101 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2105 info.li_prologue_length = byte_get (hdrptr, offset_size);
2106 hdrptr += offset_size;
2107 info.li_min_insn_length = byte_get (hdrptr, 1);
2109 info.li_default_is_stmt = byte_get (hdrptr, 1);
2111 info.li_line_base = byte_get (hdrptr, 1);
2113 info.li_line_range = byte_get (hdrptr, 1);
2115 info.li_opcode_base = byte_get (hdrptr, 1);
2118 /* Sign extend the line base field. */
2119 info.li_line_base <<= 24;
2120 info.li_line_base >>= 24;
2122 printf (_(" Offset: 0x%lx\n"), hdroff);
2123 printf (_(" Length: %ld\n"), info.li_length);
2124 printf (_(" DWARF Version: %d\n"), info.li_version);
2125 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
2126 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
2127 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
2128 printf (_(" Line Base: %d\n"), info.li_line_base);
2129 printf (_(" Line Range: %d\n"), info.li_line_range);
2130 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
2132 end_of_sequence = data + info.li_length + initial_length_size;
2134 reset_state_machine (info.li_default_is_stmt);
2136 /* Display the contents of the Opcodes table. */
2137 standard_opcodes = hdrptr;
2139 printf (_("\n Opcodes:\n"));
2141 for (i = 1; i < info.li_opcode_base; i++)
2142 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2144 /* Display the contents of the Directory table. */
2145 data = standard_opcodes + info.li_opcode_base - 1;
2148 printf (_("\n The Directory Table is empty.\n"));
2151 printf (_("\n The Directory Table:\n"));
2155 printf (_(" %s\n"), data);
2157 data += strlen ((char *) data) + 1;
2161 /* Skip the NUL at the end of the table. */
2164 /* Display the contents of the File Name table. */
2166 printf (_("\n The File Name Table is empty.\n"));
2169 printf (_("\n The File Name Table:\n"));
2170 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2174 unsigned char *name;
2175 unsigned int bytes_read;
2177 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
2180 data += strlen ((char *) data) + 1;
2182 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2184 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2186 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2188 printf (_("%s\n"), name);
2192 /* Skip the NUL at the end of the table. */
2195 /* Now display the statements. */
2196 printf (_("\n Line Number Statements:\n"));
2198 while (data < end_of_sequence)
2200 unsigned char op_code;
2202 unsigned long int uladv;
2203 unsigned int bytes_read;
2207 if (op_code >= info.li_opcode_base)
2209 op_code -= info.li_opcode_base;
2210 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2211 state_machine_regs.address += uladv;
2212 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2213 op_code, uladv, state_machine_regs.address);
2214 adv = (op_code % info.li_line_range) + info.li_line_base;
2215 state_machine_regs.line += adv;
2216 printf (_(" and Line by %d to %d\n"),
2217 adv, state_machine_regs.line);
2219 else switch (op_code)
2221 case DW_LNS_extended_op:
2222 data += process_extended_line_op (data, info.li_default_is_stmt);
2226 printf (_(" Copy\n"));
2229 case DW_LNS_advance_pc:
2230 uladv = read_leb128 (data, & bytes_read, 0);
2231 uladv *= info.li_min_insn_length;
2233 state_machine_regs.address += uladv;
2234 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
2235 state_machine_regs.address);
2238 case DW_LNS_advance_line:
2239 adv = read_leb128 (data, & bytes_read, 1);
2241 state_machine_regs.line += adv;
2242 printf (_(" Advance Line by %d to %d\n"), adv,
2243 state_machine_regs.line);
2246 case DW_LNS_set_file:
2247 adv = read_leb128 (data, & bytes_read, 0);
2249 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2251 state_machine_regs.file = adv;
2254 case DW_LNS_set_column:
2255 uladv = read_leb128 (data, & bytes_read, 0);
2257 printf (_(" Set column to %lu\n"), uladv);
2258 state_machine_regs.column = uladv;
2261 case DW_LNS_negate_stmt:
2262 adv = state_machine_regs.is_stmt;
2264 printf (_(" Set is_stmt to %d\n"), adv);
2265 state_machine_regs.is_stmt = adv;
2268 case DW_LNS_set_basic_block:
2269 printf (_(" Set basic block\n"));
2270 state_machine_regs.basic_block = 1;
2273 case DW_LNS_const_add_pc:
2274 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2275 * info.li_min_insn_length);
2276 state_machine_regs.address += uladv;
2277 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2278 state_machine_regs.address);
2281 case DW_LNS_fixed_advance_pc:
2282 uladv = byte_get (data, 2);
2284 state_machine_regs.address += uladv;
2285 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2286 uladv, state_machine_regs.address);
2289 case DW_LNS_set_prologue_end:
2290 printf (_(" Set prologue_end to true\n"));
2293 case DW_LNS_set_epilogue_begin:
2294 printf (_(" Set epilogue_begin to true\n"));
2297 case DW_LNS_set_isa:
2298 uladv = read_leb128 (data, & bytes_read, 0);
2300 printf (_(" Set ISA to %lu\n"), uladv);
2304 printf (_(" Unknown opcode %d with operands: "), op_code);
2306 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2308 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2309 i == 1 ? "" : ", ");
2323 find_debug_info_for_offset (unsigned long offset)
2327 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2330 for (i = 0; i < num_debug_info_entries; i++)
2331 if (debug_information[i].cu_offset == offset)
2332 return debug_information + i;
2338 display_debug_pubnames (struct dwarf_section *section,
2339 void *file ATTRIBUTE_UNUSED)
2341 DWARF2_Internal_PubNames pubnames;
2342 unsigned char *start = section->start;
2343 unsigned char *end = start + section->size;
2345 /* It does not matter if this load fails,
2346 we test for that later on. */
2347 load_debug_info (file);
2349 printf (_("Contents of the %s section:\n\n"), section->name);
2353 unsigned char *data;
2354 unsigned long offset;
2355 int offset_size, initial_length_size;
2359 pubnames.pn_length = byte_get (data, 4);
2361 if (pubnames.pn_length == 0xffffffff)
2363 pubnames.pn_length = byte_get (data, 8);
2366 initial_length_size = 12;
2371 initial_length_size = 4;
2374 pubnames.pn_version = byte_get (data, 2);
2377 pubnames.pn_offset = byte_get (data, offset_size);
2378 data += offset_size;
2380 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2381 && num_debug_info_entries > 0
2382 && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
2383 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2384 pubnames.pn_offset, section->name);
2386 pubnames.pn_size = byte_get (data, offset_size);
2387 data += offset_size;
2389 start += pubnames.pn_length + initial_length_size;
2391 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2393 static int warned = 0;
2397 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2404 printf (_(" Length: %ld\n"),
2405 pubnames.pn_length);
2406 printf (_(" Version: %d\n"),
2407 pubnames.pn_version);
2408 printf (_(" Offset into .debug_info section: 0x%lx\n"),
2409 pubnames.pn_offset);
2410 printf (_(" Size of area in .debug_info section: %ld\n"),
2413 printf (_("\n Offset\tName\n"));
2417 offset = byte_get (data, offset_size);
2421 data += offset_size;
2422 printf (" %-6ld\t\t%s\n", offset, data);
2423 data += strlen ((char *) data) + 1;
2426 while (offset != 0);
2434 display_debug_macinfo (struct dwarf_section *section,
2435 void *file ATTRIBUTE_UNUSED)
2437 unsigned char *start = section->start;
2438 unsigned char *end = start + section->size;
2439 unsigned char *curr = start;
2440 unsigned int bytes_read;
2441 enum dwarf_macinfo_record_type op;
2443 printf (_("Contents of the %s section:\n\n"), section->name);
2447 unsigned int lineno;
2455 case DW_MACINFO_start_file:
2457 unsigned int filenum;
2459 lineno = read_leb128 (curr, & bytes_read, 0);
2461 filenum = read_leb128 (curr, & bytes_read, 0);
2464 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2469 case DW_MACINFO_end_file:
2470 printf (_(" DW_MACINFO_end_file\n"));
2473 case DW_MACINFO_define:
2474 lineno = read_leb128 (curr, & bytes_read, 0);
2476 string = (char *) curr;
2477 curr += strlen (string) + 1;
2478 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2482 case DW_MACINFO_undef:
2483 lineno = read_leb128 (curr, & bytes_read, 0);
2485 string = (char *) curr;
2486 curr += strlen (string) + 1;
2487 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2491 case DW_MACINFO_vendor_ext:
2493 unsigned int constant;
2495 constant = read_leb128 (curr, & bytes_read, 0);
2497 string = (char *) curr;
2498 curr += strlen (string) + 1;
2499 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2510 display_debug_abbrev (struct dwarf_section *section,
2511 void *file ATTRIBUTE_UNUSED)
2513 abbrev_entry *entry;
2514 unsigned char *start = section->start;
2515 unsigned char *end = start + section->size;
2517 printf (_("Contents of the %s section:\n\n"), section->name);
2523 start = process_abbrev_section (start, end);
2525 if (first_abbrev == NULL)
2528 printf (_(" Number TAG\n"));
2530 for (entry = first_abbrev; entry; entry = entry->next)
2534 printf (_(" %ld %s [%s]\n"),
2536 get_TAG_name (entry->tag),
2537 entry->children ? _("has children") : _("no children"));
2539 for (attr = entry->first_attr; attr; attr = attr->next)
2540 printf (_(" %-18s %s\n"),
2541 get_AT_name (attr->attribute),
2542 get_FORM_name (attr->form));
2553 display_debug_loc (struct dwarf_section *section, void *file)
2555 unsigned char *start = section->start;
2556 unsigned char *section_end;
2557 unsigned long bytes;
2558 unsigned char *section_begin = start;
2559 unsigned int num_loc_list = 0;
2560 unsigned long last_offset = 0;
2561 unsigned int first = 0;
2564 int seen_first_offset = 0;
2565 int use_debug_info = 1;
2566 unsigned char *next;
2568 bytes = section->size;
2569 section_end = start + bytes;
2573 printf (_("\nThe %s section is empty.\n"), section->name);
2577 if (load_debug_info (file) == 0)
2579 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2584 /* Check the order of location list in .debug_info section. If
2585 offsets of location lists are in the ascending order, we can
2586 use `debug_information' directly. */
2587 for (i = 0; i < num_debug_info_entries; i++)
2591 num = debug_information [i].num_loc_offsets;
2592 num_loc_list += num;
2594 /* Check if we can use `debug_information' directly. */
2595 if (use_debug_info && num != 0)
2597 if (!seen_first_offset)
2599 /* This is the first location list. */
2600 last_offset = debug_information [i].loc_offsets [0];
2602 seen_first_offset = 1;
2608 for (; j < num; j++)
2611 debug_information [i].loc_offsets [j])
2616 last_offset = debug_information [i].loc_offsets [j];
2621 if (!use_debug_info)
2622 /* FIXME: Should we handle this case? */
2623 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2625 if (!seen_first_offset)
2626 error (_("No location lists in .debug_info section!\n"));
2628 /* DWARF sections under Mach-O have non-zero addresses. */
2629 if (debug_information [first].num_loc_offsets > 0
2630 && debug_information [first].loc_offsets [0] != section->address)
2631 warn (_("Location lists in %s section start at 0x%lx\n"),
2632 section->name, debug_information [first].loc_offsets [0]);
2634 printf (_("Contents of the %s section:\n\n"), section->name);
2635 printf (_(" Offset Begin End Expression\n"));
2637 seen_first_offset = 0;
2638 for (i = first; i < num_debug_info_entries; i++)
2642 unsigned short length;
2643 unsigned long offset;
2644 unsigned int pointer_size;
2645 unsigned long cu_offset;
2646 unsigned long base_address;
2647 int need_frame_base;
2650 pointer_size = debug_information [i].pointer_size;
2651 cu_offset = debug_information [i].cu_offset;
2653 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2655 has_frame_base = debug_information [i].have_frame_base [j];
2656 /* DWARF sections under Mach-O have non-zero addresses. */
2657 offset = debug_information [i].loc_offsets [j] - section->address;
2658 next = section_begin + offset;
2659 base_address = debug_information [i].base_address;
2661 if (!seen_first_offset)
2662 seen_first_offset = 1;
2666 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2667 (long)(start - section_begin), (long)(next - section_begin));
2668 else if (start > next)
2669 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2670 (long)(start - section_begin), (long)(next - section_begin));
2674 if (offset >= bytes)
2676 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2683 if (start + 2 * pointer_size > section_end)
2685 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2690 /* Note: we use sign extension here in order to be sure that
2691 we can detect the -1 escape value. Sign extension into the
2692 top 32 bits of a 32-bit address will not affect the values
2693 that we display since we always show hex values, and always
2694 the bottom 32-bits. */
2695 begin = byte_get_signed (start, pointer_size);
2696 start += pointer_size;
2697 end = byte_get_signed (start, pointer_size);
2698 start += pointer_size;
2700 printf (" %8.8lx ", offset);
2702 if (begin == 0 && end == 0)
2704 printf (_("<End of list>\n"));
2708 /* Check base address specifiers. */
2709 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
2712 print_dwarf_vma (begin, pointer_size);
2713 print_dwarf_vma (end, pointer_size);
2714 printf (_("(base address)\n"));
2718 if (start + 2 > section_end)
2720 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2725 length = byte_get (start, 2);
2728 if (start + length > section_end)
2730 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2735 print_dwarf_vma (begin + base_address, pointer_size);
2736 print_dwarf_vma (end + base_address, pointer_size);
2739 need_frame_base = decode_location_expression (start,
2745 if (need_frame_base && !has_frame_base)
2746 printf (_(" [without DW_AT_frame_base]"));
2749 fputs (_(" (start == end)"), stdout);
2750 else if (begin > end)
2751 fputs (_(" (start > end)"), stdout);
2760 if (start < section_end)
2761 warn (_("There are %ld unused bytes at the end of section %s\n"),
2762 (long) (section_end - start), section->name);
2767 display_debug_str (struct dwarf_section *section,
2768 void *file ATTRIBUTE_UNUSED)
2770 unsigned char *start = section->start;
2771 unsigned long bytes = section->size;
2772 dwarf_vma addr = section->address;
2776 printf (_("\nThe %s section is empty.\n"), section->name);
2780 printf (_("Contents of the %s section:\n\n"), section->name);
2788 lbytes = (bytes > 16 ? 16 : bytes);
2790 printf (" 0x%8.8lx ", (unsigned long) addr);
2792 for (j = 0; j < 16; j++)
2795 printf ("%2.2x", start[j]);
2803 for (j = 0; j < lbytes; j++)
2806 if (k >= ' ' && k < 0x80)
2825 display_debug_info (struct dwarf_section *section, void *file)
2827 return process_debug_info (section, file, 0);
2832 display_debug_aranges (struct dwarf_section *section,
2833 void *file ATTRIBUTE_UNUSED)
2835 unsigned char *start = section->start;
2836 unsigned char *end = start + section->size;
2838 printf (_("The section %s contains:\n\n"), section->name);
2840 /* It does not matter if this load fails,
2841 we test for that later on. */
2842 load_debug_info (file);
2846 unsigned char *hdrptr;
2847 DWARF2_Internal_ARange arange;
2848 unsigned char *ranges;
2851 unsigned char address_size;
2854 int initial_length_size;
2858 arange.ar_length = byte_get (hdrptr, 4);
2861 if (arange.ar_length == 0xffffffff)
2863 arange.ar_length = byte_get (hdrptr, 8);
2866 initial_length_size = 12;
2871 initial_length_size = 4;
2874 arange.ar_version = byte_get (hdrptr, 2);
2877 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2878 hdrptr += offset_size;
2880 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2881 && num_debug_info_entries > 0
2882 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
2883 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2884 arange.ar_info_offset, section->name);
2886 arange.ar_pointer_size = byte_get (hdrptr, 1);
2889 arange.ar_segment_size = byte_get (hdrptr, 1);
2892 if (arange.ar_version != 2 && arange.ar_version != 3)
2894 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2898 printf (_(" Length: %ld\n"), arange.ar_length);
2899 printf (_(" Version: %d\n"), arange.ar_version);
2900 printf (_(" Offset into .debug_info: 0x%lx\n"), arange.ar_info_offset);
2901 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2902 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2904 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2906 /* The DWARF spec does not require that the address size be a power
2907 of two, but we do. This will have to change if we ever encounter
2908 an uneven architecture. */
2909 if ((address_size & (address_size - 1)) != 0)
2911 warn (_("Pointer size + Segment size is not a power of two.\n"));
2915 if (address_size > 4)
2916 printf (_("\n Address Length\n"));
2918 printf (_("\n Address Length\n"));
2922 /* Must pad to an alignment boundary that is twice the address size. */
2923 excess = (hdrptr - start) % (2 * address_size);
2925 ranges += (2 * address_size) - excess;
2927 start += arange.ar_length + initial_length_size;
2929 while (ranges + 2 * address_size <= start)
2931 address = byte_get (ranges, address_size);
2933 ranges += address_size;
2935 length = byte_get (ranges, address_size);
2937 ranges += address_size;
2939 print_dwarf_vma (address, address_size);
2940 print_dwarf_vma (length, address_size);
2951 display_debug_ranges (struct dwarf_section *section,
2952 void *file ATTRIBUTE_UNUSED)
2954 unsigned char *start = section->start;
2955 unsigned char *section_end;
2956 unsigned long bytes;
2957 unsigned char *section_begin = start;
2958 unsigned int num_range_list = 0;
2959 unsigned long last_offset = 0;
2960 unsigned int first = 0;
2963 int seen_first_offset = 0;
2964 int use_debug_info = 1;
2965 unsigned char *next;
2967 bytes = section->size;
2968 section_end = start + bytes;
2972 printf (_("\nThe %s section is empty.\n"), section->name);
2976 if (load_debug_info (file) == 0)
2978 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2983 /* Check the order of range list in .debug_info section. If
2984 offsets of range lists are in the ascending order, we can
2985 use `debug_information' directly. */
2986 for (i = 0; i < num_debug_info_entries; i++)
2990 num = debug_information [i].num_range_lists;
2991 num_range_list += num;
2993 /* Check if we can use `debug_information' directly. */
2994 if (use_debug_info && num != 0)
2996 if (!seen_first_offset)
2998 /* This is the first range list. */
2999 last_offset = debug_information [i].range_lists [0];
3001 seen_first_offset = 1;
3007 for (; j < num; j++)
3010 debug_information [i].range_lists [j])
3015 last_offset = debug_information [i].range_lists [j];
3020 if (!use_debug_info)
3021 /* FIXME: Should we handle this case? */
3022 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
3024 if (!seen_first_offset)
3025 error (_("No range lists in .debug_info section!\n"));
3027 /* DWARF sections under Mach-O have non-zero addresses. */
3028 if (debug_information [first].num_range_lists > 0
3029 && debug_information [first].range_lists [0] != section->address)
3030 warn (_("Range lists in %s section start at 0x%lx\n"),
3031 section->name, debug_information [first].range_lists [0]);
3033 printf (_("Contents of the %s section:\n\n"), section->name);
3034 printf (_(" Offset Begin End\n"));
3036 seen_first_offset = 0;
3037 for (i = first; i < num_debug_info_entries; i++)
3041 unsigned long offset;
3042 unsigned int pointer_size;
3043 unsigned long base_address;
3045 pointer_size = debug_information [i].pointer_size;
3047 for (j = 0; j < debug_information [i].num_range_lists; j++)
3049 /* DWARF sections under Mach-O have non-zero addresses. */
3050 offset = debug_information [i].range_lists [j] - section->address;
3051 next = section_begin + offset;
3052 base_address = debug_information [i].base_address;
3054 if (!seen_first_offset)
3055 seen_first_offset = 1;
3059 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3060 (long)(start - section_begin),
3061 (long)(next - section_begin), section->name);
3062 else if (start > next)
3063 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3064 (long)(start - section_begin),
3065 (long)(next - section_begin), section->name);
3071 /* Note: we use sign extension here in order to be sure that
3072 we can detect the -1 escape value. Sign extension into the
3073 top 32 bits of a 32-bit address will not affect the values
3074 that we display since we always show hex values, and always
3075 the bottom 32-bits. */
3076 begin = byte_get_signed (start, pointer_size);
3077 start += pointer_size;
3078 end = byte_get_signed (start, pointer_size);
3079 start += pointer_size;
3081 printf (" %8.8lx ", offset);
3083 if (begin == 0 && end == 0)
3085 printf (_("<End of list>\n"));
3089 print_dwarf_vma (begin, pointer_size);
3090 print_dwarf_vma (end, pointer_size);
3092 /* Check base address specifiers. */
3093 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3096 printf ("(base address)\n");
3101 fputs (_("(start == end)"), stdout);
3102 else if (begin > end)
3103 fputs (_("(start > end)"), stdout);
3113 typedef struct Frame_Chunk
3115 struct Frame_Chunk *next;
3116 unsigned char *chunk_start;
3118 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3119 short int *col_type;
3122 unsigned int code_factor;
3124 unsigned long pc_begin;
3125 unsigned long pc_range;
3129 unsigned char fde_encoding;
3130 unsigned char cfa_exp;
3134 /* A marker for a col_type that means this column was never referenced
3135 in the frame info. */
3136 #define DW_CFA_unreferenced (-1)
3139 frame_need_space (Frame_Chunk *fc, int reg)
3141 int prev = fc->ncols;
3143 if (reg < fc->ncols)
3146 fc->ncols = reg + 1;
3147 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3148 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3150 while (prev < fc->ncols)
3152 fc->col_type[prev] = DW_CFA_unreferenced;
3153 fc->col_offset[prev] = 0;
3158 static const char *const dwarf_regnames_i386[] =
3160 "eax", "ecx", "edx", "ebx",
3161 "esp", "ebp", "esi", "edi",
3162 "eip", "eflags", NULL,
3163 "st0", "st1", "st2", "st3",
3164 "st4", "st5", "st6", "st7",
3166 "xmm0", "xmm1", "xmm2", "xmm3",
3167 "xmm4", "xmm5", "xmm6", "xmm7",
3168 "mm0", "mm1", "mm2", "mm3",
3169 "mm4", "mm5", "mm6", "mm7",
3170 "fcw", "fsw", "mxcsr",
3171 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3175 static const char *const dwarf_regnames_x86_64[] =
3177 "rax", "rdx", "rcx", "rbx",
3178 "rsi", "rdi", "rbp", "rsp",
3179 "r8", "r9", "r10", "r11",
3180 "r12", "r13", "r14", "r15",
3182 "xmm0", "xmm1", "xmm2", "xmm3",
3183 "xmm4", "xmm5", "xmm6", "xmm7",
3184 "xmm8", "xmm9", "xmm10", "xmm11",
3185 "xmm12", "xmm13", "xmm14", "xmm15",
3186 "st0", "st1", "st2", "st3",
3187 "st4", "st5", "st6", "st7",
3188 "mm0", "mm1", "mm2", "mm3",
3189 "mm4", "mm5", "mm6", "mm7",
3191 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3192 "fs.base", "gs.base", NULL, NULL,
3194 "mxcsr", "fcw", "fsw"
3197 static const char *const *dwarf_regnames;
3198 static unsigned int dwarf_regnames_count;
3201 init_dwarf_regnames (unsigned int e_machine)
3207 dwarf_regnames = dwarf_regnames_i386;
3208 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
3212 dwarf_regnames = dwarf_regnames_x86_64;
3213 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
3222 regname (unsigned int regno, int row)
3224 static char reg[64];
3226 && regno < dwarf_regnames_count
3227 && dwarf_regnames [regno] != NULL)
3230 return dwarf_regnames [regno];
3231 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
3232 dwarf_regnames [regno]);
3235 snprintf (reg, sizeof (reg), "r%d", regno);
3240 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3245 if (*max_regs < fc->ncols)
3246 *max_regs = fc->ncols;
3248 if (*need_col_headers)
3250 static const char *loc = " LOC";
3252 *need_col_headers = 0;
3254 printf ("%-*s CFA ", eh_addr_size * 2, loc);
3256 for (r = 0; r < *max_regs; r++)
3257 if (fc->col_type[r] != DW_CFA_unreferenced)
3262 printf ("%-5s ", regname (r, 1));
3268 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
3270 strcpy (tmp, "exp");
3272 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
3273 printf ("%-8s ", tmp);
3275 for (r = 0; r < fc->ncols; r++)
3277 if (fc->col_type[r] != DW_CFA_unreferenced)
3279 switch (fc->col_type[r])
3281 case DW_CFA_undefined:
3284 case DW_CFA_same_value:
3288 sprintf (tmp, "c%+d", fc->col_offset[r]);
3290 case DW_CFA_val_offset:
3291 sprintf (tmp, "v%+d", fc->col_offset[r]);
3293 case DW_CFA_register:
3294 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
3296 case DW_CFA_expression:
3297 strcpy (tmp, "exp");
3299 case DW_CFA_val_expression:
3300 strcpy (tmp, "vexp");
3303 strcpy (tmp, "n/a");
3306 printf ("%-5s ", tmp);
3313 size_of_encoded_value (int encoding)
3315 switch (encoding & 0x7)
3318 case 0: return eh_addr_size;
3326 get_encoded_value (unsigned char *data, int encoding)
3328 int size = size_of_encoded_value (encoding);
3330 if (encoding & DW_EH_PE_signed)
3331 return byte_get_signed (data, size);
3333 return byte_get (data, size);
3336 #define GET(N) byte_get (start, N); start += N
3337 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3338 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3341 display_debug_frames (struct dwarf_section *section,
3342 void *file ATTRIBUTE_UNUSED)
3344 unsigned char *start = section->start;
3345 unsigned char *end = start + section->size;
3346 unsigned char *section_start = start;
3347 Frame_Chunk *chunks = 0;
3348 Frame_Chunk *remembered_state = 0;
3350 int is_eh = strcmp (section->name, ".eh_frame") == 0;
3351 unsigned int length_return;
3354 printf (_("The section %s contains:\n"), section->name);
3358 unsigned char *saved_start;
3359 unsigned char *block_end;
3360 unsigned long length;
3361 unsigned long cie_id;
3364 int need_col_headers = 1;
3365 unsigned char *augmentation_data = NULL;
3366 unsigned long augmentation_data_len = 0;
3367 int encoded_ptr_size = eh_addr_size;
3369 int initial_length_size;
3371 saved_start = start;
3372 length = byte_get (start, 4); start += 4;
3376 printf ("\n%08lx ZERO terminator\n\n",
3377 (unsigned long)(saved_start - section_start));
3381 if (length == 0xffffffff)
3383 length = byte_get (start, 8);
3386 initial_length_size = 12;
3391 initial_length_size = 4;
3394 block_end = saved_start + length + initial_length_size;
3395 if (block_end > end)
3397 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3398 length, (unsigned long)(saved_start - section_start));
3401 cie_id = byte_get (start, offset_size); start += offset_size;
3403 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3407 fc = xmalloc (sizeof (Frame_Chunk));
3408 memset (fc, 0, sizeof (Frame_Chunk));
3412 fc->chunk_start = saved_start;
3414 fc->col_type = xmalloc (sizeof (short int));
3415 fc->col_offset = xmalloc (sizeof (int));
3416 frame_need_space (fc, max_regs - 1);
3420 fc->augmentation = (char *) start;
3421 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3423 if (fc->augmentation[0] == 'z')
3425 fc->code_factor = LEB ();
3426 fc->data_factor = SLEB ();
3435 augmentation_data_len = LEB ();
3436 augmentation_data = start;
3437 start += augmentation_data_len;
3439 else if (strcmp (fc->augmentation, "eh") == 0)
3441 start += eh_addr_size;
3442 fc->code_factor = LEB ();
3443 fc->data_factor = SLEB ();
3455 fc->code_factor = LEB ();
3456 fc->data_factor = SLEB ();
3468 if (do_debug_frames_interp)
3469 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3470 (unsigned long)(saved_start - section_start), length, cie_id,
3471 fc->augmentation, fc->code_factor, fc->data_factor,
3475 printf ("\n%08lx %08lx %08lx CIE\n",
3476 (unsigned long)(saved_start - section_start), length, cie_id);
3477 printf (" Version: %d\n", version);
3478 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3479 printf (" Code alignment factor: %u\n", fc->code_factor);
3480 printf (" Data alignment factor: %d\n", fc->data_factor);
3481 printf (" Return address column: %d\n", fc->ra);
3483 if (augmentation_data_len)
3486 printf (" Augmentation data: ");
3487 for (i = 0; i < augmentation_data_len; ++i)
3488 printf (" %02x", augmentation_data[i]);
3494 if (augmentation_data_len)
3496 unsigned char *p, *q;
3497 p = (unsigned char *) fc->augmentation + 1;
3498 q = augmentation_data;
3505 q += 1 + size_of_encoded_value (*q);
3507 fc->fde_encoding = *q++;
3513 if (fc->fde_encoding)
3514 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3517 frame_need_space (fc, fc->ra);
3521 unsigned char *look_for;
3522 static Frame_Chunk fde_fc;
3525 memset (fc, 0, sizeof (Frame_Chunk));
3527 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3529 for (cie = chunks; cie ; cie = cie->next)
3530 if (cie->chunk_start == look_for)
3535 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3536 cie_id, (unsigned long)(saved_start - section_start));
3538 fc->col_type = xmalloc (sizeof (short int));
3539 fc->col_offset = xmalloc (sizeof (int));
3540 frame_need_space (fc, max_regs - 1);
3542 fc->augmentation = "";
3543 fc->fde_encoding = 0;
3547 fc->ncols = cie->ncols;
3548 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3549 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3550 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3551 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3552 fc->augmentation = cie->augmentation;
3553 fc->code_factor = cie->code_factor;
3554 fc->data_factor = cie->data_factor;
3555 fc->cfa_reg = cie->cfa_reg;
3556 fc->cfa_offset = cie->cfa_offset;
3558 frame_need_space (fc, max_regs - 1);
3559 fc->fde_encoding = cie->fde_encoding;
3562 if (fc->fde_encoding)
3563 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3565 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3566 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3567 fc->pc_begin += section->address + (start - section_start);
3568 start += encoded_ptr_size;
3569 fc->pc_range = byte_get (start, encoded_ptr_size);
3570 start += encoded_ptr_size;
3572 if (cie->augmentation[0] == 'z')
3574 augmentation_data_len = LEB ();
3575 augmentation_data = start;
3576 start += augmentation_data_len;
3579 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3580 (unsigned long)(saved_start - section_start), length, cie_id,
3581 (unsigned long)(cie->chunk_start - section_start),
3582 fc->pc_begin, fc->pc_begin + fc->pc_range);
3583 if (! do_debug_frames_interp && augmentation_data_len)
3587 printf (" Augmentation data: ");
3588 for (i = 0; i < augmentation_data_len; ++i)
3589 printf (" %02x", augmentation_data[i]);
3595 /* At this point, fc is the current chunk, cie (if any) is set, and
3596 we're about to interpret instructions for the chunk. */
3597 /* ??? At present we need to do this always, since this sizes the
3598 fc->col_type and fc->col_offset arrays, which we write into always.
3599 We should probably split the interpreted and non-interpreted bits
3600 into two different routines, since there's so much that doesn't
3601 really overlap between them. */
3602 if (1 || do_debug_frames_interp)
3604 /* Start by making a pass over the chunk, allocating storage
3605 and taking note of what registers are used. */
3606 unsigned char *tmp = start;
3608 while (start < block_end)
3611 unsigned long reg, tmp;
3618 /* Warning: if you add any more cases to this switch, be
3619 sure to add them to the corresponding switch below. */
3622 case DW_CFA_advance_loc:
3626 frame_need_space (fc, opa);
3627 fc->col_type[opa] = DW_CFA_undefined;
3629 case DW_CFA_restore:
3630 frame_need_space (fc, opa);
3631 fc->col_type[opa] = DW_CFA_undefined;
3633 case DW_CFA_set_loc:
3634 start += encoded_ptr_size;
3636 case DW_CFA_advance_loc1:
3639 case DW_CFA_advance_loc2:
3642 case DW_CFA_advance_loc4:
3645 case DW_CFA_offset_extended:
3646 case DW_CFA_val_offset:
3647 reg = LEB (); LEB ();
3648 frame_need_space (fc, reg);
3649 fc->col_type[reg] = DW_CFA_undefined;
3651 case DW_CFA_restore_extended:
3653 frame_need_space (fc, reg);
3654 fc->col_type[reg] = DW_CFA_undefined;
3656 case DW_CFA_undefined:
3658 frame_need_space (fc, reg);
3659 fc->col_type[reg] = DW_CFA_undefined;
3661 case DW_CFA_same_value:
3663 frame_need_space (fc, reg);
3664 fc->col_type[reg] = DW_CFA_undefined;
3666 case DW_CFA_register:
3667 reg = LEB (); LEB ();
3668 frame_need_space (fc, reg);
3669 fc->col_type[reg] = DW_CFA_undefined;
3671 case DW_CFA_def_cfa:
3674 case DW_CFA_def_cfa_register:
3677 case DW_CFA_def_cfa_offset:
3680 case DW_CFA_def_cfa_expression:
3684 case DW_CFA_expression:
3685 case DW_CFA_val_expression:
3689 frame_need_space (fc, reg);
3690 fc->col_type[reg] = DW_CFA_undefined;
3692 case DW_CFA_offset_extended_sf:
3693 case DW_CFA_val_offset_sf:
3694 reg = LEB (); SLEB ();
3695 frame_need_space (fc, reg);
3696 fc->col_type[reg] = DW_CFA_undefined;
3698 case DW_CFA_def_cfa_sf:
3701 case DW_CFA_def_cfa_offset_sf:
3704 case DW_CFA_MIPS_advance_loc8:
3707 case DW_CFA_GNU_args_size:
3710 case DW_CFA_GNU_negative_offset_extended:
3711 reg = LEB (); LEB ();
3712 frame_need_space (fc, reg);
3713 fc->col_type[reg] = DW_CFA_undefined;
3722 /* Now we know what registers are used, make a second pass over
3723 the chunk, this time actually printing out the info. */
3725 while (start < block_end)
3728 unsigned long ul, reg, roffs;
3737 /* Warning: if you add any more cases to this switch, be
3738 sure to add them to the corresponding switch above. */
3741 case DW_CFA_advance_loc:
3742 if (do_debug_frames_interp)
3743 frame_display_row (fc, &need_col_headers, &max_regs);
3745 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3746 opa * fc->code_factor,
3747 fc->pc_begin + opa * fc->code_factor);
3748 fc->pc_begin += opa * fc->code_factor;
3753 if (! do_debug_frames_interp)
3754 printf (" DW_CFA_offset: %s at cfa%+ld\n",
3755 regname (opa, 0), roffs * fc->data_factor);
3756 fc->col_type[opa] = DW_CFA_offset;
3757 fc->col_offset[opa] = roffs * fc->data_factor;
3760 case DW_CFA_restore:
3761 if (! do_debug_frames_interp)
3762 printf (" DW_CFA_restore: %s\n", regname (opa, 0));
3763 fc->col_type[opa] = cie->col_type[opa];
3764 fc->col_offset[opa] = cie->col_offset[opa];
3767 case DW_CFA_set_loc:
3768 vma = get_encoded_value (start, fc->fde_encoding);
3769 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3770 vma += section->address + (start - section_start);
3771 start += encoded_ptr_size;
3772 if (do_debug_frames_interp)
3773 frame_display_row (fc, &need_col_headers, &max_regs);
3775 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3779 case DW_CFA_advance_loc1:
3780 ofs = byte_get (start, 1); start += 1;
3781 if (do_debug_frames_interp)
3782 frame_display_row (fc, &need_col_headers, &max_regs);
3784 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3785 ofs * fc->code_factor,
3786 fc->pc_begin + ofs * fc->code_factor);
3787 fc->pc_begin += ofs * fc->code_factor;
3790 case DW_CFA_advance_loc2:
3791 ofs = byte_get (start, 2); start += 2;
3792 if (do_debug_frames_interp)
3793 frame_display_row (fc, &need_col_headers, &max_regs);
3795 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3796 ofs * fc->code_factor,
3797 fc->pc_begin + ofs * fc->code_factor);
3798 fc->pc_begin += ofs * fc->code_factor;
3801 case DW_CFA_advance_loc4:
3802 ofs = byte_get (start, 4); start += 4;
3803 if (do_debug_frames_interp)
3804 frame_display_row (fc, &need_col_headers, &max_regs);
3806 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3807 ofs * fc->code_factor,
3808 fc->pc_begin + ofs * fc->code_factor);
3809 fc->pc_begin += ofs * fc->code_factor;
3812 case DW_CFA_offset_extended:
3815 if (! do_debug_frames_interp)
3816 printf (" DW_CFA_offset_extended: %s at cfa%+ld\n",
3817 regname (reg, 0), roffs * fc->data_factor);
3818 fc->col_type[reg] = DW_CFA_offset;
3819 fc->col_offset[reg] = roffs * fc->data_factor;
3822 case DW_CFA_val_offset:
3825 if (! do_debug_frames_interp)
3826 printf (" DW_CFA_val_offset: %s at cfa%+ld\n",
3827 regname (reg, 0), roffs * fc->data_factor);
3828 fc->col_type[reg] = DW_CFA_val_offset;
3829 fc->col_offset[reg] = roffs * fc->data_factor;
3832 case DW_CFA_restore_extended:
3834 if (! do_debug_frames_interp)
3835 printf (" DW_CFA_restore_extended: %s\n",
3837 fc->col_type[reg] = cie->col_type[reg];
3838 fc->col_offset[reg] = cie->col_offset[reg];
3841 case DW_CFA_undefined:
3843 if (! do_debug_frames_interp)
3844 printf (" DW_CFA_undefined: %s\n", regname (reg, 0));
3845 fc->col_type[reg] = DW_CFA_undefined;
3846 fc->col_offset[reg] = 0;
3849 case DW_CFA_same_value:
3851 if (! do_debug_frames_interp)
3852 printf (" DW_CFA_same_value: %s\n", regname (reg, 0));
3853 fc->col_type[reg] = DW_CFA_same_value;
3854 fc->col_offset[reg] = 0;
3857 case DW_CFA_register:
3860 if (! do_debug_frames_interp)
3862 printf (" DW_CFA_register: %s in ",
3864 puts (regname (roffs, 0));
3866 fc->col_type[reg] = DW_CFA_register;
3867 fc->col_offset[reg] = roffs;
3870 case DW_CFA_remember_state:
3871 if (! do_debug_frames_interp)
3872 printf (" DW_CFA_remember_state\n");
3873 rs = xmalloc (sizeof (Frame_Chunk));
3874 rs->ncols = fc->ncols;
3875 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3876 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3877 memcpy (rs->col_type, fc->col_type, rs->ncols);
3878 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3879 rs->next = remembered_state;
3880 remembered_state = rs;
3883 case DW_CFA_restore_state:
3884 if (! do_debug_frames_interp)
3885 printf (" DW_CFA_restore_state\n");
3886 rs = remembered_state;
3889 remembered_state = rs->next;
3890 frame_need_space (fc, rs->ncols - 1);
3891 memcpy (fc->col_type, rs->col_type, rs->ncols);
3892 memcpy (fc->col_offset, rs->col_offset,
3893 rs->ncols * sizeof (int));
3894 free (rs->col_type);
3895 free (rs->col_offset);
3898 else if (do_debug_frames_interp)
3899 printf ("Mismatched DW_CFA_restore_state\n");
3902 case DW_CFA_def_cfa:
3903 fc->cfa_reg = LEB ();
3904 fc->cfa_offset = LEB ();
3906 if (! do_debug_frames_interp)
3907 printf (" DW_CFA_def_cfa: %s ofs %d\n",
3908 regname (fc->cfa_reg, 0), fc->cfa_offset);
3911 case DW_CFA_def_cfa_register:
3912 fc->cfa_reg = LEB ();
3914 if (! do_debug_frames_interp)
3915 printf (" DW_CFA_def_cfa_register: %s\n",
3916 regname (fc->cfa_reg, 0));
3919 case DW_CFA_def_cfa_offset:
3920 fc->cfa_offset = LEB ();
3921 if (! do_debug_frames_interp)
3922 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3926 if (! do_debug_frames_interp)
3927 printf (" DW_CFA_nop\n");
3930 case DW_CFA_def_cfa_expression:
3932 if (! do_debug_frames_interp)
3934 printf (" DW_CFA_def_cfa_expression (");
3935 decode_location_expression (start, eh_addr_size, ul, 0);
3942 case DW_CFA_expression:
3945 if (! do_debug_frames_interp)
3947 printf (" DW_CFA_expression: %s (",
3949 decode_location_expression (start, eh_addr_size,
3953 fc->col_type[reg] = DW_CFA_expression;
3957 case DW_CFA_val_expression:
3960 if (! do_debug_frames_interp)
3962 printf (" DW_CFA_val_expression: %s (",
3964 decode_location_expression (start, eh_addr_size, ul, 0);
3967 fc->col_type[reg] = DW_CFA_val_expression;
3971 case DW_CFA_offset_extended_sf:
3974 frame_need_space (fc, reg);
3975 if (! do_debug_frames_interp)
3976 printf (" DW_CFA_offset_extended_sf: %s at cfa%+ld\n",
3977 regname (reg, 0), l * fc->data_factor);
3978 fc->col_type[reg] = DW_CFA_offset;
3979 fc->col_offset[reg] = l * fc->data_factor;
3982 case DW_CFA_val_offset_sf:
3985 frame_need_space (fc, reg);
3986 if (! do_debug_frames_interp)
3987 printf (" DW_CFA_val_offset_sf: %s at cfa%+ld\n",
3988 regname (reg, 0), l * fc->data_factor);
3989 fc->col_type[reg] = DW_CFA_val_offset;
3990 fc->col_offset[reg] = l * fc->data_factor;
3993 case DW_CFA_def_cfa_sf:
3994 fc->cfa_reg = LEB ();
3995 fc->cfa_offset = SLEB ();
3996 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3998 if (! do_debug_frames_interp)
3999 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4000 regname (fc->cfa_reg, 0), fc->cfa_offset);
4003 case DW_CFA_def_cfa_offset_sf:
4004 fc->cfa_offset = SLEB ();
4005 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4006 if (! do_debug_frames_interp)
4007 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4010 case DW_CFA_MIPS_advance_loc8:
4011 ofs = byte_get (start, 8); start += 8;
4012 if (do_debug_frames_interp)
4013 frame_display_row (fc, &need_col_headers, &max_regs);
4015 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4016 ofs * fc->code_factor,
4017 fc->pc_begin + ofs * fc->code_factor);
4018 fc->pc_begin += ofs * fc->code_factor;
4021 case DW_CFA_GNU_window_save:
4022 if (! do_debug_frames_interp)
4023 printf (" DW_CFA_GNU_window_save\n");
4026 case DW_CFA_GNU_args_size:
4028 if (! do_debug_frames_interp)
4029 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
4032 case DW_CFA_GNU_negative_offset_extended:
4035 frame_need_space (fc, reg);
4036 if (! do_debug_frames_interp)
4037 printf (" DW_CFA_GNU_negative_offset_extended: %s at cfa%+ld\n",
4038 regname (reg, 0), l * fc->data_factor);
4039 fc->col_type[reg] = DW_CFA_offset;
4040 fc->col_offset[reg] = l * fc->data_factor;
4044 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4045 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4047 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4052 if (do_debug_frames_interp)
4053 frame_display_row (fc, &need_col_headers, &max_regs);
4068 display_debug_not_supported (struct dwarf_section *section,
4069 void *file ATTRIBUTE_UNUSED)
4071 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4078 cmalloc (size_t nmemb, size_t size)
4080 /* Check for overflow. */
4081 if (nmemb >= ~(size_t) 0 / size)
4084 return malloc (nmemb * size);
4088 xcmalloc (size_t nmemb, size_t size)
4090 /* Check for overflow. */
4091 if (nmemb >= ~(size_t) 0 / size)
4094 return xmalloc (nmemb * size);
4098 xcrealloc (void *ptr, size_t nmemb, size_t size)
4100 /* Check for overflow. */
4101 if (nmemb >= ~(size_t) 0 / size)
4104 return xrealloc (ptr, nmemb * size);
4108 error (const char *message, ...)
4112 va_start (args, message);
4113 fprintf (stderr, _("%s: Error: "), program_name);
4114 vfprintf (stderr, message, args);
4119 warn (const char *message, ...)
4123 va_start (args, message);
4124 fprintf (stderr, _("%s: Warning: "), program_name);
4125 vfprintf (stderr, message, args);
4130 free_debug_memory (void)
4132 enum dwarf_section_display_enum i;
4136 for (i = 0; i < max; i++)
4137 free_debug_section (i);
4139 if (debug_information != NULL)
4141 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
4143 for (i = 0; i < num_debug_info_entries; i++)
4145 if (!debug_information [i].max_loc_offsets)
4147 free (debug_information [i].loc_offsets);
4148 free (debug_information [i].have_frame_base);
4150 if (!debug_information [i].max_range_lists)
4151 free (debug_information [i].range_lists);
4155 free (debug_information);
4156 debug_information = NULL;
4157 num_debug_info_entries = 0;
4161 struct dwarf_section_display debug_displays[] =
4163 { { ".debug_abbrev", NULL, 0, 0 },
4164 display_debug_abbrev, 0, 0 },
4165 { { ".debug_aranges", NULL, 0, 0 },
4166 display_debug_aranges, 0, 0 },
4167 { { ".debug_frame", NULL, 0, 0 },
4168 display_debug_frames, 1, 0 },
4169 { { ".debug_info", NULL, 0, 0 },
4170 display_debug_info, 1, 0 },
4171 { { ".debug_line", NULL, 0, 0 },
4172 display_debug_lines, 0, 0 },
4173 { { ".debug_pubnames", NULL, 0, 0 },
4174 display_debug_pubnames, 0, 0 },
4175 { { ".eh_frame", NULL, 0, 0 },
4176 display_debug_frames, 1, 1 },
4177 { { ".debug_macinfo", NULL, 0, 0 },
4178 display_debug_macinfo, 0, 0 },
4179 { { ".debug_str", NULL, 0, 0 },
4180 display_debug_str, 0, 0 },
4181 { { ".debug_loc", NULL, 0, 0 },
4182 display_debug_loc, 0, 0 },
4183 { { ".debug_pubtypes", NULL, 0, 0 },
4184 display_debug_pubnames, 0, 0 },
4185 { { ".debug_ranges", NULL, 0, 0 },
4186 display_debug_ranges, 0, 0 },
4187 { { ".debug_static_func", NULL, 0, 0 },
4188 display_debug_not_supported, 0, 0 },
4189 { { ".debug_static_vars", NULL, 0, 0 },
4190 display_debug_not_supported, 0, 0 },
4191 { { ".debug_types", NULL, 0, 0 },
4192 display_debug_not_supported, 0, 0 },
4193 { { ".debug_weaknames", NULL, 0, 0 },
4194 display_debug_not_supported, 0, 0 }