1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/dwarf2.h"
29 static int have_frame_base;
30 static int need_base_address;
32 static unsigned int last_pointer_size = 0;
33 static int warned_about_missing_comp_units = FALSE;
35 static unsigned int num_debug_info_entries = 0;
36 static debug_info *debug_information = NULL;
38 dwarf_vma eh_addr_size;
44 int do_debug_pubnames;
48 int do_debug_frames_interp;
53 dwarf_vma (*byte_get) (unsigned char *, int);
56 byte_get_little_endian (unsigned char *field, int size)
64 return ((unsigned int) (field[0]))
65 | (((unsigned int) (field[1])) << 8);
68 return ((unsigned long) (field[0]))
69 | (((unsigned long) (field[1])) << 8)
70 | (((unsigned long) (field[2])) << 16)
71 | (((unsigned long) (field[3])) << 24);
74 if (sizeof (dwarf_vma) == 8)
75 return ((dwarf_vma) (field[0]))
76 | (((dwarf_vma) (field[1])) << 8)
77 | (((dwarf_vma) (field[2])) << 16)
78 | (((dwarf_vma) (field[3])) << 24)
79 | (((dwarf_vma) (field[4])) << 32)
80 | (((dwarf_vma) (field[5])) << 40)
81 | (((dwarf_vma) (field[6])) << 48)
82 | (((dwarf_vma) (field[7])) << 56);
83 else if (sizeof (dwarf_vma) == 4)
84 /* We want to extract data from an 8 byte wide field and
85 place it into a 4 byte wide field. Since this is a little
86 endian source we can just use the 4 byte extraction code. */
87 return ((unsigned long) (field[0]))
88 | (((unsigned long) (field[1])) << 8)
89 | (((unsigned long) (field[2])) << 16)
90 | (((unsigned long) (field[3])) << 24);
93 error (_("Unhandled data length: %d\n"), size);
99 byte_get_big_endian (unsigned char *field, int size)
107 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
110 return ((unsigned long) (field[3]))
111 | (((unsigned long) (field[2])) << 8)
112 | (((unsigned long) (field[1])) << 16)
113 | (((unsigned long) (field[0])) << 24);
116 if (sizeof (dwarf_vma) == 8)
117 return ((dwarf_vma) (field[7]))
118 | (((dwarf_vma) (field[6])) << 8)
119 | (((dwarf_vma) (field[5])) << 16)
120 | (((dwarf_vma) (field[4])) << 24)
121 | (((dwarf_vma) (field[3])) << 32)
122 | (((dwarf_vma) (field[2])) << 40)
123 | (((dwarf_vma) (field[1])) << 48)
124 | (((dwarf_vma) (field[0])) << 56);
125 else if (sizeof (dwarf_vma) == 4)
127 /* Although we are extracing data from an 8 byte wide field,
128 we are returning only 4 bytes of data. */
130 return ((unsigned long) (field[3]))
131 | (((unsigned long) (field[2])) << 8)
132 | (((unsigned long) (field[1])) << 16)
133 | (((unsigned long) (field[0])) << 24);
137 error (_("Unhandled data length: %d\n"), size);
143 byte_get_signed (unsigned char *field, int size)
145 dwarf_vma x = byte_get (field, size);
150 return (x ^ 0x80) - 0x80;
152 return (x ^ 0x8000) - 0x8000;
154 return (x ^ 0x80000000) - 0x80000000;
162 static unsigned long int
163 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
165 unsigned long int result = 0;
166 unsigned int num_read = 0;
167 unsigned int shift = 0;
175 result |= ((unsigned long int) (byte & 0x7f)) << shift;
182 if (length_return != NULL)
183 *length_return = num_read;
185 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
186 result |= -1L << shift;
191 typedef struct State_Machine_Registers
193 unsigned long address;
200 /* This variable hold the number of the last entry seen
201 in the File Table. */
202 unsigned int last_file_entry;
205 static SMR state_machine_regs;
208 reset_state_machine (int is_stmt)
210 state_machine_regs.address = 0;
211 state_machine_regs.file = 1;
212 state_machine_regs.line = 1;
213 state_machine_regs.column = 0;
214 state_machine_regs.is_stmt = is_stmt;
215 state_machine_regs.basic_block = 0;
216 state_machine_regs.end_sequence = 0;
217 state_machine_regs.last_file_entry = 0;
220 /* Handled an extend line op.
221 Returns the number of bytes read. */
224 process_extended_line_op (unsigned char *data, int is_stmt)
226 unsigned char op_code;
227 unsigned int bytes_read;
232 len = read_leb128 (data, & bytes_read, 0);
237 warn (_("badly formed extended line op encountered!\n"));
244 printf (_(" Extended opcode %d: "), op_code);
248 case DW_LNE_end_sequence:
249 printf (_("End of Sequence\n\n"));
250 reset_state_machine (is_stmt);
253 case DW_LNE_set_address:
254 adr = byte_get (data, len - bytes_read - 1);
255 printf (_("set Address to 0x%lx\n"), adr);
256 state_machine_regs.address = adr;
259 case DW_LNE_define_file:
260 printf (_(" define new File Table entry\n"));
261 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
263 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
265 data += strlen ((char *) data) + 1;
266 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
268 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
270 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
271 printf (_("%s\n\n"), name);
275 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
283 fetch_indirect_string (unsigned long offset)
285 struct dwarf_section *section = &debug_displays [str].section;
287 if (section->start == NULL)
288 return _("<no .debug_str section>");
290 /* DWARF sections under Mach-O have non-zero addresses. */
291 offset -= section->address;
292 if (offset > section->size)
294 warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
295 return _("<offset is too big>");
298 return (const char *) section->start + offset;
301 /* FIXME: There are better and more efficient ways to handle
302 these structures. For now though, I just want something that
303 is simple to implement. */
304 typedef struct abbrev_attr
306 unsigned long attribute;
308 struct abbrev_attr *next;
312 typedef struct abbrev_entry
317 struct abbrev_attr *first_attr;
318 struct abbrev_attr *last_attr;
319 struct abbrev_entry *next;
323 static abbrev_entry *first_abbrev = NULL;
324 static abbrev_entry *last_abbrev = NULL;
329 abbrev_entry *abbrev;
331 for (abbrev = first_abbrev; abbrev;)
333 abbrev_entry *next = abbrev->next;
336 for (attr = abbrev->first_attr; attr;)
338 abbrev_attr *next = attr->next;
348 last_abbrev = first_abbrev = NULL;
352 add_abbrev (unsigned long number, unsigned long tag, int children)
356 entry = malloc (sizeof (*entry));
362 entry->entry = number;
364 entry->children = children;
365 entry->first_attr = NULL;
366 entry->last_attr = NULL;
369 if (first_abbrev == NULL)
370 first_abbrev = entry;
372 last_abbrev->next = entry;
378 add_abbrev_attr (unsigned long attribute, unsigned long form)
382 attr = malloc (sizeof (*attr));
388 attr->attribute = attribute;
392 if (last_abbrev->first_attr == NULL)
393 last_abbrev->first_attr = attr;
395 last_abbrev->last_attr->next = attr;
397 last_abbrev->last_attr = attr;
400 /* Processes the (partial) contents of a .debug_abbrev section.
401 Returns NULL if the end of the section was encountered.
402 Returns the address after the last byte read if the end of
403 an abbreviation set was found. */
405 static unsigned char *
406 process_abbrev_section (unsigned char *start, unsigned char *end)
408 if (first_abbrev != NULL)
413 unsigned int bytes_read;
416 unsigned long attribute;
419 entry = read_leb128 (start, & bytes_read, 0);
422 /* A single zero is supposed to end the section according
423 to the standard. If there's more, then signal that to
426 return start == end ? NULL : start;
428 tag = read_leb128 (start, & bytes_read, 0);
433 add_abbrev (entry, tag, children);
439 attribute = read_leb128 (start, & bytes_read, 0);
442 form = read_leb128 (start, & bytes_read, 0);
446 add_abbrev_attr (attribute, form);
448 while (attribute != 0);
455 get_TAG_name (unsigned long tag)
459 case DW_TAG_padding: return "DW_TAG_padding";
460 case DW_TAG_array_type: return "DW_TAG_array_type";
461 case DW_TAG_class_type: return "DW_TAG_class_type";
462 case DW_TAG_entry_point: return "DW_TAG_entry_point";
463 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
464 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
465 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
466 case DW_TAG_label: return "DW_TAG_label";
467 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
468 case DW_TAG_member: return "DW_TAG_member";
469 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
470 case DW_TAG_reference_type: return "DW_TAG_reference_type";
471 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
472 case DW_TAG_string_type: return "DW_TAG_string_type";
473 case DW_TAG_structure_type: return "DW_TAG_structure_type";
474 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
475 case DW_TAG_typedef: return "DW_TAG_typedef";
476 case DW_TAG_union_type: return "DW_TAG_union_type";
477 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
478 case DW_TAG_variant: return "DW_TAG_variant";
479 case DW_TAG_common_block: return "DW_TAG_common_block";
480 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
481 case DW_TAG_inheritance: return "DW_TAG_inheritance";
482 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
483 case DW_TAG_module: return "DW_TAG_module";
484 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
485 case DW_TAG_set_type: return "DW_TAG_set_type";
486 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
487 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
488 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
489 case DW_TAG_base_type: return "DW_TAG_base_type";
490 case DW_TAG_catch_block: return "DW_TAG_catch_block";
491 case DW_TAG_const_type: return "DW_TAG_const_type";
492 case DW_TAG_constant: return "DW_TAG_constant";
493 case DW_TAG_enumerator: return "DW_TAG_enumerator";
494 case DW_TAG_file_type: return "DW_TAG_file_type";
495 case DW_TAG_friend: return "DW_TAG_friend";
496 case DW_TAG_namelist: return "DW_TAG_namelist";
497 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
498 case DW_TAG_packed_type: return "DW_TAG_packed_type";
499 case DW_TAG_subprogram: return "DW_TAG_subprogram";
500 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
501 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
502 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
503 case DW_TAG_try_block: return "DW_TAG_try_block";
504 case DW_TAG_variant_part: return "DW_TAG_variant_part";
505 case DW_TAG_variable: return "DW_TAG_variable";
506 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
507 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
508 case DW_TAG_format_label: return "DW_TAG_format_label";
509 case DW_TAG_function_template: return "DW_TAG_function_template";
510 case DW_TAG_class_template: return "DW_TAG_class_template";
511 /* DWARF 2.1 values. */
512 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
513 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
514 case DW_TAG_interface_type: return "DW_TAG_interface_type";
515 case DW_TAG_namespace: return "DW_TAG_namespace";
516 case DW_TAG_imported_module: return "DW_TAG_imported_module";
517 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
518 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
519 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
521 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
522 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
523 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
526 static char buffer[100];
528 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
535 get_FORM_name (unsigned long form)
539 case DW_FORM_addr: return "DW_FORM_addr";
540 case DW_FORM_block2: return "DW_FORM_block2";
541 case DW_FORM_block4: return "DW_FORM_block4";
542 case DW_FORM_data2: return "DW_FORM_data2";
543 case DW_FORM_data4: return "DW_FORM_data4";
544 case DW_FORM_data8: return "DW_FORM_data8";
545 case DW_FORM_string: return "DW_FORM_string";
546 case DW_FORM_block: return "DW_FORM_block";
547 case DW_FORM_block1: return "DW_FORM_block1";
548 case DW_FORM_data1: return "DW_FORM_data1";
549 case DW_FORM_flag: return "DW_FORM_flag";
550 case DW_FORM_sdata: return "DW_FORM_sdata";
551 case DW_FORM_strp: return "DW_FORM_strp";
552 case DW_FORM_udata: return "DW_FORM_udata";
553 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
554 case DW_FORM_ref1: return "DW_FORM_ref1";
555 case DW_FORM_ref2: return "DW_FORM_ref2";
556 case DW_FORM_ref4: return "DW_FORM_ref4";
557 case DW_FORM_ref8: return "DW_FORM_ref8";
558 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
559 case DW_FORM_indirect: return "DW_FORM_indirect";
560 case DW_FORM_flag_present: return "DW_FORM_flag_present";
563 static char buffer[100];
565 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
571 static unsigned char *
572 display_block (unsigned char *data, unsigned long length)
574 printf (_(" %lu byte block: "), length);
577 printf ("%lx ", (unsigned long) byte_get (data++, 1));
583 decode_location_expression (unsigned char * data,
584 unsigned int pointer_size,
585 unsigned long length,
586 unsigned long cu_offset)
589 unsigned int bytes_read;
590 unsigned long uvalue;
591 unsigned char *end = data + length;
592 int need_frame_base = 0;
601 printf ("DW_OP_addr: %lx",
602 (unsigned long) byte_get (data, pointer_size));
603 data += pointer_size;
606 printf ("DW_OP_deref");
609 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
612 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
615 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
619 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
623 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
627 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
631 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
632 (unsigned long) byte_get (data + 4, 4));
636 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
637 (long) byte_get (data + 4, 4));
641 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
645 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
649 printf ("DW_OP_dup");
652 printf ("DW_OP_drop");
655 printf ("DW_OP_over");
658 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
661 printf ("DW_OP_swap");
664 printf ("DW_OP_rot");
667 printf ("DW_OP_xderef");
670 printf ("DW_OP_abs");
673 printf ("DW_OP_and");
676 printf ("DW_OP_div");
679 printf ("DW_OP_minus");
682 printf ("DW_OP_mod");
685 printf ("DW_OP_mul");
688 printf ("DW_OP_neg");
691 printf ("DW_OP_not");
697 printf ("DW_OP_plus");
699 case DW_OP_plus_uconst:
700 printf ("DW_OP_plus_uconst: %lu",
701 read_leb128 (data, &bytes_read, 0));
705 printf ("DW_OP_shl");
708 printf ("DW_OP_shr");
711 printf ("DW_OP_shra");
714 printf ("DW_OP_xor");
717 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
739 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
775 printf ("DW_OP_lit%d", op - DW_OP_lit0);
810 printf ("DW_OP_reg%d", op - DW_OP_reg0);
845 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
846 read_leb128 (data, &bytes_read, 1));
851 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
856 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
860 uvalue = read_leb128 (data, &bytes_read, 0);
862 printf ("DW_OP_bregx: %lu %ld", uvalue,
863 read_leb128 (data, &bytes_read, 1));
867 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
870 case DW_OP_deref_size:
871 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
873 case DW_OP_xderef_size:
874 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
877 printf ("DW_OP_nop");
880 /* DWARF 3 extensions. */
881 case DW_OP_push_object_address:
882 printf ("DW_OP_push_object_address");
885 /* XXX: Strictly speaking for 64-bit DWARF3 files
886 this ought to be an 8-byte wide computation. */
887 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
891 /* XXX: Strictly speaking for 64-bit DWARF3 files
892 this ought to be an 8-byte wide computation. */
893 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
897 printf ("DW_OP_call_ref");
899 case DW_OP_form_tls_address:
900 printf ("DW_OP_form_tls_address");
903 /* GNU extensions. */
904 case DW_OP_GNU_push_tls_address:
905 printf ("DW_OP_GNU_push_tls_address");
909 if (op >= DW_OP_lo_user
910 && op <= DW_OP_hi_user)
911 printf (_("(User defined location op)"));
913 printf (_("(Unknown location op)"));
914 /* No way to tell where the next op is, so just bail. */
915 return need_frame_base;
918 /* Separate the ops. */
923 return need_frame_base;
926 static unsigned char *
927 read_and_display_attr_value (unsigned long attribute,
930 unsigned long cu_offset,
931 unsigned long pointer_size,
932 unsigned long offset_size,
934 debug_info *debug_info_p,
937 unsigned long uvalue = 0;
938 unsigned char *block_start = NULL;
939 unsigned int bytes_read;
946 case DW_FORM_ref_addr:
947 if (dwarf_version == 2)
949 uvalue = byte_get (data, pointer_size);
950 data += pointer_size;
952 else if (dwarf_version == 3)
954 uvalue = byte_get (data, offset_size);
959 error (_("Internal error: DWARF version is not 2 or 3.\n"));
964 uvalue = byte_get (data, pointer_size);
965 data += pointer_size;
969 uvalue = byte_get (data, offset_size);
973 case DW_FORM_flag_present:
980 uvalue = byte_get (data++, 1);
985 uvalue = byte_get (data, 2);
991 uvalue = byte_get (data, 4);
996 uvalue = read_leb128 (data, & bytes_read, 1);
1000 case DW_FORM_ref_udata:
1002 uvalue = read_leb128 (data, & bytes_read, 0);
1006 case DW_FORM_indirect:
1007 form = read_leb128 (data, & bytes_read, 0);
1010 printf (" %s", get_FORM_name (form));
1011 return read_and_display_attr_value (attribute, form, data,
1012 cu_offset, pointer_size,
1013 offset_size, dwarf_version,
1014 debug_info_p, do_loc);
1019 case DW_FORM_ref_addr:
1021 printf (" <#%lx>", uvalue);
1027 case DW_FORM_ref_udata:
1029 printf (" <%lx>", uvalue + cu_offset);
1035 printf (" %#lx", uvalue);
1038 case DW_FORM_flag_present:
1045 printf (" %ld", uvalue);
1052 uvalue = byte_get (data, 4);
1053 printf (" %lx", uvalue);
1054 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
1056 if ((do_loc || do_debug_loc || do_debug_ranges)
1057 && num_debug_info_entries == 0)
1059 if (sizeof (uvalue) == 8)
1060 uvalue = byte_get (data, 8);
1062 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1067 case DW_FORM_string:
1069 printf (" %s", data);
1070 data += strlen ((char *) data) + 1;
1074 uvalue = read_leb128 (data, & bytes_read, 0);
1075 block_start = data + bytes_read;
1077 data = block_start + uvalue;
1079 data = display_block (block_start, uvalue);
1082 case DW_FORM_block1:
1083 uvalue = byte_get (data, 1);
1084 block_start = data + 1;
1086 data = block_start + uvalue;
1088 data = display_block (block_start, uvalue);
1091 case DW_FORM_block2:
1092 uvalue = byte_get (data, 2);
1093 block_start = data + 2;
1095 data = block_start + uvalue;
1097 data = display_block (block_start, uvalue);
1100 case DW_FORM_block4:
1101 uvalue = byte_get (data, 4);
1102 block_start = data + 4;
1104 data = block_start + uvalue;
1106 data = display_block (block_start, uvalue);
1111 printf (_(" (indirect string, offset: 0x%lx): %s"),
1112 uvalue, fetch_indirect_string (uvalue));
1115 case DW_FORM_indirect:
1116 /* Handled above. */
1120 warn (_("Unrecognized form: %lu\n"), form);
1124 /* For some attributes we can display further information. */
1125 if ((do_loc || do_debug_loc || do_debug_ranges)
1126 && num_debug_info_entries == 0)
1130 case DW_AT_frame_base:
1131 have_frame_base = 1;
1132 case DW_AT_location:
1133 case DW_AT_data_member_location:
1134 case DW_AT_vtable_elem_location:
1135 case DW_AT_allocated:
1136 case DW_AT_associated:
1137 case DW_AT_data_location:
1139 case DW_AT_upper_bound:
1140 case DW_AT_lower_bound:
1141 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1143 /* Process location list. */
1144 unsigned int max = debug_info_p->max_loc_offsets;
1145 unsigned int num = debug_info_p->num_loc_offsets;
1147 if (max == 0 || num >= max)
1150 debug_info_p->loc_offsets
1151 = xcrealloc (debug_info_p->loc_offsets,
1152 max, sizeof (*debug_info_p->loc_offsets));
1153 debug_info_p->have_frame_base
1154 = xcrealloc (debug_info_p->have_frame_base,
1155 max, sizeof (*debug_info_p->have_frame_base));
1156 debug_info_p->max_loc_offsets = max;
1158 debug_info_p->loc_offsets [num] = uvalue;
1159 debug_info_p->have_frame_base [num] = have_frame_base;
1160 debug_info_p->num_loc_offsets++;
1165 if (need_base_address)
1166 debug_info_p->base_address = uvalue;
1170 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1172 /* Process range list. */
1173 unsigned int max = debug_info_p->max_range_lists;
1174 unsigned int num = debug_info_p->num_range_lists;
1176 if (max == 0 || num >= max)
1179 debug_info_p->range_lists
1180 = xcrealloc (debug_info_p->range_lists,
1181 max, sizeof (*debug_info_p->range_lists));
1182 debug_info_p->max_range_lists = max;
1184 debug_info_p->range_lists [num] = uvalue;
1185 debug_info_p->num_range_lists++;
1204 case DW_INL_not_inlined:
1205 printf (_("(not inlined)"));
1207 case DW_INL_inlined:
1208 printf (_("(inlined)"));
1210 case DW_INL_declared_not_inlined:
1211 printf (_("(declared as inline but ignored)"));
1213 case DW_INL_declared_inlined:
1214 printf (_("(declared as inline and inlined)"));
1217 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1222 case DW_AT_language:
1225 /* Ordered by the numeric value of these constants. */
1226 case DW_LANG_C89: printf ("(ANSI C)"); break;
1227 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1228 case DW_LANG_Ada83: printf ("(Ada)"); break;
1229 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1230 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1231 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1232 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1233 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1234 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1235 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1236 /* DWARF 2.1 values. */
1237 case DW_LANG_Java: printf ("(Java)"); break;
1238 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1239 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1240 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1241 /* DWARF 3 values. */
1242 case DW_LANG_PLI: printf ("(PLI)"); break;
1243 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1244 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1245 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1246 case DW_LANG_D: printf ("(D)"); break;
1247 /* MIPS extension. */
1248 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1249 /* UPC extension. */
1250 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1252 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1253 printf ("(implementation defined: %lx)", uvalue);
1255 printf ("(Unknown: %lx)", uvalue);
1260 case DW_AT_encoding:
1263 case DW_ATE_void: printf ("(void)"); break;
1264 case DW_ATE_address: printf ("(machine address)"); break;
1265 case DW_ATE_boolean: printf ("(boolean)"); break;
1266 case DW_ATE_complex_float: printf ("(complex float)"); break;
1267 case DW_ATE_float: printf ("(float)"); break;
1268 case DW_ATE_signed: printf ("(signed)"); break;
1269 case DW_ATE_signed_char: printf ("(signed char)"); break;
1270 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1271 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1272 /* DWARF 2.1 value. */
1273 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1274 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1276 if (uvalue >= DW_ATE_lo_user
1277 && uvalue <= DW_ATE_hi_user)
1278 printf ("(user defined type)");
1280 printf ("(unknown type)");
1285 case DW_AT_accessibility:
1288 case DW_ACCESS_public: printf ("(public)"); break;
1289 case DW_ACCESS_protected: printf ("(protected)"); break;
1290 case DW_ACCESS_private: printf ("(private)"); break;
1292 printf ("(unknown accessibility)");
1297 case DW_AT_visibility:
1300 case DW_VIS_local: printf ("(local)"); break;
1301 case DW_VIS_exported: printf ("(exported)"); break;
1302 case DW_VIS_qualified: printf ("(qualified)"); break;
1303 default: printf ("(unknown visibility)"); break;
1307 case DW_AT_virtuality:
1310 case DW_VIRTUALITY_none: printf ("(none)"); break;
1311 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1312 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1313 default: printf ("(unknown virtuality)"); break;
1317 case DW_AT_identifier_case:
1320 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1321 case DW_ID_up_case: printf ("(up_case)"); break;
1322 case DW_ID_down_case: printf ("(down_case)"); break;
1323 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1324 default: printf ("(unknown case)"); break;
1328 case DW_AT_calling_convention:
1331 case DW_CC_normal: printf ("(normal)"); break;
1332 case DW_CC_program: printf ("(program)"); break;
1333 case DW_CC_nocall: printf ("(nocall)"); break;
1335 if (uvalue >= DW_CC_lo_user
1336 && uvalue <= DW_CC_hi_user)
1337 printf ("(user defined)");
1339 printf ("(unknown convention)");
1343 case DW_AT_ordering:
1346 case -1: printf ("(undefined)"); break;
1347 case 0: printf ("(row major)"); break;
1348 case 1: printf ("(column major)"); break;
1352 case DW_AT_frame_base:
1353 have_frame_base = 1;
1354 case DW_AT_location:
1355 case DW_AT_data_member_location:
1356 case DW_AT_vtable_elem_location:
1357 case DW_AT_allocated:
1358 case DW_AT_associated:
1359 case DW_AT_data_location:
1361 case DW_AT_upper_bound:
1362 case DW_AT_lower_bound:
1365 int need_frame_base;
1368 need_frame_base = decode_location_expression (block_start,
1373 if (need_frame_base && !have_frame_base)
1374 printf (_(" [without DW_AT_frame_base]"));
1376 else if (form == DW_FORM_data4 || form == DW_FORM_data8)
1377 printf (_("(location list)"));
1389 get_AT_name (unsigned long attribute)
1393 case DW_AT_sibling: return "DW_AT_sibling";
1394 case DW_AT_location: return "DW_AT_location";
1395 case DW_AT_name: return "DW_AT_name";
1396 case DW_AT_ordering: return "DW_AT_ordering";
1397 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1398 case DW_AT_byte_size: return "DW_AT_byte_size";
1399 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1400 case DW_AT_bit_size: return "DW_AT_bit_size";
1401 case DW_AT_element_list: return "DW_AT_element_list";
1402 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1403 case DW_AT_low_pc: return "DW_AT_low_pc";
1404 case DW_AT_high_pc: return "DW_AT_high_pc";
1405 case DW_AT_language: return "DW_AT_language";
1406 case DW_AT_member: return "DW_AT_member";
1407 case DW_AT_discr: return "DW_AT_discr";
1408 case DW_AT_discr_value: return "DW_AT_discr_value";
1409 case DW_AT_visibility: return "DW_AT_visibility";
1410 case DW_AT_import: return "DW_AT_import";
1411 case DW_AT_string_length: return "DW_AT_string_length";
1412 case DW_AT_common_reference: return "DW_AT_common_reference";
1413 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1414 case DW_AT_const_value: return "DW_AT_const_value";
1415 case DW_AT_containing_type: return "DW_AT_containing_type";
1416 case DW_AT_default_value: return "DW_AT_default_value";
1417 case DW_AT_inline: return "DW_AT_inline";
1418 case DW_AT_is_optional: return "DW_AT_is_optional";
1419 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1420 case DW_AT_producer: return "DW_AT_producer";
1421 case DW_AT_prototyped: return "DW_AT_prototyped";
1422 case DW_AT_return_addr: return "DW_AT_return_addr";
1423 case DW_AT_start_scope: return "DW_AT_start_scope";
1424 case DW_AT_stride_size: return "DW_AT_stride_size";
1425 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1426 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1427 case DW_AT_accessibility: return "DW_AT_accessibility";
1428 case DW_AT_address_class: return "DW_AT_address_class";
1429 case DW_AT_artificial: return "DW_AT_artificial";
1430 case DW_AT_base_types: return "DW_AT_base_types";
1431 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1432 case DW_AT_count: return "DW_AT_count";
1433 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1434 case DW_AT_decl_column: return "DW_AT_decl_column";
1435 case DW_AT_decl_file: return "DW_AT_decl_file";
1436 case DW_AT_decl_line: return "DW_AT_decl_line";
1437 case DW_AT_declaration: return "DW_AT_declaration";
1438 case DW_AT_discr_list: return "DW_AT_discr_list";
1439 case DW_AT_encoding: return "DW_AT_encoding";
1440 case DW_AT_external: return "DW_AT_external";
1441 case DW_AT_frame_base: return "DW_AT_frame_base";
1442 case DW_AT_friend: return "DW_AT_friend";
1443 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1444 case DW_AT_macro_info: return "DW_AT_macro_info";
1445 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1446 case DW_AT_priority: return "DW_AT_priority";
1447 case DW_AT_segment: return "DW_AT_segment";
1448 case DW_AT_specification: return "DW_AT_specification";
1449 case DW_AT_static_link: return "DW_AT_static_link";
1450 case DW_AT_type: return "DW_AT_type";
1451 case DW_AT_use_location: return "DW_AT_use_location";
1452 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1453 case DW_AT_virtuality: return "DW_AT_virtuality";
1454 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1455 /* DWARF 2.1 values. */
1456 case DW_AT_allocated: return "DW_AT_allocated";
1457 case DW_AT_associated: return "DW_AT_associated";
1458 case DW_AT_data_location: return "DW_AT_data_location";
1459 case DW_AT_stride: return "DW_AT_stride";
1460 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1461 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1462 case DW_AT_extension: return "DW_AT_extension";
1463 case DW_AT_ranges: return "DW_AT_ranges";
1464 case DW_AT_trampoline: return "DW_AT_trampoline";
1465 case DW_AT_call_column: return "DW_AT_call_column";
1466 case DW_AT_call_file: return "DW_AT_call_file";
1467 case DW_AT_call_line: return "DW_AT_call_line";
1468 /* SGI/MIPS extensions. */
1469 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
1470 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1471 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1472 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1473 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1474 case DW_AT_MIPS_software_pipeline_depth:
1475 return "DW_AT_MIPS_software_pipeline_depth";
1476 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1477 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1478 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1479 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1480 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1481 /* GNU extensions. */
1482 case DW_AT_sf_names: return "DW_AT_sf_names";
1483 case DW_AT_src_info: return "DW_AT_src_info";
1484 case DW_AT_mac_info: return "DW_AT_mac_info";
1485 case DW_AT_src_coords: return "DW_AT_src_coords";
1486 case DW_AT_body_begin: return "DW_AT_body_begin";
1487 case DW_AT_body_end: return "DW_AT_body_end";
1488 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1489 /* UPC extension. */
1490 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1493 static char buffer[100];
1495 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1502 static unsigned char *
1503 read_and_display_attr (unsigned long attribute,
1505 unsigned char *data,
1506 unsigned long cu_offset,
1507 unsigned long pointer_size,
1508 unsigned long offset_size,
1510 debug_info *debug_info_p,
1514 printf (" %-18s:", get_AT_name (attribute));
1515 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1516 pointer_size, offset_size,
1517 dwarf_version, debug_info_p,
1525 /* Process the contents of a .debug_info section. If do_loc is non-zero
1526 then we are scanning for location lists and we do not want to display
1527 anything to the user. */
1530 process_debug_info (struct dwarf_section *section, void *file,
1533 unsigned char *start = section->start;
1534 unsigned char *end = start + section->size;
1535 unsigned char *section_begin;
1537 unsigned int num_units = 0;
1539 if ((do_loc || do_debug_loc || do_debug_ranges)
1540 && num_debug_info_entries == 0)
1542 unsigned long length;
1544 /* First scan the section to get the number of comp units. */
1545 for (section_begin = start, num_units = 0; section_begin < end;
1548 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1549 will be the length. For a 64-bit DWARF section, it'll be
1550 the escape code 0xffffffff followed by an 8 byte length. */
1551 length = byte_get (section_begin, 4);
1553 if (length == 0xffffffff)
1555 length = byte_get (section_begin + 4, 8);
1556 section_begin += length + 12;
1559 section_begin += length + 4;
1564 error (_("No comp units in %s section ?"), section->name);
1568 /* Then allocate an array to hold the information. */
1569 debug_information = cmalloc (num_units,
1570 sizeof (* debug_information));
1571 if (debug_information == NULL)
1573 error (_("Not enough memory for a debug info array of %u entries"),
1581 printf (_("The section %s contains:\n\n"), section->name);
1583 load_debug_section (str, file);
1586 load_debug_section (abbrev, file);
1587 if (debug_displays [abbrev].section.start == NULL)
1589 warn (_("Unable to locate %s section!\n"),
1590 debug_displays [abbrev].section.name);
1594 for (section_begin = start, unit = 0; start < end; unit++)
1596 DWARF2_Internal_CompUnit compunit;
1597 unsigned char *hdrptr;
1598 unsigned char *cu_abbrev_offset_ptr;
1599 unsigned char *tags;
1601 unsigned long cu_offset;
1603 int initial_length_size;
1607 compunit.cu_length = byte_get (hdrptr, 4);
1610 if (compunit.cu_length == 0xffffffff)
1612 compunit.cu_length = byte_get (hdrptr, 8);
1615 initial_length_size = 12;
1620 initial_length_size = 4;
1623 compunit.cu_version = byte_get (hdrptr, 2);
1626 cu_offset = start - section_begin;
1628 cu_abbrev_offset_ptr = hdrptr;
1629 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1630 hdrptr += offset_size;
1632 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1634 if ((do_loc || do_debug_loc || do_debug_ranges)
1635 && num_debug_info_entries == 0)
1637 debug_information [unit].cu_offset = cu_offset;
1638 debug_information [unit].pointer_size
1639 = compunit.cu_pointer_size;
1640 debug_information [unit].base_address = 0;
1641 debug_information [unit].loc_offsets = NULL;
1642 debug_information [unit].have_frame_base = NULL;
1643 debug_information [unit].max_loc_offsets = 0;
1644 debug_information [unit].num_loc_offsets = 0;
1645 debug_information [unit].range_lists = NULL;
1646 debug_information [unit].max_range_lists= 0;
1647 debug_information [unit].num_range_lists = 0;
1652 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1653 printf (_(" Length: %ld\n"), compunit.cu_length);
1654 printf (_(" Version: %d\n"), compunit.cu_version);
1655 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1656 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1659 if (cu_offset + compunit.cu_length + initial_length_size
1662 warn (_("Debug info is corrupted, length is invalid (section is %lu bytes)\n"),
1663 (unsigned long)section->size);
1667 start += compunit.cu_length + initial_length_size;
1669 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1671 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1677 /* Process the abbrevs used by this compilation unit. DWARF
1678 sections under Mach-O have non-zero addresses. */
1679 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1680 warn (_("Debug info is corrupted, abbrev offset is invalid (section is %lu bytes)\n"),
1681 (unsigned long)debug_displays [abbrev].section.size);
1683 process_abbrev_section
1684 ((unsigned char *) debug_displays [abbrev].section.start
1685 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1686 (unsigned char *) debug_displays [abbrev].section.start
1687 + debug_displays [abbrev].section.size);
1690 while (tags < start)
1692 unsigned int bytes_read;
1693 unsigned long abbrev_number;
1694 abbrev_entry *entry;
1697 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1700 /* A null DIE marks the end of a list of children. */
1701 if (abbrev_number == 0)
1708 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1710 (unsigned long) (tags - section_begin
1714 /* Scan through the abbreviation list until we reach the
1716 for (entry = first_abbrev;
1717 entry && entry->entry != abbrev_number;
1718 entry = entry->next)
1728 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1734 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1739 need_base_address = 0;
1741 case DW_TAG_compile_unit:
1742 need_base_address = 1;
1744 case DW_TAG_entry_point:
1745 case DW_TAG_subprogram:
1746 need_base_address = 0;
1747 /* Assuming that there is no DW_AT_frame_base. */
1748 have_frame_base = 0;
1752 for (attr = entry->first_attr; attr; attr = attr->next)
1755 /* Show the offset from where the tag was extracted. */
1756 printf (" <%2lx>", (unsigned long)(tags - section_begin));
1758 tags = read_and_display_attr (attr->attribute,
1761 compunit.cu_pointer_size,
1763 compunit.cu_version,
1764 &debug_information [unit],
1768 if (entry->children)
1773 /* Set num_debug_info_entries here so that it can be used to check if
1774 we need to process .debug_loc and .debug_ranges sections. */
1775 if ((do_loc || do_debug_loc || do_debug_ranges)
1776 && num_debug_info_entries == 0)
1777 num_debug_info_entries = num_units;
1787 /* Locate and scan the .debug_info section in the file and record the pointer
1788 sizes and offsets for the compilation units in it. Usually an executable
1789 will have just one pointer size, but this is not guaranteed, and so we try
1790 not to make any assumptions. Returns zero upon failure, or the number of
1791 compilation units upon success. */
1794 load_debug_info (void * file)
1796 /* Reset the last pointer size so that we can issue correct error
1797 messages if we are displaying the contents of more than one section. */
1798 last_pointer_size = 0;
1799 warned_about_missing_comp_units = FALSE;
1801 /* If we already have the information there is nothing else to do. */
1802 if (num_debug_info_entries > 0)
1803 return num_debug_info_entries;
1805 if (load_debug_section (info, file)
1806 && process_debug_info (&debug_displays [info].section, file, 1))
1807 return num_debug_info_entries;
1813 display_debug_lines (struct dwarf_section *section, void *file)
1815 unsigned char *start = section->start;
1816 unsigned char *data = start;
1817 unsigned char *end = start + section->size;
1819 printf (_("\nDump of debug contents of section %s:\n\n"),
1822 load_debug_info (file);
1826 DWARF2_Internal_LineInfo info;
1827 unsigned char *standard_opcodes;
1828 unsigned char *end_of_sequence;
1829 unsigned char *hdrptr;
1830 int initial_length_size;
1836 /* Check the length of the block. */
1837 info.li_length = byte_get (hdrptr, 4);
1840 if (info.li_length == 0xffffffff)
1842 /* This section is 64-bit DWARF 3. */
1843 info.li_length = byte_get (hdrptr, 8);
1846 initial_length_size = 12;
1851 initial_length_size = 4;
1854 if (info.li_length + initial_length_size > section->size)
1857 (_("The line info appears to be corrupt - the section is too small\n"));
1861 /* Check its version number. */
1862 info.li_version = byte_get (hdrptr, 2);
1864 if (info.li_version != 2 && info.li_version != 3)
1866 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1870 info.li_prologue_length = byte_get (hdrptr, offset_size);
1871 hdrptr += offset_size;
1872 info.li_min_insn_length = byte_get (hdrptr, 1);
1874 info.li_default_is_stmt = byte_get (hdrptr, 1);
1876 info.li_line_base = byte_get (hdrptr, 1);
1878 info.li_line_range = byte_get (hdrptr, 1);
1880 info.li_opcode_base = byte_get (hdrptr, 1);
1883 /* Sign extend the line base field. */
1884 info.li_line_base <<= 24;
1885 info.li_line_base >>= 24;
1887 printf (_(" Length: %ld\n"), info.li_length);
1888 printf (_(" DWARF Version: %d\n"), info.li_version);
1889 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
1890 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
1891 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
1892 printf (_(" Line Base: %d\n"), info.li_line_base);
1893 printf (_(" Line Range: %d\n"), info.li_line_range);
1894 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
1896 end_of_sequence = data + info.li_length + initial_length_size;
1898 reset_state_machine (info.li_default_is_stmt);
1900 /* Display the contents of the Opcodes table. */
1901 standard_opcodes = hdrptr;
1903 printf (_("\n Opcodes:\n"));
1905 for (i = 1; i < info.li_opcode_base; i++)
1906 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
1908 /* Display the contents of the Directory table. */
1909 data = standard_opcodes + info.li_opcode_base - 1;
1912 printf (_("\n The Directory Table is empty.\n"));
1915 printf (_("\n The Directory Table:\n"));
1919 printf (_(" %s\n"), data);
1921 data += strlen ((char *) data) + 1;
1925 /* Skip the NUL at the end of the table. */
1928 /* Display the contents of the File Name table. */
1930 printf (_("\n The File Name Table is empty.\n"));
1933 printf (_("\n The File Name Table:\n"));
1934 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
1938 unsigned char *name;
1939 unsigned int bytes_read;
1941 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
1944 data += strlen ((char *) data) + 1;
1946 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1948 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1950 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1952 printf (_("%s\n"), name);
1956 /* Skip the NUL at the end of the table. */
1959 /* Now display the statements. */
1960 printf (_("\n Line Number Statements:\n"));
1962 while (data < end_of_sequence)
1964 unsigned char op_code;
1966 unsigned long int uladv;
1967 unsigned int bytes_read;
1971 if (op_code >= info.li_opcode_base)
1973 op_code -= info.li_opcode_base;
1974 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
1975 state_machine_regs.address += uladv;
1976 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
1977 op_code, uladv, state_machine_regs.address);
1978 adv = (op_code % info.li_line_range) + info.li_line_base;
1979 state_machine_regs.line += adv;
1980 printf (_(" and Line by %d to %d\n"),
1981 adv, state_machine_regs.line);
1983 else switch (op_code)
1985 case DW_LNS_extended_op:
1986 data += process_extended_line_op (data, info.li_default_is_stmt);
1990 printf (_(" Copy\n"));
1993 case DW_LNS_advance_pc:
1994 uladv = read_leb128 (data, & bytes_read, 0);
1995 uladv *= info.li_min_insn_length;
1997 state_machine_regs.address += uladv;
1998 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
1999 state_machine_regs.address);
2002 case DW_LNS_advance_line:
2003 adv = read_leb128 (data, & bytes_read, 1);
2005 state_machine_regs.line += adv;
2006 printf (_(" Advance Line by %d to %d\n"), adv,
2007 state_machine_regs.line);
2010 case DW_LNS_set_file:
2011 adv = read_leb128 (data, & bytes_read, 0);
2013 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2015 state_machine_regs.file = adv;
2018 case DW_LNS_set_column:
2019 uladv = read_leb128 (data, & bytes_read, 0);
2021 printf (_(" Set column to %lu\n"), uladv);
2022 state_machine_regs.column = uladv;
2025 case DW_LNS_negate_stmt:
2026 adv = state_machine_regs.is_stmt;
2028 printf (_(" Set is_stmt to %d\n"), adv);
2029 state_machine_regs.is_stmt = adv;
2032 case DW_LNS_set_basic_block:
2033 printf (_(" Set basic block\n"));
2034 state_machine_regs.basic_block = 1;
2037 case DW_LNS_const_add_pc:
2038 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2039 * info.li_min_insn_length);
2040 state_machine_regs.address += uladv;
2041 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2042 state_machine_regs.address);
2045 case DW_LNS_fixed_advance_pc:
2046 uladv = byte_get (data, 2);
2048 state_machine_regs.address += uladv;
2049 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2050 uladv, state_machine_regs.address);
2053 case DW_LNS_set_prologue_end:
2054 printf (_(" Set prologue_end to true\n"));
2057 case DW_LNS_set_epilogue_begin:
2058 printf (_(" Set epilogue_begin to true\n"));
2061 case DW_LNS_set_isa:
2062 uladv = read_leb128 (data, & bytes_read, 0);
2064 printf (_(" Set ISA to %lu\n"), uladv);
2068 printf (_(" Unknown opcode %d with operands: "), op_code);
2070 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2072 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2073 i == 1 ? "" : ", ");
2087 display_debug_pubnames (struct dwarf_section *section,
2088 void *file ATTRIBUTE_UNUSED)
2090 DWARF2_Internal_PubNames pubnames;
2091 unsigned char *start = section->start;
2092 unsigned char *end = start + section->size;
2094 printf (_("Contents of the %s section:\n\n"), section->name);
2098 unsigned char *data;
2099 unsigned long offset;
2100 int offset_size, initial_length_size;
2104 pubnames.pn_length = byte_get (data, 4);
2106 if (pubnames.pn_length == 0xffffffff)
2108 pubnames.pn_length = byte_get (data, 8);
2111 initial_length_size = 12;
2116 initial_length_size = 4;
2119 pubnames.pn_version = byte_get (data, 2);
2121 pubnames.pn_offset = byte_get (data, offset_size);
2122 data += offset_size;
2123 pubnames.pn_size = byte_get (data, offset_size);
2124 data += offset_size;
2126 start += pubnames.pn_length + initial_length_size;
2128 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2130 static int warned = 0;
2134 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2141 printf (_(" Length: %ld\n"),
2142 pubnames.pn_length);
2143 printf (_(" Version: %d\n"),
2144 pubnames.pn_version);
2145 printf (_(" Offset into .debug_info section: %ld\n"),
2146 pubnames.pn_offset);
2147 printf (_(" Size of area in .debug_info section: %ld\n"),
2150 printf (_("\n Offset\tName\n"));
2154 offset = byte_get (data, offset_size);
2158 data += offset_size;
2159 printf (" %-6ld\t\t%s\n", offset, data);
2160 data += strlen ((char *) data) + 1;
2163 while (offset != 0);
2171 display_debug_macinfo (struct dwarf_section *section,
2172 void *file ATTRIBUTE_UNUSED)
2174 unsigned char *start = section->start;
2175 unsigned char *end = start + section->size;
2176 unsigned char *curr = start;
2177 unsigned int bytes_read;
2178 enum dwarf_macinfo_record_type op;
2180 printf (_("Contents of the %s section:\n\n"), section->name);
2184 unsigned int lineno;
2192 case DW_MACINFO_start_file:
2194 unsigned int filenum;
2196 lineno = read_leb128 (curr, & bytes_read, 0);
2198 filenum = read_leb128 (curr, & bytes_read, 0);
2201 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2206 case DW_MACINFO_end_file:
2207 printf (_(" DW_MACINFO_end_file\n"));
2210 case DW_MACINFO_define:
2211 lineno = read_leb128 (curr, & bytes_read, 0);
2213 string = (char *) curr;
2214 curr += strlen (string) + 1;
2215 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2219 case DW_MACINFO_undef:
2220 lineno = read_leb128 (curr, & bytes_read, 0);
2222 string = (char *) curr;
2223 curr += strlen (string) + 1;
2224 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2228 case DW_MACINFO_vendor_ext:
2230 unsigned int constant;
2232 constant = read_leb128 (curr, & bytes_read, 0);
2234 string = (char *) curr;
2235 curr += strlen (string) + 1;
2236 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2247 display_debug_abbrev (struct dwarf_section *section,
2248 void *file ATTRIBUTE_UNUSED)
2250 abbrev_entry *entry;
2251 unsigned char *start = section->start;
2252 unsigned char *end = start + section->size;
2254 printf (_("Contents of the %s section:\n\n"), section->name);
2260 start = process_abbrev_section (start, end);
2262 if (first_abbrev == NULL)
2265 printf (_(" Number TAG\n"));
2267 for (entry = first_abbrev; entry; entry = entry->next)
2271 printf (_(" %ld %s [%s]\n"),
2273 get_TAG_name (entry->tag),
2274 entry->children ? _("has children") : _("no children"));
2276 for (attr = entry->first_attr; attr; attr = attr->next)
2277 printf (_(" %-18s %s\n"),
2278 get_AT_name (attr->attribute),
2279 get_FORM_name (attr->form));
2290 display_debug_loc (struct dwarf_section *section, void *file)
2292 unsigned char *start = section->start;
2293 unsigned char *section_end;
2294 unsigned long bytes;
2295 unsigned char *section_begin = start;
2296 unsigned int num_loc_list = 0;
2297 unsigned long last_offset = 0;
2298 unsigned int first = 0;
2301 int seen_first_offset = 0;
2302 int use_debug_info = 1;
2303 unsigned char *next;
2305 bytes = section->size;
2306 section_end = start + bytes;
2310 printf (_("\nThe %s section is empty.\n"), section->name);
2314 load_debug_info (file);
2316 /* Check the order of location list in .debug_info section. If
2317 offsets of location lists are in the ascending order, we can
2318 use `debug_information' directly. */
2319 for (i = 0; i < num_debug_info_entries; i++)
2323 num = debug_information [i].num_loc_offsets;
2324 num_loc_list += num;
2326 /* Check if we can use `debug_information' directly. */
2327 if (use_debug_info && num != 0)
2329 if (!seen_first_offset)
2331 /* This is the first location list. */
2332 last_offset = debug_information [i].loc_offsets [0];
2334 seen_first_offset = 1;
2340 for (; j < num; j++)
2343 debug_information [i].loc_offsets [j])
2348 last_offset = debug_information [i].loc_offsets [j];
2353 if (!use_debug_info)
2354 /* FIXME: Should we handle this case? */
2355 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2357 if (!seen_first_offset)
2358 error (_("No location lists in .debug_info section!\n"));
2360 /* DWARF sections under Mach-O have non-zero addresses. */
2361 if (debug_information [first].num_loc_offsets > 0
2362 && debug_information [first].loc_offsets [0] != section->address)
2363 warn (_("Location lists in %s section start at 0x%lx\n"),
2364 section->name, debug_information [first].loc_offsets [0]);
2366 printf (_("Contents of the %s section:\n\n"), section->name);
2367 printf (_(" Offset Begin End Expression\n"));
2369 seen_first_offset = 0;
2370 for (i = first; i < num_debug_info_entries; i++)
2372 unsigned long begin;
2374 unsigned short length;
2375 unsigned long offset;
2376 unsigned int pointer_size;
2377 unsigned long cu_offset;
2378 unsigned long base_address;
2379 int need_frame_base;
2382 pointer_size = debug_information [i].pointer_size;
2383 cu_offset = debug_information [i].cu_offset;
2385 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2387 has_frame_base = debug_information [i].have_frame_base [j];
2388 /* DWARF sections under Mach-O have non-zero addresses. */
2389 offset = debug_information [i].loc_offsets [j] - section->address;
2390 next = section_begin + offset;
2391 base_address = debug_information [i].base_address;
2393 if (!seen_first_offset)
2394 seen_first_offset = 1;
2398 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2399 (long)(start - section_begin), (long)(next - section_begin));
2400 else if (start > next)
2401 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2402 (long)(start - section_begin), (long)(next - section_begin));
2406 if (offset >= bytes)
2408 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2415 if (start + 2 * pointer_size > section_end)
2417 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2422 begin = byte_get (start, pointer_size);
2423 start += pointer_size;
2424 end = byte_get (start, pointer_size);
2425 start += pointer_size;
2427 if (begin == 0 && end == 0)
2429 printf (_(" %8.8lx <End of list>\n"), offset);
2433 /* Check base address specifiers. */
2434 if (begin == -1UL && end != -1UL)
2437 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2438 offset, begin, end);
2442 if (start + 2 > section_end)
2444 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2449 length = byte_get (start, 2);
2452 if (start + length > section_end)
2454 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2459 printf (" %8.8lx %8.8lx %8.8lx (",
2460 offset, begin + base_address, end + base_address);
2461 need_frame_base = decode_location_expression (start,
2467 if (need_frame_base && !has_frame_base)
2468 printf (_(" [without DW_AT_frame_base]"));
2471 fputs (_(" (start == end)"), stdout);
2472 else if (begin > end)
2473 fputs (_(" (start > end)"), stdout);
2485 display_debug_str (struct dwarf_section *section,
2486 void *file ATTRIBUTE_UNUSED)
2488 unsigned char *start = section->start;
2489 unsigned long bytes = section->size;
2490 dwarf_vma addr = section->address;
2494 printf (_("\nThe %s section is empty.\n"), section->name);
2498 printf (_("Contents of the %s section:\n\n"), section->name);
2506 lbytes = (bytes > 16 ? 16 : bytes);
2508 printf (" 0x%8.8lx ", (unsigned long) addr);
2510 for (j = 0; j < 16; j++)
2513 printf ("%2.2x", start[j]);
2521 for (j = 0; j < lbytes; j++)
2524 if (k >= ' ' && k < 0x80)
2543 display_debug_info (struct dwarf_section *section, void *file)
2545 return process_debug_info (section, file, 0);
2550 display_debug_aranges (struct dwarf_section *section,
2551 void *file ATTRIBUTE_UNUSED)
2553 unsigned char *start = section->start;
2554 unsigned char *end = start + section->size;
2556 printf (_("The section %s contains:\n\n"), section->name);
2560 unsigned char *hdrptr;
2561 DWARF2_Internal_ARange arange;
2562 unsigned char *ranges;
2563 unsigned long length;
2564 unsigned long address;
2565 unsigned char address_size;
2568 int initial_length_size;
2572 arange.ar_length = byte_get (hdrptr, 4);
2575 if (arange.ar_length == 0xffffffff)
2577 arange.ar_length = byte_get (hdrptr, 8);
2580 initial_length_size = 12;
2585 initial_length_size = 4;
2588 arange.ar_version = byte_get (hdrptr, 2);
2591 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2592 hdrptr += offset_size;
2594 arange.ar_pointer_size = byte_get (hdrptr, 1);
2597 arange.ar_segment_size = byte_get (hdrptr, 1);
2600 if (arange.ar_version != 2 && arange.ar_version != 3)
2602 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2606 printf (_(" Length: %ld\n"), arange.ar_length);
2607 printf (_(" Version: %d\n"), arange.ar_version);
2608 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
2609 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2610 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2612 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2614 /* The DWARF spec does not require that the address size be a power
2615 of two, but we do. This will have to change if we ever encounter
2616 an uneven architecture. */
2617 if ((address_size & (address_size - 1)) != 0)
2619 warn (_("Pointer size + Segment size is not a power of two.\n"));
2623 if (address_size > 4)
2624 printf (_("\n Address Length\n"));
2626 printf (_("\n Address Length\n"));
2630 /* Must pad to an alignment boundary that is twice the address size. */
2631 excess = (hdrptr - start) % (2 * address_size);
2633 ranges += (2 * address_size) - excess;
2635 start += arange.ar_length + initial_length_size;
2637 while (ranges + 2 * address_size <= start)
2639 address = byte_get (ranges, address_size);
2641 ranges += address_size;
2643 length = byte_get (ranges, address_size);
2645 ranges += address_size;
2647 if (address_size > 4)
2648 printf (" 0x%16.16lx 0x%lx\n", address, length);
2650 printf (" 0x%8.8lx 0x%lx\n", address, length);
2660 display_debug_ranges (struct dwarf_section *section,
2661 void *file ATTRIBUTE_UNUSED)
2663 unsigned char *start = section->start;
2664 unsigned char *section_end;
2665 unsigned long bytes;
2666 unsigned char *section_begin = start;
2667 unsigned int num_range_list = 0;
2668 unsigned long last_offset = 0;
2669 unsigned int first = 0;
2672 int seen_first_offset = 0;
2673 int use_debug_info = 1;
2674 unsigned char *next;
2676 bytes = section->size;
2677 section_end = start + bytes;
2681 printf (_("\nThe %s section is empty.\n"), section->name);
2685 load_debug_info (file);
2687 /* Check the order of range list in .debug_info section. If
2688 offsets of range lists are in the ascending order, we can
2689 use `debug_information' directly. */
2690 for (i = 0; i < num_debug_info_entries; i++)
2694 num = debug_information [i].num_range_lists;
2695 num_range_list += num;
2697 /* Check if we can use `debug_information' directly. */
2698 if (use_debug_info && num != 0)
2700 if (!seen_first_offset)
2702 /* This is the first range list. */
2703 last_offset = debug_information [i].range_lists [0];
2705 seen_first_offset = 1;
2711 for (; j < num; j++)
2714 debug_information [i].range_lists [j])
2719 last_offset = debug_information [i].range_lists [j];
2724 if (!use_debug_info)
2725 /* FIXME: Should we handle this case? */
2726 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2728 if (!seen_first_offset)
2729 error (_("No range lists in .debug_info section!\n"));
2731 /* DWARF sections under Mach-O have non-zero addresses. */
2732 if (debug_information [first].num_range_lists > 0
2733 && debug_information [first].range_lists [0] != section->address)
2734 warn (_("Range lists in %s section start at 0x%lx\n"),
2735 section->name, debug_information [first].range_lists [0]);
2737 printf (_("Contents of the %s section:\n\n"), section->name);
2738 printf (_(" Offset Begin End\n"));
2740 seen_first_offset = 0;
2741 for (i = first; i < num_debug_info_entries; i++)
2743 unsigned long begin;
2745 unsigned long offset;
2746 unsigned int pointer_size;
2747 unsigned long base_address;
2749 pointer_size = debug_information [i].pointer_size;
2751 for (j = 0; j < debug_information [i].num_range_lists; j++)
2753 /* DWARF sections under Mach-O have non-zero addresses. */
2754 offset = debug_information [i].range_lists [j] - section->address;
2755 next = section_begin + offset;
2756 base_address = debug_information [i].base_address;
2758 if (!seen_first_offset)
2759 seen_first_offset = 1;
2763 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2764 (long)(start - section_begin),
2765 (long)(next - section_begin), section->name);
2766 else if (start > next)
2767 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2768 (long)(start - section_begin),
2769 (long)(next - section_begin), section->name);
2775 begin = byte_get (start, pointer_size);
2776 start += pointer_size;
2777 end = byte_get (start, pointer_size);
2778 start += pointer_size;
2780 if (begin == 0 && end == 0)
2782 printf (_(" %8.8lx <End of list>\n"), offset);
2786 /* Check base address specifiers. */
2787 if (begin == -1UL && end != -1UL)
2790 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
2791 offset, begin, end);
2795 printf (" %8.8lx %8.8lx %8.8lx",
2796 offset, begin + base_address, end + base_address);
2799 fputs (_(" (start == end)"), stdout);
2800 else if (begin > end)
2801 fputs (_(" (start > end)"), stdout);
2811 typedef struct Frame_Chunk
2813 struct Frame_Chunk *next;
2814 unsigned char *chunk_start;
2816 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
2817 short int *col_type;
2820 unsigned int code_factor;
2822 unsigned long pc_begin;
2823 unsigned long pc_range;
2827 unsigned char fde_encoding;
2828 unsigned char cfa_exp;
2832 /* A marker for a col_type that means this column was never referenced
2833 in the frame info. */
2834 #define DW_CFA_unreferenced (-1)
2837 frame_need_space (Frame_Chunk *fc, int reg)
2839 int prev = fc->ncols;
2841 if (reg < fc->ncols)
2844 fc->ncols = reg + 1;
2845 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2846 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2848 while (prev < fc->ncols)
2850 fc->col_type[prev] = DW_CFA_unreferenced;
2851 fc->col_offset[prev] = 0;
2857 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
2862 if (*max_regs < fc->ncols)
2863 *max_regs = fc->ncols;
2865 if (*need_col_headers)
2867 *need_col_headers = 0;
2869 printf (" LOC CFA ");
2871 for (r = 0; r < *max_regs; r++)
2872 if (fc->col_type[r] != DW_CFA_unreferenced)
2877 printf ("r%-4d", r);
2883 printf ("%08lx ", fc->pc_begin);
2885 strcpy (tmp, "exp");
2887 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
2888 printf ("%-8s ", tmp);
2890 for (r = 0; r < fc->ncols; r++)
2892 if (fc->col_type[r] != DW_CFA_unreferenced)
2894 switch (fc->col_type[r])
2896 case DW_CFA_undefined:
2899 case DW_CFA_same_value:
2903 sprintf (tmp, "c%+d", fc->col_offset[r]);
2905 case DW_CFA_val_offset:
2906 sprintf (tmp, "v%+d", fc->col_offset[r]);
2908 case DW_CFA_register:
2909 sprintf (tmp, "r%d", fc->col_offset[r]);
2911 case DW_CFA_expression:
2912 strcpy (tmp, "exp");
2914 case DW_CFA_val_expression:
2915 strcpy (tmp, "vexp");
2918 strcpy (tmp, "n/a");
2921 printf ("%-5s", tmp);
2928 size_of_encoded_value (int encoding)
2930 switch (encoding & 0x7)
2933 case 0: return eh_addr_size;
2941 get_encoded_value (unsigned char *data, int encoding)
2943 int size = size_of_encoded_value (encoding);
2945 if (encoding & DW_EH_PE_signed)
2946 return byte_get_signed (data, size);
2948 return byte_get (data, size);
2951 #define GET(N) byte_get (start, N); start += N
2952 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
2953 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
2956 display_debug_frames (struct dwarf_section *section,
2957 void *file ATTRIBUTE_UNUSED)
2959 unsigned char *start = section->start;
2960 unsigned char *end = start + section->size;
2961 unsigned char *section_start = start;
2962 Frame_Chunk *chunks = 0;
2963 Frame_Chunk *remembered_state = 0;
2965 int is_eh = strcmp (section->name, ".eh_frame") == 0;
2966 unsigned int length_return;
2969 printf (_("The section %s contains:\n"), section->name);
2973 unsigned char *saved_start;
2974 unsigned char *block_end;
2975 unsigned long length;
2976 unsigned long cie_id;
2979 int need_col_headers = 1;
2980 unsigned char *augmentation_data = NULL;
2981 unsigned long augmentation_data_len = 0;
2982 int encoded_ptr_size = eh_addr_size;
2984 int initial_length_size;
2986 saved_start = start;
2987 length = byte_get (start, 4); start += 4;
2991 printf ("\n%08lx ZERO terminator\n\n",
2992 (unsigned long)(saved_start - section_start));
2996 if (length == 0xffffffff)
2998 length = byte_get (start, 8);
3001 initial_length_size = 12;
3006 initial_length_size = 4;
3009 block_end = saved_start + length + initial_length_size;
3010 if (block_end > end)
3012 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3013 length, (unsigned long)(saved_start - section_start));
3016 cie_id = byte_get (start, offset_size); start += offset_size;
3018 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3022 fc = xmalloc (sizeof (Frame_Chunk));
3023 memset (fc, 0, sizeof (Frame_Chunk));
3027 fc->chunk_start = saved_start;
3029 fc->col_type = xmalloc (sizeof (short int));
3030 fc->col_offset = xmalloc (sizeof (int));
3031 frame_need_space (fc, max_regs-1);
3035 fc->augmentation = (char *) start;
3036 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3038 if (fc->augmentation[0] == 'z')
3040 fc->code_factor = LEB ();
3041 fc->data_factor = SLEB ();
3050 augmentation_data_len = LEB ();
3051 augmentation_data = start;
3052 start += augmentation_data_len;
3054 else if (strcmp (fc->augmentation, "eh") == 0)
3056 start += eh_addr_size;
3057 fc->code_factor = LEB ();
3058 fc->data_factor = SLEB ();
3070 fc->code_factor = LEB ();
3071 fc->data_factor = SLEB ();
3083 if (do_debug_frames_interp)
3084 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3085 (unsigned long)(saved_start - section_start), length, cie_id,
3086 fc->augmentation, fc->code_factor, fc->data_factor,
3090 printf ("\n%08lx %08lx %08lx CIE\n",
3091 (unsigned long)(saved_start - section_start), length, cie_id);
3092 printf (" Version: %d\n", version);
3093 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3094 printf (" Code alignment factor: %u\n", fc->code_factor);
3095 printf (" Data alignment factor: %d\n", fc->data_factor);
3096 printf (" Return address column: %d\n", fc->ra);
3098 if (augmentation_data_len)
3101 printf (" Augmentation data: ");
3102 for (i = 0; i < augmentation_data_len; ++i)
3103 printf (" %02x", augmentation_data[i]);
3109 if (augmentation_data_len)
3111 unsigned char *p, *q;
3112 p = (unsigned char *) fc->augmentation + 1;
3113 q = augmentation_data;
3120 q += 1 + size_of_encoded_value (*q);
3122 fc->fde_encoding = *q++;
3128 if (fc->fde_encoding)
3129 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3132 frame_need_space (fc, fc->ra);
3136 unsigned char *look_for;
3137 static Frame_Chunk fde_fc;
3140 memset (fc, 0, sizeof (Frame_Chunk));
3142 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3144 for (cie = chunks; cie ; cie = cie->next)
3145 if (cie->chunk_start == look_for)
3150 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3151 cie_id, (unsigned long)(saved_start - section_start));
3153 fc->col_type = xmalloc (sizeof (short int));
3154 fc->col_offset = xmalloc (sizeof (int));
3155 frame_need_space (fc, max_regs - 1);
3157 fc->augmentation = "";
3158 fc->fde_encoding = 0;
3162 fc->ncols = cie->ncols;
3163 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3164 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3165 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3166 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3167 fc->augmentation = cie->augmentation;
3168 fc->code_factor = cie->code_factor;
3169 fc->data_factor = cie->data_factor;
3170 fc->cfa_reg = cie->cfa_reg;
3171 fc->cfa_offset = cie->cfa_offset;
3173 frame_need_space (fc, max_regs-1);
3174 fc->fde_encoding = cie->fde_encoding;
3177 if (fc->fde_encoding)
3178 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3180 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3181 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3182 /* Don't adjust for relocatable file since there's
3183 invariably a pcrel reloc here, which we haven't
3186 fc->pc_begin += section->address + (start - section_start);
3187 start += encoded_ptr_size;
3188 fc->pc_range = byte_get (start, encoded_ptr_size);
3189 start += encoded_ptr_size;
3191 if (cie->augmentation[0] == 'z')
3193 augmentation_data_len = LEB ();
3194 augmentation_data = start;
3195 start += augmentation_data_len;
3198 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3199 (unsigned long)(saved_start - section_start), length, cie_id,
3200 (unsigned long)(cie->chunk_start - section_start),
3201 fc->pc_begin, fc->pc_begin + fc->pc_range);
3202 if (! do_debug_frames_interp && augmentation_data_len)
3206 printf (" Augmentation data: ");
3207 for (i = 0; i < augmentation_data_len; ++i)
3208 printf (" %02x", augmentation_data[i]);
3214 /* At this point, fc is the current chunk, cie (if any) is set, and
3215 we're about to interpret instructions for the chunk. */
3216 /* ??? At present we need to do this always, since this sizes the
3217 fc->col_type and fc->col_offset arrays, which we write into always.
3218 We should probably split the interpreted and non-interpreted bits
3219 into two different routines, since there's so much that doesn't
3220 really overlap between them. */
3221 if (1 || do_debug_frames_interp)
3223 /* Start by making a pass over the chunk, allocating storage
3224 and taking note of what registers are used. */
3225 unsigned char *tmp = start;
3227 while (start < block_end)
3230 unsigned long reg, tmp;
3237 /* Warning: if you add any more cases to this switch, be
3238 sure to add them to the corresponding switch below. */
3241 case DW_CFA_advance_loc:
3245 frame_need_space (fc, opa);
3246 fc->col_type[opa] = DW_CFA_undefined;
3248 case DW_CFA_restore:
3249 frame_need_space (fc, opa);
3250 fc->col_type[opa] = DW_CFA_undefined;
3252 case DW_CFA_set_loc:
3253 start += encoded_ptr_size;
3255 case DW_CFA_advance_loc1:
3258 case DW_CFA_advance_loc2:
3261 case DW_CFA_advance_loc4:
3264 case DW_CFA_offset_extended:
3265 case DW_CFA_val_offset:
3266 reg = LEB (); LEB ();
3267 frame_need_space (fc, reg);
3268 fc->col_type[reg] = DW_CFA_undefined;
3270 case DW_CFA_restore_extended:
3272 frame_need_space (fc, reg);
3273 fc->col_type[reg] = DW_CFA_undefined;
3275 case DW_CFA_undefined:
3277 frame_need_space (fc, reg);
3278 fc->col_type[reg] = DW_CFA_undefined;
3280 case DW_CFA_same_value:
3282 frame_need_space (fc, reg);
3283 fc->col_type[reg] = DW_CFA_undefined;
3285 case DW_CFA_register:
3286 reg = LEB (); LEB ();
3287 frame_need_space (fc, reg);
3288 fc->col_type[reg] = DW_CFA_undefined;
3290 case DW_CFA_def_cfa:
3293 case DW_CFA_def_cfa_register:
3296 case DW_CFA_def_cfa_offset:
3299 case DW_CFA_def_cfa_expression:
3303 case DW_CFA_expression:
3304 case DW_CFA_val_expression:
3308 frame_need_space (fc, reg);
3309 fc->col_type[reg] = DW_CFA_undefined;
3311 case DW_CFA_offset_extended_sf:
3312 case DW_CFA_val_offset_sf:
3313 reg = LEB (); SLEB ();
3314 frame_need_space (fc, reg);
3315 fc->col_type[reg] = DW_CFA_undefined;
3317 case DW_CFA_def_cfa_sf:
3320 case DW_CFA_def_cfa_offset_sf:
3323 case DW_CFA_MIPS_advance_loc8:
3326 case DW_CFA_GNU_args_size:
3329 case DW_CFA_GNU_negative_offset_extended:
3330 reg = LEB (); LEB ();
3331 frame_need_space (fc, reg);
3332 fc->col_type[reg] = DW_CFA_undefined;
3341 /* Now we know what registers are used, make a second pass over
3342 the chunk, this time actually printing out the info. */
3344 while (start < block_end)
3347 unsigned long ul, reg, roffs;
3356 /* Warning: if you add any more cases to this switch, be
3357 sure to add them to the corresponding switch above. */
3360 case DW_CFA_advance_loc:
3361 if (do_debug_frames_interp)
3362 frame_display_row (fc, &need_col_headers, &max_regs);
3364 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3365 opa * fc->code_factor,
3366 fc->pc_begin + opa * fc->code_factor);
3367 fc->pc_begin += opa * fc->code_factor;
3372 if (! do_debug_frames_interp)
3373 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3374 opa, roffs * fc->data_factor);
3375 fc->col_type[opa] = DW_CFA_offset;
3376 fc->col_offset[opa] = roffs * fc->data_factor;
3379 case DW_CFA_restore:
3380 if (! do_debug_frames_interp)
3381 printf (" DW_CFA_restore: r%d\n", opa);
3382 fc->col_type[opa] = cie->col_type[opa];
3383 fc->col_offset[opa] = cie->col_offset[opa];
3386 case DW_CFA_set_loc:
3387 vma = get_encoded_value (start, fc->fde_encoding);
3388 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3390 vma += section->address + (start - section_start);
3391 start += encoded_ptr_size;
3392 if (do_debug_frames_interp)
3393 frame_display_row (fc, &need_col_headers, &max_regs);
3395 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3399 case DW_CFA_advance_loc1:
3400 ofs = byte_get (start, 1); start += 1;
3401 if (do_debug_frames_interp)
3402 frame_display_row (fc, &need_col_headers, &max_regs);
3404 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3405 ofs * fc->code_factor,
3406 fc->pc_begin + ofs * fc->code_factor);
3407 fc->pc_begin += ofs * fc->code_factor;
3410 case DW_CFA_advance_loc2:
3411 ofs = byte_get (start, 2); start += 2;
3412 if (do_debug_frames_interp)
3413 frame_display_row (fc, &need_col_headers, &max_regs);
3415 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3416 ofs * fc->code_factor,
3417 fc->pc_begin + ofs * fc->code_factor);
3418 fc->pc_begin += ofs * fc->code_factor;
3421 case DW_CFA_advance_loc4:
3422 ofs = byte_get (start, 4); start += 4;
3423 if (do_debug_frames_interp)
3424 frame_display_row (fc, &need_col_headers, &max_regs);
3426 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3427 ofs * fc->code_factor,
3428 fc->pc_begin + ofs * fc->code_factor);
3429 fc->pc_begin += ofs * fc->code_factor;
3432 case DW_CFA_offset_extended:
3435 if (! do_debug_frames_interp)
3436 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3437 reg, roffs * fc->data_factor);
3438 fc->col_type[reg] = DW_CFA_offset;
3439 fc->col_offset[reg] = roffs * fc->data_factor;
3442 case DW_CFA_val_offset:
3445 if (! do_debug_frames_interp)
3446 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3447 reg, roffs * fc->data_factor);
3448 fc->col_type[reg] = DW_CFA_val_offset;
3449 fc->col_offset[reg] = roffs * fc->data_factor;
3452 case DW_CFA_restore_extended:
3454 if (! do_debug_frames_interp)
3455 printf (" DW_CFA_restore_extended: r%ld\n", reg);
3456 fc->col_type[reg] = cie->col_type[reg];
3457 fc->col_offset[reg] = cie->col_offset[reg];
3460 case DW_CFA_undefined:
3462 if (! do_debug_frames_interp)
3463 printf (" DW_CFA_undefined: r%ld\n", reg);
3464 fc->col_type[reg] = DW_CFA_undefined;
3465 fc->col_offset[reg] = 0;
3468 case DW_CFA_same_value:
3470 if (! do_debug_frames_interp)
3471 printf (" DW_CFA_same_value: r%ld\n", reg);
3472 fc->col_type[reg] = DW_CFA_same_value;
3473 fc->col_offset[reg] = 0;
3476 case DW_CFA_register:
3479 if (! do_debug_frames_interp)
3480 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3481 fc->col_type[reg] = DW_CFA_register;
3482 fc->col_offset[reg] = roffs;
3485 case DW_CFA_remember_state:
3486 if (! do_debug_frames_interp)
3487 printf (" DW_CFA_remember_state\n");
3488 rs = xmalloc (sizeof (Frame_Chunk));
3489 rs->ncols = fc->ncols;
3490 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3491 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3492 memcpy (rs->col_type, fc->col_type, rs->ncols);
3493 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3494 rs->next = remembered_state;
3495 remembered_state = rs;
3498 case DW_CFA_restore_state:
3499 if (! do_debug_frames_interp)
3500 printf (" DW_CFA_restore_state\n");
3501 rs = remembered_state;
3504 remembered_state = rs->next;
3505 frame_need_space (fc, rs->ncols-1);
3506 memcpy (fc->col_type, rs->col_type, rs->ncols);
3507 memcpy (fc->col_offset, rs->col_offset,
3508 rs->ncols * sizeof (int));
3509 free (rs->col_type);
3510 free (rs->col_offset);
3513 else if (do_debug_frames_interp)
3514 printf ("Mismatched DW_CFA_restore_state\n");
3517 case DW_CFA_def_cfa:
3518 fc->cfa_reg = LEB ();
3519 fc->cfa_offset = LEB ();
3521 if (! do_debug_frames_interp)
3522 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3523 fc->cfa_reg, fc->cfa_offset);
3526 case DW_CFA_def_cfa_register:
3527 fc->cfa_reg = LEB ();
3529 if (! do_debug_frames_interp)
3530 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3533 case DW_CFA_def_cfa_offset:
3534 fc->cfa_offset = LEB ();
3535 if (! do_debug_frames_interp)
3536 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3540 if (! do_debug_frames_interp)
3541 printf (" DW_CFA_nop\n");
3544 case DW_CFA_def_cfa_expression:
3546 if (! do_debug_frames_interp)
3548 printf (" DW_CFA_def_cfa_expression (");
3549 decode_location_expression (start, eh_addr_size, ul, 0);
3556 case DW_CFA_expression:
3559 if (! do_debug_frames_interp)
3561 printf (" DW_CFA_expression: r%ld (", reg);
3562 decode_location_expression (start, eh_addr_size, ul, 0);
3565 fc->col_type[reg] = DW_CFA_expression;
3569 case DW_CFA_val_expression:
3572 if (! do_debug_frames_interp)
3574 printf (" DW_CFA_val_expression: r%ld (", reg);
3575 decode_location_expression (start, eh_addr_size, ul, 0);
3578 fc->col_type[reg] = DW_CFA_val_expression;
3582 case DW_CFA_offset_extended_sf:
3585 frame_need_space (fc, reg);
3586 if (! do_debug_frames_interp)
3587 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3588 reg, l * fc->data_factor);
3589 fc->col_type[reg] = DW_CFA_offset;
3590 fc->col_offset[reg] = l * fc->data_factor;
3593 case DW_CFA_val_offset_sf:
3596 frame_need_space (fc, reg);
3597 if (! do_debug_frames_interp)
3598 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3599 reg, l * fc->data_factor);
3600 fc->col_type[reg] = DW_CFA_val_offset;
3601 fc->col_offset[reg] = l * fc->data_factor;
3604 case DW_CFA_def_cfa_sf:
3605 fc->cfa_reg = LEB ();
3606 fc->cfa_offset = SLEB ();
3607 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3609 if (! do_debug_frames_interp)
3610 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3611 fc->cfa_reg, fc->cfa_offset);
3614 case DW_CFA_def_cfa_offset_sf:
3615 fc->cfa_offset = SLEB ();
3616 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3617 if (! do_debug_frames_interp)
3618 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3621 case DW_CFA_MIPS_advance_loc8:
3622 ofs = byte_get (start, 8); start += 8;
3623 if (do_debug_frames_interp)
3624 frame_display_row (fc, &need_col_headers, &max_regs);
3626 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3627 ofs * fc->code_factor,
3628 fc->pc_begin + ofs * fc->code_factor);
3629 fc->pc_begin += ofs * fc->code_factor;
3632 case DW_CFA_GNU_window_save:
3633 if (! do_debug_frames_interp)
3634 printf (" DW_CFA_GNU_window_save\n");
3637 case DW_CFA_GNU_args_size:
3639 if (! do_debug_frames_interp)
3640 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
3643 case DW_CFA_GNU_negative_offset_extended:
3646 frame_need_space (fc, reg);
3647 if (! do_debug_frames_interp)
3648 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3649 reg, l * fc->data_factor);
3650 fc->col_type[reg] = DW_CFA_offset;
3651 fc->col_offset[reg] = l * fc->data_factor;
3655 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3656 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3658 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3663 if (do_debug_frames_interp)
3664 frame_display_row (fc, &need_col_headers, &max_regs);
3679 display_debug_not_supported (struct dwarf_section *section,
3680 void *file ATTRIBUTE_UNUSED)
3682 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3689 cmalloc (size_t nmemb, size_t size)
3691 /* Check for overflow. */
3692 if (nmemb >= ~(size_t) 0 / size)
3695 return malloc (nmemb * size);
3699 xcmalloc (size_t nmemb, size_t size)
3701 /* Check for overflow. */
3702 if (nmemb >= ~(size_t) 0 / size)
3705 return xmalloc (nmemb * size);
3709 xcrealloc (void *ptr, size_t nmemb, size_t size)
3711 /* Check for overflow. */
3712 if (nmemb >= ~(size_t) 0 / size)
3715 return xrealloc (ptr, nmemb * size);
3719 error (const char *message, ...)
3723 va_start (args, message);
3724 fprintf (stderr, _("%s: Error: "), program_name);
3725 vfprintf (stderr, message, args);
3730 warn (const char *message, ...)
3734 va_start (args, message);
3735 fprintf (stderr, _("%s: Warning: "), program_name);
3736 vfprintf (stderr, message, args);
3741 free_debug_memory (void)
3743 enum dwarf_section_display_enum i;
3747 for (i = 0; i < max; i++)
3748 free_debug_section (i);
3750 if (debug_information)
3752 for (i = 0; i < num_debug_info_entries; i++)
3754 if (!debug_information [i].max_loc_offsets)
3756 free (debug_information [i].loc_offsets);
3757 free (debug_information [i].have_frame_base);
3759 if (!debug_information [i].max_range_lists)
3760 free (debug_information [i].range_lists);
3762 free (debug_information);
3763 debug_information = NULL;
3764 num_debug_info_entries = 0;
3769 struct dwarf_section_display debug_displays[] =
3771 { { ".debug_abbrev", NULL, 0, 0 },
3772 display_debug_abbrev, 0, 0 },
3773 { { ".debug_aranges", NULL, 0, 0 },
3774 display_debug_aranges, 0, 0 },
3775 { { ".debug_frame", NULL, 0, 0 },
3776 display_debug_frames, 1, 0 },
3777 { { ".debug_info", NULL, 0, 0 },
3778 display_debug_info, 1, 0 },
3779 { { ".debug_line", NULL, 0, 0 },
3780 display_debug_lines, 0, 0 },
3781 { { ".debug_pubnames", NULL, 0, 0 },
3782 display_debug_pubnames, 0, 0 },
3783 { { ".eh_frame", NULL, 0, 0 },
3784 display_debug_frames, 1, 1 },
3785 { { ".debug_macinfo", NULL, 0, 0 },
3786 display_debug_macinfo, 0, 0 },
3787 { { ".debug_str", NULL, 0, 0 },
3788 display_debug_str, 0, 0 },
3789 { { ".debug_loc", NULL, 0, 0 },
3790 display_debug_loc, 0, 0 },
3791 { { ".debug_pubtypes", NULL, 0, 0 },
3792 display_debug_pubnames, 0, 0 },
3793 { { ".debug_ranges", NULL, 0, 0 },
3794 display_debug_ranges, 0, 0 },
3795 { { ".debug_static_func", NULL, 0, 0 },
3796 display_debug_not_supported, 0, 0 },
3797 { { ".debug_static_vars", NULL, 0, 0 },
3798 display_debug_not_supported, 0, 0 },
3799 { { ".debug_types", NULL, 0, 0 },
3800 display_debug_not_supported, 0, 0 },
3801 { { ".debug_weaknames", NULL, 0, 0 },
3802 display_debug_not_supported, 0, 0 }