1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/dwarf2.h"
29 static int have_frame_base;
30 static int need_base_address;
32 static unsigned int last_pointer_size = 0;
33 static int warned_about_missing_comp_units = FALSE;
35 static unsigned int num_debug_info_entries = 0;
36 static debug_info *debug_information = NULL;
38 dwarf_vma eh_addr_size;
43 int do_debug_pubnames;
47 int do_debug_frames_interp;
52 dwarf_vma (*byte_get) (unsigned char *, int);
55 byte_get_little_endian (unsigned char *field, int size)
63 return ((unsigned int) (field[0]))
64 | (((unsigned int) (field[1])) << 8);
67 return ((unsigned long) (field[0]))
68 | (((unsigned long) (field[1])) << 8)
69 | (((unsigned long) (field[2])) << 16)
70 | (((unsigned long) (field[3])) << 24);
73 if (sizeof (dwarf_vma) == 8)
74 return ((dwarf_vma) (field[0]))
75 | (((dwarf_vma) (field[1])) << 8)
76 | (((dwarf_vma) (field[2])) << 16)
77 | (((dwarf_vma) (field[3])) << 24)
78 | (((dwarf_vma) (field[4])) << 32)
79 | (((dwarf_vma) (field[5])) << 40)
80 | (((dwarf_vma) (field[6])) << 48)
81 | (((dwarf_vma) (field[7])) << 56);
82 else if (sizeof (dwarf_vma) == 4)
83 /* We want to extract data from an 8 byte wide field and
84 place it into a 4 byte wide field. Since this is a little
85 endian source we can just use the 4 byte extraction code. */
86 return ((unsigned long) (field[0]))
87 | (((unsigned long) (field[1])) << 8)
88 | (((unsigned long) (field[2])) << 16)
89 | (((unsigned long) (field[3])) << 24);
92 error (_("Unhandled data length: %d\n"), size);
98 byte_get_big_endian (unsigned char *field, int size)
106 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
109 return ((unsigned long) (field[3]))
110 | (((unsigned long) (field[2])) << 8)
111 | (((unsigned long) (field[1])) << 16)
112 | (((unsigned long) (field[0])) << 24);
115 if (sizeof (dwarf_vma) == 8)
116 return ((dwarf_vma) (field[7]))
117 | (((dwarf_vma) (field[6])) << 8)
118 | (((dwarf_vma) (field[5])) << 16)
119 | (((dwarf_vma) (field[4])) << 24)
120 | (((dwarf_vma) (field[3])) << 32)
121 | (((dwarf_vma) (field[2])) << 40)
122 | (((dwarf_vma) (field[1])) << 48)
123 | (((dwarf_vma) (field[0])) << 56);
124 else if (sizeof (dwarf_vma) == 4)
126 /* Although we are extracing data from an 8 byte wide field,
127 we are returning only 4 bytes of data. */
129 return ((unsigned long) (field[3]))
130 | (((unsigned long) (field[2])) << 8)
131 | (((unsigned long) (field[1])) << 16)
132 | (((unsigned long) (field[0])) << 24);
136 error (_("Unhandled data length: %d\n"), size);
142 byte_get_signed (unsigned char *field, int size)
144 dwarf_vma x = byte_get (field, size);
149 return (x ^ 0x80) - 0x80;
151 return (x ^ 0x8000) - 0x8000;
153 return (x ^ 0x80000000) - 0x80000000;
161 static unsigned long int
162 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
164 unsigned long int result = 0;
165 unsigned int num_read = 0;
166 unsigned int shift = 0;
174 result |= ((unsigned long int) (byte & 0x7f)) << shift;
181 if (length_return != NULL)
182 *length_return = num_read;
184 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
185 result |= -1L << shift;
190 typedef struct State_Machine_Registers
192 unsigned long address;
199 /* This variable hold the number of the last entry seen
200 in the File Table. */
201 unsigned int last_file_entry;
204 static SMR state_machine_regs;
207 reset_state_machine (int is_stmt)
209 state_machine_regs.address = 0;
210 state_machine_regs.file = 1;
211 state_machine_regs.line = 1;
212 state_machine_regs.column = 0;
213 state_machine_regs.is_stmt = is_stmt;
214 state_machine_regs.basic_block = 0;
215 state_machine_regs.end_sequence = 0;
216 state_machine_regs.last_file_entry = 0;
219 /* Handled an extend line op.
220 Returns the number of bytes read. */
223 process_extended_line_op (unsigned char *data, int is_stmt)
225 unsigned char op_code;
226 unsigned int bytes_read;
231 len = read_leb128 (data, & bytes_read, 0);
236 warn (_("badly formed extended line op encountered!\n"));
243 printf (_(" Extended opcode %d: "), op_code);
247 case DW_LNE_end_sequence:
248 printf (_("End of Sequence\n\n"));
249 reset_state_machine (is_stmt);
252 case DW_LNE_set_address:
253 adr = byte_get (data, len - bytes_read - 1);
254 printf (_("set Address to 0x%lx\n"), adr);
255 state_machine_regs.address = adr;
258 case DW_LNE_define_file:
259 printf (_(" define new File Table entry\n"));
260 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
262 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
264 data += strlen ((char *) data) + 1;
265 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
267 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
269 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
270 printf (_("%s\n\n"), name);
274 case DW_LNE_HP_negate_is_UV_update:
275 printf ("DW_LNE_HP_negate_is_UV_update");
277 case DW_LNE_HP_push_context:
278 printf ("DW_LNE_HP_push_context");
280 case DW_LNE_HP_pop_context:
281 printf ("DW_LNE_HP_pop_context");
283 case DW_LNE_HP_set_file_line_column:
284 printf ("DW_LNE_HP_set_file_line_column");
286 case DW_LNE_HP_set_routine_name:
287 printf ("DW_LNE_HP_set_routine_name");
289 case DW_LNE_HP_set_sequence:
290 printf ("DW_LNE_HP_set_sequence");
292 case DW_LNE_HP_negate_post_semantics:
293 printf ("DW_LNE_HP_negate_post_semantics");
295 case DW_LNE_HP_negate_function_exit:
296 printf ("DW_LNE_HP_negate_function_exit");
298 case DW_LNE_HP_negate_front_end_logical:
299 printf ("DW_LNE_HP_negate_front_end_logical");
301 case DW_LNE_HP_define_proc:
302 printf ("DW_LNE_HP_define_proc");
306 if (op_code >= DW_LNE_lo_user
307 /* The test against DW_LNW_hi_user is redundant due to
308 the limited range of the unsigned char data type used
310 /*&& op_code <= DW_LNE_hi_user*/)
311 printf (_("user defined: length %d\n"), len - bytes_read);
313 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
321 fetch_indirect_string (unsigned long offset)
323 struct dwarf_section *section = &debug_displays [str].section;
325 if (section->start == NULL)
326 return _("<no .debug_str section>");
328 /* DWARF sections under Mach-O have non-zero addresses. */
329 offset -= section->address;
330 if (offset > section->size)
332 warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
333 return _("<offset is too big>");
336 return (const char *) section->start + offset;
339 /* FIXME: There are better and more efficient ways to handle
340 these structures. For now though, I just want something that
341 is simple to implement. */
342 typedef struct abbrev_attr
344 unsigned long attribute;
346 struct abbrev_attr *next;
350 typedef struct abbrev_entry
355 struct abbrev_attr *first_attr;
356 struct abbrev_attr *last_attr;
357 struct abbrev_entry *next;
361 static abbrev_entry *first_abbrev = NULL;
362 static abbrev_entry *last_abbrev = NULL;
367 abbrev_entry *abbrev;
369 for (abbrev = first_abbrev; abbrev;)
371 abbrev_entry *next = abbrev->next;
374 for (attr = abbrev->first_attr; attr;)
376 abbrev_attr *next = attr->next;
386 last_abbrev = first_abbrev = NULL;
390 add_abbrev (unsigned long number, unsigned long tag, int children)
394 entry = malloc (sizeof (*entry));
400 entry->entry = number;
402 entry->children = children;
403 entry->first_attr = NULL;
404 entry->last_attr = NULL;
407 if (first_abbrev == NULL)
408 first_abbrev = entry;
410 last_abbrev->next = entry;
416 add_abbrev_attr (unsigned long attribute, unsigned long form)
420 attr = malloc (sizeof (*attr));
426 attr->attribute = attribute;
430 if (last_abbrev->first_attr == NULL)
431 last_abbrev->first_attr = attr;
433 last_abbrev->last_attr->next = attr;
435 last_abbrev->last_attr = attr;
438 /* Processes the (partial) contents of a .debug_abbrev section.
439 Returns NULL if the end of the section was encountered.
440 Returns the address after the last byte read if the end of
441 an abbreviation set was found. */
443 static unsigned char *
444 process_abbrev_section (unsigned char *start, unsigned char *end)
446 if (first_abbrev != NULL)
451 unsigned int bytes_read;
454 unsigned long attribute;
457 entry = read_leb128 (start, & bytes_read, 0);
460 /* A single zero is supposed to end the section according
461 to the standard. If there's more, then signal that to
464 return start == end ? NULL : start;
466 tag = read_leb128 (start, & bytes_read, 0);
471 add_abbrev (entry, tag, children);
477 attribute = read_leb128 (start, & bytes_read, 0);
480 form = read_leb128 (start, & bytes_read, 0);
484 add_abbrev_attr (attribute, form);
486 while (attribute != 0);
493 get_TAG_name (unsigned long tag)
497 case DW_TAG_padding: return "DW_TAG_padding";
498 case DW_TAG_array_type: return "DW_TAG_array_type";
499 case DW_TAG_class_type: return "DW_TAG_class_type";
500 case DW_TAG_entry_point: return "DW_TAG_entry_point";
501 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
502 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
503 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
504 case DW_TAG_label: return "DW_TAG_label";
505 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
506 case DW_TAG_member: return "DW_TAG_member";
507 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
508 case DW_TAG_reference_type: return "DW_TAG_reference_type";
509 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
510 case DW_TAG_string_type: return "DW_TAG_string_type";
511 case DW_TAG_structure_type: return "DW_TAG_structure_type";
512 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
513 case DW_TAG_typedef: return "DW_TAG_typedef";
514 case DW_TAG_union_type: return "DW_TAG_union_type";
515 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
516 case DW_TAG_variant: return "DW_TAG_variant";
517 case DW_TAG_common_block: return "DW_TAG_common_block";
518 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
519 case DW_TAG_inheritance: return "DW_TAG_inheritance";
520 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
521 case DW_TAG_module: return "DW_TAG_module";
522 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
523 case DW_TAG_set_type: return "DW_TAG_set_type";
524 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
525 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
526 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
527 case DW_TAG_base_type: return "DW_TAG_base_type";
528 case DW_TAG_catch_block: return "DW_TAG_catch_block";
529 case DW_TAG_const_type: return "DW_TAG_const_type";
530 case DW_TAG_constant: return "DW_TAG_constant";
531 case DW_TAG_enumerator: return "DW_TAG_enumerator";
532 case DW_TAG_file_type: return "DW_TAG_file_type";
533 case DW_TAG_friend: return "DW_TAG_friend";
534 case DW_TAG_namelist: return "DW_TAG_namelist";
535 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
536 case DW_TAG_packed_type: return "DW_TAG_packed_type";
537 case DW_TAG_subprogram: return "DW_TAG_subprogram";
538 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
539 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
540 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
541 case DW_TAG_try_block: return "DW_TAG_try_block";
542 case DW_TAG_variant_part: return "DW_TAG_variant_part";
543 case DW_TAG_variable: return "DW_TAG_variable";
544 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
545 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
546 case DW_TAG_format_label: return "DW_TAG_format_label";
547 case DW_TAG_function_template: return "DW_TAG_function_template";
548 case DW_TAG_class_template: return "DW_TAG_class_template";
549 /* DWARF 2.1 values. */
550 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
551 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
552 case DW_TAG_interface_type: return "DW_TAG_interface_type";
553 case DW_TAG_namespace: return "DW_TAG_namespace";
554 case DW_TAG_imported_module: return "DW_TAG_imported_module";
555 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
556 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
557 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
559 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
560 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
561 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
564 static char buffer[100];
566 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
573 get_FORM_name (unsigned long form)
577 case DW_FORM_addr: return "DW_FORM_addr";
578 case DW_FORM_block2: return "DW_FORM_block2";
579 case DW_FORM_block4: return "DW_FORM_block4";
580 case DW_FORM_data2: return "DW_FORM_data2";
581 case DW_FORM_data4: return "DW_FORM_data4";
582 case DW_FORM_data8: return "DW_FORM_data8";
583 case DW_FORM_string: return "DW_FORM_string";
584 case DW_FORM_block: return "DW_FORM_block";
585 case DW_FORM_block1: return "DW_FORM_block1";
586 case DW_FORM_data1: return "DW_FORM_data1";
587 case DW_FORM_flag: return "DW_FORM_flag";
588 case DW_FORM_sdata: return "DW_FORM_sdata";
589 case DW_FORM_strp: return "DW_FORM_strp";
590 case DW_FORM_udata: return "DW_FORM_udata";
591 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
592 case DW_FORM_ref1: return "DW_FORM_ref1";
593 case DW_FORM_ref2: return "DW_FORM_ref2";
594 case DW_FORM_ref4: return "DW_FORM_ref4";
595 case DW_FORM_ref8: return "DW_FORM_ref8";
596 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
597 case DW_FORM_indirect: return "DW_FORM_indirect";
600 static char buffer[100];
602 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
608 static unsigned char *
609 display_block (unsigned char *data, unsigned long length)
611 printf (_(" %lu byte block: "), length);
614 printf ("%lx ", (unsigned long) byte_get (data++, 1));
620 decode_location_expression (unsigned char * data,
621 unsigned int pointer_size,
622 unsigned long length,
623 unsigned long cu_offset)
626 unsigned int bytes_read;
627 unsigned long uvalue;
628 unsigned char *end = data + length;
629 int need_frame_base = 0;
638 printf ("DW_OP_addr: %lx",
639 (unsigned long) byte_get (data, pointer_size));
640 data += pointer_size;
643 printf ("DW_OP_deref");
646 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
649 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
652 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
656 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
660 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
664 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
668 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
669 (unsigned long) byte_get (data + 4, 4));
673 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
674 (long) byte_get (data + 4, 4));
678 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
682 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
686 printf ("DW_OP_dup");
689 printf ("DW_OP_drop");
692 printf ("DW_OP_over");
695 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
698 printf ("DW_OP_swap");
701 printf ("DW_OP_rot");
704 printf ("DW_OP_xderef");
707 printf ("DW_OP_abs");
710 printf ("DW_OP_and");
713 printf ("DW_OP_div");
716 printf ("DW_OP_minus");
719 printf ("DW_OP_mod");
722 printf ("DW_OP_mul");
725 printf ("DW_OP_neg");
728 printf ("DW_OP_not");
734 printf ("DW_OP_plus");
736 case DW_OP_plus_uconst:
737 printf ("DW_OP_plus_uconst: %lu",
738 read_leb128 (data, &bytes_read, 0));
742 printf ("DW_OP_shl");
745 printf ("DW_OP_shr");
748 printf ("DW_OP_shra");
751 printf ("DW_OP_xor");
754 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
776 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
812 printf ("DW_OP_lit%d", op - DW_OP_lit0);
847 printf ("DW_OP_reg%d", op - DW_OP_reg0);
882 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
883 read_leb128 (data, &bytes_read, 1));
888 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
893 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
897 uvalue = read_leb128 (data, &bytes_read, 0);
899 printf ("DW_OP_bregx: %lu %ld", uvalue,
900 read_leb128 (data, &bytes_read, 1));
904 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
907 case DW_OP_deref_size:
908 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
910 case DW_OP_xderef_size:
911 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
914 printf ("DW_OP_nop");
917 /* DWARF 3 extensions. */
918 case DW_OP_push_object_address:
919 printf ("DW_OP_push_object_address");
922 /* XXX: Strictly speaking for 64-bit DWARF3 files
923 this ought to be an 8-byte wide computation. */
924 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
928 /* XXX: Strictly speaking for 64-bit DWARF3 files
929 this ought to be an 8-byte wide computation. */
930 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
934 /* XXX: Strictly speaking for 64-bit DWARF3 files
935 this ought to be an 8-byte wide computation. */
936 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
939 case DW_OP_form_tls_address:
940 printf ("DW_OP_form_tls_address");
942 case DW_OP_call_frame_cfa:
943 printf ("DW_OP_call_frame_cfa");
945 case DW_OP_bit_piece:
946 printf ("DW_OP_bit_piece: ");
947 printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
949 printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
953 /* GNU extensions. */
954 case DW_OP_GNU_push_tls_address:
955 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
957 case DW_OP_GNU_uninit:
958 printf ("DW_OP_GNU_uninit");
959 /* FIXME: Is there data associated with this OP ? */
963 case DW_OP_HP_is_value:
964 printf ("DW_OP_HP_is_value");
965 /* FIXME: Is there data associated with this OP ? */
967 case DW_OP_HP_fltconst4:
968 printf ("DW_OP_HP_fltconst4");
969 /* FIXME: Is there data associated with this OP ? */
971 case DW_OP_HP_fltconst8:
972 printf ("DW_OP_HP_fltconst8");
973 /* FIXME: Is there data associated with this OP ? */
975 case DW_OP_HP_mod_range:
976 printf ("DW_OP_HP_mod_range");
977 /* FIXME: Is there data associated with this OP ? */
979 case DW_OP_HP_unmod_range:
980 printf ("DW_OP_HP_unmod_range");
981 /* FIXME: Is there data associated with this OP ? */
984 printf ("DW_OP_HP_tls");
985 /* FIXME: Is there data associated with this OP ? */
989 if (op >= DW_OP_lo_user
990 && op <= DW_OP_hi_user)
991 printf (_("(User defined location op)"));
993 printf (_("(Unknown location op)"));
994 /* No way to tell where the next op is, so just bail. */
995 return need_frame_base;
998 /* Separate the ops. */
1003 return need_frame_base;
1006 static unsigned char *
1007 read_and_display_attr_value (unsigned long attribute,
1009 unsigned char *data,
1010 unsigned long cu_offset,
1011 unsigned long pointer_size,
1012 unsigned long offset_size,
1014 debug_info *debug_info_p,
1017 unsigned long uvalue = 0;
1018 unsigned char *block_start = NULL;
1019 unsigned int bytes_read;
1026 case DW_FORM_ref_addr:
1027 if (dwarf_version == 2)
1029 uvalue = byte_get (data, pointer_size);
1030 data += pointer_size;
1032 else if (dwarf_version == 3)
1034 uvalue = byte_get (data, offset_size);
1035 data += offset_size;
1039 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1044 uvalue = byte_get (data, pointer_size);
1045 data += pointer_size;
1049 uvalue = byte_get (data, offset_size);
1050 data += offset_size;
1056 uvalue = byte_get (data++, 1);
1061 uvalue = byte_get (data, 2);
1067 uvalue = byte_get (data, 4);
1072 uvalue = read_leb128 (data, & bytes_read, 1);
1076 case DW_FORM_ref_udata:
1078 uvalue = read_leb128 (data, & bytes_read, 0);
1082 case DW_FORM_indirect:
1083 form = read_leb128 (data, & bytes_read, 0);
1086 printf (" %s", get_FORM_name (form));
1087 return read_and_display_attr_value (attribute, form, data,
1088 cu_offset, pointer_size,
1089 offset_size, dwarf_version,
1090 debug_info_p, do_loc);
1095 case DW_FORM_ref_addr:
1097 printf (" <#%lx>", uvalue);
1103 case DW_FORM_ref_udata:
1105 printf (" <%lx>", uvalue + cu_offset);
1111 printf (" %#lx", uvalue);
1120 printf (" %ld", uvalue);
1127 uvalue = byte_get (data, 4);
1128 printf (" %lx", uvalue);
1129 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
1131 if ((do_loc || do_debug_loc || do_debug_ranges)
1132 && num_debug_info_entries == 0)
1134 if (sizeof (uvalue) == 8)
1135 uvalue = byte_get (data, 8);
1137 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1142 case DW_FORM_string:
1144 printf (" %s", data);
1145 data += strlen ((char *) data) + 1;
1149 uvalue = read_leb128 (data, & bytes_read, 0);
1150 block_start = data + bytes_read;
1152 data = block_start + uvalue;
1154 data = display_block (block_start, uvalue);
1157 case DW_FORM_block1:
1158 uvalue = byte_get (data, 1);
1159 block_start = data + 1;
1161 data = block_start + uvalue;
1163 data = display_block (block_start, uvalue);
1166 case DW_FORM_block2:
1167 uvalue = byte_get (data, 2);
1168 block_start = data + 2;
1170 data = block_start + uvalue;
1172 data = display_block (block_start, uvalue);
1175 case DW_FORM_block4:
1176 uvalue = byte_get (data, 4);
1177 block_start = data + 4;
1179 data = block_start + uvalue;
1181 data = display_block (block_start, uvalue);
1186 printf (_(" (indirect string, offset: 0x%lx): %s"),
1187 uvalue, fetch_indirect_string (uvalue));
1190 case DW_FORM_indirect:
1191 /* Handled above. */
1195 warn (_("Unrecognized form: %lu\n"), form);
1199 /* For some attributes we can display further information. */
1200 if ((do_loc || do_debug_loc || do_debug_ranges)
1201 && num_debug_info_entries == 0)
1205 case DW_AT_frame_base:
1206 have_frame_base = 1;
1207 case DW_AT_location:
1208 case DW_AT_string_length:
1209 case DW_AT_return_addr:
1210 case DW_AT_data_member_location:
1211 case DW_AT_vtable_elem_location:
1213 case DW_AT_static_link:
1214 case DW_AT_use_location:
1215 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1217 /* Process location list. */
1218 unsigned int max = debug_info_p->max_loc_offsets;
1219 unsigned int num = debug_info_p->num_loc_offsets;
1221 if (max == 0 || num >= max)
1224 debug_info_p->loc_offsets
1225 = xcrealloc (debug_info_p->loc_offsets,
1226 max, sizeof (*debug_info_p->loc_offsets));
1227 debug_info_p->have_frame_base
1228 = xcrealloc (debug_info_p->have_frame_base,
1229 max, sizeof (*debug_info_p->have_frame_base));
1230 debug_info_p->max_loc_offsets = max;
1232 debug_info_p->loc_offsets [num] = uvalue;
1233 debug_info_p->have_frame_base [num] = have_frame_base;
1234 debug_info_p->num_loc_offsets++;
1239 if (need_base_address)
1240 debug_info_p->base_address = uvalue;
1244 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1246 /* Process range list. */
1247 unsigned int max = debug_info_p->max_range_lists;
1248 unsigned int num = debug_info_p->num_range_lists;
1250 if (max == 0 || num >= max)
1253 debug_info_p->range_lists
1254 = xcrealloc (debug_info_p->range_lists,
1255 max, sizeof (*debug_info_p->range_lists));
1256 debug_info_p->max_range_lists = max;
1258 debug_info_p->range_lists [num] = uvalue;
1259 debug_info_p->num_range_lists++;
1278 case DW_INL_not_inlined:
1279 printf (_("(not inlined)"));
1281 case DW_INL_inlined:
1282 printf (_("(inlined)"));
1284 case DW_INL_declared_not_inlined:
1285 printf (_("(declared as inline but ignored)"));
1287 case DW_INL_declared_inlined:
1288 printf (_("(declared as inline and inlined)"));
1291 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1296 case DW_AT_language:
1299 /* Ordered by the numeric value of these constants. */
1300 case DW_LANG_C89: printf ("(ANSI C)"); break;
1301 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1302 case DW_LANG_Ada83: printf ("(Ada)"); break;
1303 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1304 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1305 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1306 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1307 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1308 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1309 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1310 /* DWARF 2.1 values. */
1311 case DW_LANG_Java: printf ("(Java)"); break;
1312 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1313 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1314 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1315 /* DWARF 3 values. */
1316 case DW_LANG_PLI: printf ("(PLI)"); break;
1317 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1318 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1319 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1320 case DW_LANG_D: printf ("(D)"); break;
1321 /* MIPS extension. */
1322 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1323 /* UPC extension. */
1324 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1326 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1327 printf ("(implementation defined: %lx)", uvalue);
1329 printf ("(Unknown: %lx)", uvalue);
1334 case DW_AT_encoding:
1337 case DW_ATE_void: printf ("(void)"); break;
1338 case DW_ATE_address: printf ("(machine address)"); break;
1339 case DW_ATE_boolean: printf ("(boolean)"); break;
1340 case DW_ATE_complex_float: printf ("(complex float)"); break;
1341 case DW_ATE_float: printf ("(float)"); break;
1342 case DW_ATE_signed: printf ("(signed)"); break;
1343 case DW_ATE_signed_char: printf ("(signed char)"); break;
1344 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1345 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1346 /* DWARF 2.1 values: */
1347 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1348 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1349 /* DWARF 3 values: */
1350 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1351 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1352 case DW_ATE_edited: printf ("(edited)"); break;
1353 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1354 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1355 /* HP extensions: */
1356 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1357 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1358 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1359 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1360 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1361 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1362 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1365 if (uvalue >= DW_ATE_lo_user
1366 && uvalue <= DW_ATE_hi_user)
1367 printf ("(user defined type)");
1369 printf ("(unknown type)");
1374 case DW_AT_accessibility:
1377 case DW_ACCESS_public: printf ("(public)"); break;
1378 case DW_ACCESS_protected: printf ("(protected)"); break;
1379 case DW_ACCESS_private: printf ("(private)"); break;
1381 printf ("(unknown accessibility)");
1386 case DW_AT_visibility:
1389 case DW_VIS_local: printf ("(local)"); break;
1390 case DW_VIS_exported: printf ("(exported)"); break;
1391 case DW_VIS_qualified: printf ("(qualified)"); break;
1392 default: printf ("(unknown visibility)"); break;
1396 case DW_AT_virtuality:
1399 case DW_VIRTUALITY_none: printf ("(none)"); break;
1400 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1401 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1402 default: printf ("(unknown virtuality)"); break;
1406 case DW_AT_identifier_case:
1409 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1410 case DW_ID_up_case: printf ("(up_case)"); break;
1411 case DW_ID_down_case: printf ("(down_case)"); break;
1412 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1413 default: printf ("(unknown case)"); break;
1417 case DW_AT_calling_convention:
1420 case DW_CC_normal: printf ("(normal)"); break;
1421 case DW_CC_program: printf ("(program)"); break;
1422 case DW_CC_nocall: printf ("(nocall)"); break;
1424 if (uvalue >= DW_CC_lo_user
1425 && uvalue <= DW_CC_hi_user)
1426 printf ("(user defined)");
1428 printf ("(unknown convention)");
1432 case DW_AT_ordering:
1435 case -1: printf ("(undefined)"); break;
1436 case 0: printf ("(row major)"); break;
1437 case 1: printf ("(column major)"); break;
1441 case DW_AT_frame_base:
1442 have_frame_base = 1;
1443 case DW_AT_location:
1444 case DW_AT_string_length:
1445 case DW_AT_return_addr:
1446 case DW_AT_data_member_location:
1447 case DW_AT_vtable_elem_location:
1449 case DW_AT_static_link:
1450 case DW_AT_use_location:
1451 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1452 printf (_("(location list)"));
1454 case DW_AT_allocated:
1455 case DW_AT_associated:
1456 case DW_AT_data_location:
1458 case DW_AT_upper_bound:
1459 case DW_AT_lower_bound:
1462 int need_frame_base;
1465 need_frame_base = decode_location_expression (block_start,
1470 if (need_frame_base && !have_frame_base)
1471 printf (_(" [without DW_AT_frame_base]"));
1483 get_AT_name (unsigned long attribute)
1487 case DW_AT_sibling: return "DW_AT_sibling";
1488 case DW_AT_location: return "DW_AT_location";
1489 case DW_AT_name: return "DW_AT_name";
1490 case DW_AT_ordering: return "DW_AT_ordering";
1491 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1492 case DW_AT_byte_size: return "DW_AT_byte_size";
1493 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1494 case DW_AT_bit_size: return "DW_AT_bit_size";
1495 case DW_AT_element_list: return "DW_AT_element_list";
1496 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1497 case DW_AT_low_pc: return "DW_AT_low_pc";
1498 case DW_AT_high_pc: return "DW_AT_high_pc";
1499 case DW_AT_language: return "DW_AT_language";
1500 case DW_AT_member: return "DW_AT_member";
1501 case DW_AT_discr: return "DW_AT_discr";
1502 case DW_AT_discr_value: return "DW_AT_discr_value";
1503 case DW_AT_visibility: return "DW_AT_visibility";
1504 case DW_AT_import: return "DW_AT_import";
1505 case DW_AT_string_length: return "DW_AT_string_length";
1506 case DW_AT_common_reference: return "DW_AT_common_reference";
1507 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1508 case DW_AT_const_value: return "DW_AT_const_value";
1509 case DW_AT_containing_type: return "DW_AT_containing_type";
1510 case DW_AT_default_value: return "DW_AT_default_value";
1511 case DW_AT_inline: return "DW_AT_inline";
1512 case DW_AT_is_optional: return "DW_AT_is_optional";
1513 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1514 case DW_AT_producer: return "DW_AT_producer";
1515 case DW_AT_prototyped: return "DW_AT_prototyped";
1516 case DW_AT_return_addr: return "DW_AT_return_addr";
1517 case DW_AT_start_scope: return "DW_AT_start_scope";
1518 case DW_AT_stride_size: return "DW_AT_stride_size";
1519 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1520 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1521 case DW_AT_accessibility: return "DW_AT_accessibility";
1522 case DW_AT_address_class: return "DW_AT_address_class";
1523 case DW_AT_artificial: return "DW_AT_artificial";
1524 case DW_AT_base_types: return "DW_AT_base_types";
1525 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1526 case DW_AT_count: return "DW_AT_count";
1527 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1528 case DW_AT_decl_column: return "DW_AT_decl_column";
1529 case DW_AT_decl_file: return "DW_AT_decl_file";
1530 case DW_AT_decl_line: return "DW_AT_decl_line";
1531 case DW_AT_declaration: return "DW_AT_declaration";
1532 case DW_AT_discr_list: return "DW_AT_discr_list";
1533 case DW_AT_encoding: return "DW_AT_encoding";
1534 case DW_AT_external: return "DW_AT_external";
1535 case DW_AT_frame_base: return "DW_AT_frame_base";
1536 case DW_AT_friend: return "DW_AT_friend";
1537 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1538 case DW_AT_macro_info: return "DW_AT_macro_info";
1539 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1540 case DW_AT_priority: return "DW_AT_priority";
1541 case DW_AT_segment: return "DW_AT_segment";
1542 case DW_AT_specification: return "DW_AT_specification";
1543 case DW_AT_static_link: return "DW_AT_static_link";
1544 case DW_AT_type: return "DW_AT_type";
1545 case DW_AT_use_location: return "DW_AT_use_location";
1546 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1547 case DW_AT_virtuality: return "DW_AT_virtuality";
1548 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1549 /* DWARF 2.1 values. */
1550 case DW_AT_allocated: return "DW_AT_allocated";
1551 case DW_AT_associated: return "DW_AT_associated";
1552 case DW_AT_data_location: return "DW_AT_data_location";
1553 case DW_AT_stride: return "DW_AT_stride";
1554 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1555 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1556 case DW_AT_extension: return "DW_AT_extension";
1557 case DW_AT_ranges: return "DW_AT_ranges";
1558 case DW_AT_trampoline: return "DW_AT_trampoline";
1559 case DW_AT_call_column: return "DW_AT_call_column";
1560 case DW_AT_call_file: return "DW_AT_call_file";
1561 case DW_AT_call_line: return "DW_AT_call_line";
1562 case DW_AT_description: return "DW_AT_description";
1563 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1564 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1565 case DW_AT_small: return "DW_AT_small";
1566 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1567 case DW_AT_digit_count: return "DW_AT_digit_count";
1568 case DW_AT_picture_string: return "DW_AT_picture_string";
1569 case DW_AT_mutable: return "DW_AT_mutable";
1570 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1571 case DW_AT_explicit: return "DW_AT_explicit";
1572 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1573 case DW_AT_endianity: return "DW_AT_endianity";
1574 case DW_AT_elemental: return "DW_AT_elemental";
1575 case DW_AT_pure: return "DW_AT_pure";
1576 case DW_AT_recursive: return "DW_AT_recursive";
1578 /* HP and SGI/MIPS extensions. */
1579 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1580 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1581 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1582 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1583 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1584 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1585 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1586 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1587 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1588 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1590 /* HP Extensions. */
1591 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1592 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1593 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1594 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1595 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1596 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1597 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1598 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1599 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1600 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1601 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1602 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1603 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1605 /* One value is shared by the MIPS and HP extensions: */
1606 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1608 /* GNU extensions. */
1609 case DW_AT_sf_names: return "DW_AT_sf_names";
1610 case DW_AT_src_info: return "DW_AT_src_info";
1611 case DW_AT_mac_info: return "DW_AT_mac_info";
1612 case DW_AT_src_coords: return "DW_AT_src_coords";
1613 case DW_AT_body_begin: return "DW_AT_body_begin";
1614 case DW_AT_body_end: return "DW_AT_body_end";
1615 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1617 /* UPC extension. */
1618 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1620 /* PGI (STMicroelectronics) extensions. */
1621 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1622 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1623 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1627 static char buffer[100];
1629 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1636 static unsigned char *
1637 read_and_display_attr (unsigned long attribute,
1639 unsigned char *data,
1640 unsigned long cu_offset,
1641 unsigned long pointer_size,
1642 unsigned long offset_size,
1644 debug_info *debug_info_p,
1648 printf (" %-18s:", get_AT_name (attribute));
1649 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1650 pointer_size, offset_size,
1651 dwarf_version, debug_info_p,
1659 /* Process the contents of a .debug_info section. If do_loc is non-zero
1660 then we are scanning for location lists and we do not want to display
1661 anything to the user. */
1664 process_debug_info (struct dwarf_section *section, void *file,
1667 unsigned char *start = section->start;
1668 unsigned char *end = start + section->size;
1669 unsigned char *section_begin;
1671 unsigned int num_units = 0;
1673 if ((do_loc || do_debug_loc || do_debug_ranges)
1674 && num_debug_info_entries == 0)
1676 unsigned long length;
1678 /* First scan the section to get the number of comp units. */
1679 for (section_begin = start, num_units = 0; section_begin < end;
1682 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1683 will be the length. For a 64-bit DWARF section, it'll be
1684 the escape code 0xffffffff followed by an 8 byte length. */
1685 length = byte_get (section_begin, 4);
1687 if (length == 0xffffffff)
1689 length = byte_get (section_begin + 4, 8);
1690 section_begin += length + 12;
1693 section_begin += length + 4;
1695 /* Negative values are illegal, they may even cause infinite
1696 looping. This can happen if we can't accurately apply
1697 relocations to an object file. */
1698 if ((signed long) length <= 0)
1700 warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1707 error (_("No comp units in %s section ?"), section->name);
1711 /* Then allocate an array to hold the information. */
1712 debug_information = cmalloc (num_units,
1713 sizeof (* debug_information));
1714 if (debug_information == NULL)
1716 error (_("Not enough memory for a debug info array of %u entries"),
1724 printf (_("The section %s contains:\n\n"), section->name);
1726 load_debug_section (str, file);
1729 load_debug_section (abbrev, file);
1730 if (debug_displays [abbrev].section.start == NULL)
1732 warn (_("Unable to locate %s section!\n"),
1733 debug_displays [abbrev].section.name);
1737 for (section_begin = start, unit = 0; start < end; unit++)
1739 DWARF2_Internal_CompUnit compunit;
1740 unsigned char *hdrptr;
1741 unsigned char *cu_abbrev_offset_ptr;
1742 unsigned char *tags;
1744 unsigned long cu_offset;
1746 int initial_length_size;
1750 compunit.cu_length = byte_get (hdrptr, 4);
1753 if (compunit.cu_length == 0xffffffff)
1755 compunit.cu_length = byte_get (hdrptr, 8);
1758 initial_length_size = 12;
1763 initial_length_size = 4;
1766 compunit.cu_version = byte_get (hdrptr, 2);
1769 cu_offset = start - section_begin;
1771 cu_abbrev_offset_ptr = hdrptr;
1772 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1773 hdrptr += offset_size;
1775 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1777 if ((do_loc || do_debug_loc || do_debug_ranges)
1778 && num_debug_info_entries == 0)
1780 debug_information [unit].cu_offset = cu_offset;
1781 debug_information [unit].pointer_size
1782 = compunit.cu_pointer_size;
1783 debug_information [unit].base_address = 0;
1784 debug_information [unit].loc_offsets = NULL;
1785 debug_information [unit].have_frame_base = NULL;
1786 debug_information [unit].max_loc_offsets = 0;
1787 debug_information [unit].num_loc_offsets = 0;
1788 debug_information [unit].range_lists = NULL;
1789 debug_information [unit].max_range_lists= 0;
1790 debug_information [unit].num_range_lists = 0;
1795 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1796 printf (_(" Length: %ld\n"), compunit.cu_length);
1797 printf (_(" Version: %d\n"), compunit.cu_version);
1798 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1799 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1802 if (cu_offset + compunit.cu_length + initial_length_size
1805 warn (_("Debug info is corrupted, length is invalid (section is %lu bytes)\n"),
1806 (unsigned long)section->size);
1810 start += compunit.cu_length + initial_length_size;
1812 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1814 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1820 /* Process the abbrevs used by this compilation unit. DWARF
1821 sections under Mach-O have non-zero addresses. */
1822 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1823 warn (_("Debug info is corrupted, abbrev offset is invalid (section is %lu bytes)\n"),
1824 (unsigned long)debug_displays [abbrev].section.size);
1826 process_abbrev_section
1827 ((unsigned char *) debug_displays [abbrev].section.start
1828 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1829 (unsigned char *) debug_displays [abbrev].section.start
1830 + debug_displays [abbrev].section.size);
1833 while (tags < start)
1835 unsigned int bytes_read;
1836 unsigned long abbrev_number;
1837 abbrev_entry *entry;
1840 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1843 /* A null DIE marks the end of a list of children. */
1844 if (abbrev_number == 0)
1851 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1853 (unsigned long) (tags - section_begin
1857 /* Scan through the abbreviation list until we reach the
1859 for (entry = first_abbrev;
1860 entry && entry->entry != abbrev_number;
1861 entry = entry->next)
1871 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1877 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1882 need_base_address = 0;
1884 case DW_TAG_compile_unit:
1885 need_base_address = 1;
1887 case DW_TAG_entry_point:
1888 case DW_TAG_subprogram:
1889 need_base_address = 0;
1890 /* Assuming that there is no DW_AT_frame_base. */
1891 have_frame_base = 0;
1895 for (attr = entry->first_attr; attr; attr = attr->next)
1898 /* Show the offset from where the tag was extracted. */
1899 printf (" <%2lx>", (unsigned long)(tags - section_begin));
1901 tags = read_and_display_attr (attr->attribute,
1904 compunit.cu_pointer_size,
1906 compunit.cu_version,
1907 &debug_information [unit],
1911 if (entry->children)
1916 /* Set num_debug_info_entries here so that it can be used to check if
1917 we need to process .debug_loc and .debug_ranges sections. */
1918 if ((do_loc || do_debug_loc || do_debug_ranges)
1919 && num_debug_info_entries == 0)
1920 num_debug_info_entries = num_units;
1930 /* Locate and scan the .debug_info section in the file and record the pointer
1931 sizes and offsets for the compilation units in it. Usually an executable
1932 will have just one pointer size, but this is not guaranteed, and so we try
1933 not to make any assumptions. Returns zero upon failure, or the number of
1934 compilation units upon success. */
1937 load_debug_info (void * file)
1939 /* Reset the last pointer size so that we can issue correct error
1940 messages if we are displaying the contents of more than one section. */
1941 last_pointer_size = 0;
1942 warned_about_missing_comp_units = FALSE;
1944 /* If we already have the information there is nothing else to do. */
1945 if (num_debug_info_entries > 0)
1946 return num_debug_info_entries;
1948 if (load_debug_section (info, file)
1949 && process_debug_info (&debug_displays [info].section, file, 1))
1950 return num_debug_info_entries;
1956 display_debug_lines (struct dwarf_section *section, void *file)
1958 unsigned char *start = section->start;
1959 unsigned char *data = start;
1960 unsigned char *end = start + section->size;
1962 printf (_("\nDump of debug contents of section %s:\n\n"),
1965 load_debug_info (file);
1969 DWARF2_Internal_LineInfo info;
1970 unsigned char *standard_opcodes;
1971 unsigned char *end_of_sequence;
1972 unsigned char *hdrptr;
1973 unsigned long hdroff;
1974 int initial_length_size;
1979 hdroff = hdrptr - start;
1981 /* Check the length of the block. */
1982 info.li_length = byte_get (hdrptr, 4);
1985 if (info.li_length == 0xffffffff)
1987 /* This section is 64-bit DWARF 3. */
1988 info.li_length = byte_get (hdrptr, 8);
1991 initial_length_size = 12;
1996 initial_length_size = 4;
1999 if (info.li_length + initial_length_size > section->size)
2002 (_("The line info appears to be corrupt - the section is too small\n"));
2006 /* Check its version number. */
2007 info.li_version = byte_get (hdrptr, 2);
2009 if (info.li_version != 2 && info.li_version != 3)
2011 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2015 info.li_prologue_length = byte_get (hdrptr, offset_size);
2016 hdrptr += offset_size;
2017 info.li_min_insn_length = byte_get (hdrptr, 1);
2019 info.li_default_is_stmt = byte_get (hdrptr, 1);
2021 info.li_line_base = byte_get (hdrptr, 1);
2023 info.li_line_range = byte_get (hdrptr, 1);
2025 info.li_opcode_base = byte_get (hdrptr, 1);
2028 /* Sign extend the line base field. */
2029 info.li_line_base <<= 24;
2030 info.li_line_base >>= 24;
2032 printf (_(" Offset: 0x%lx\n"), hdroff);
2033 printf (_(" Length: %ld\n"), info.li_length);
2034 printf (_(" DWARF Version: %d\n"), info.li_version);
2035 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
2036 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
2037 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
2038 printf (_(" Line Base: %d\n"), info.li_line_base);
2039 printf (_(" Line Range: %d\n"), info.li_line_range);
2040 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
2042 end_of_sequence = data + info.li_length + initial_length_size;
2044 reset_state_machine (info.li_default_is_stmt);
2046 /* Display the contents of the Opcodes table. */
2047 standard_opcodes = hdrptr;
2049 printf (_("\n Opcodes:\n"));
2051 for (i = 1; i < info.li_opcode_base; i++)
2052 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2054 /* Display the contents of the Directory table. */
2055 data = standard_opcodes + info.li_opcode_base - 1;
2058 printf (_("\n The Directory Table is empty.\n"));
2061 printf (_("\n The Directory Table:\n"));
2065 printf (_(" %s\n"), data);
2067 data += strlen ((char *) data) + 1;
2071 /* Skip the NUL at the end of the table. */
2074 /* Display the contents of the File Name table. */
2076 printf (_("\n The File Name Table is empty.\n"));
2079 printf (_("\n The File Name Table:\n"));
2080 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2084 unsigned char *name;
2085 unsigned int bytes_read;
2087 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
2090 data += strlen ((char *) data) + 1;
2092 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2094 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2096 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2098 printf (_("%s\n"), name);
2102 /* Skip the NUL at the end of the table. */
2105 /* Now display the statements. */
2106 printf (_("\n Line Number Statements:\n"));
2108 while (data < end_of_sequence)
2110 unsigned char op_code;
2112 unsigned long int uladv;
2113 unsigned int bytes_read;
2117 if (op_code >= info.li_opcode_base)
2119 op_code -= info.li_opcode_base;
2120 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2121 state_machine_regs.address += uladv;
2122 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2123 op_code, uladv, state_machine_regs.address);
2124 adv = (op_code % info.li_line_range) + info.li_line_base;
2125 state_machine_regs.line += adv;
2126 printf (_(" and Line by %d to %d\n"),
2127 adv, state_machine_regs.line);
2129 else switch (op_code)
2131 case DW_LNS_extended_op:
2132 data += process_extended_line_op (data, info.li_default_is_stmt);
2136 printf (_(" Copy\n"));
2139 case DW_LNS_advance_pc:
2140 uladv = read_leb128 (data, & bytes_read, 0);
2141 uladv *= info.li_min_insn_length;
2143 state_machine_regs.address += uladv;
2144 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
2145 state_machine_regs.address);
2148 case DW_LNS_advance_line:
2149 adv = read_leb128 (data, & bytes_read, 1);
2151 state_machine_regs.line += adv;
2152 printf (_(" Advance Line by %d to %d\n"), adv,
2153 state_machine_regs.line);
2156 case DW_LNS_set_file:
2157 adv = read_leb128 (data, & bytes_read, 0);
2159 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2161 state_machine_regs.file = adv;
2164 case DW_LNS_set_column:
2165 uladv = read_leb128 (data, & bytes_read, 0);
2167 printf (_(" Set column to %lu\n"), uladv);
2168 state_machine_regs.column = uladv;
2171 case DW_LNS_negate_stmt:
2172 adv = state_machine_regs.is_stmt;
2174 printf (_(" Set is_stmt to %d\n"), adv);
2175 state_machine_regs.is_stmt = adv;
2178 case DW_LNS_set_basic_block:
2179 printf (_(" Set basic block\n"));
2180 state_machine_regs.basic_block = 1;
2183 case DW_LNS_const_add_pc:
2184 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2185 * info.li_min_insn_length);
2186 state_machine_regs.address += uladv;
2187 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2188 state_machine_regs.address);
2191 case DW_LNS_fixed_advance_pc:
2192 uladv = byte_get (data, 2);
2194 state_machine_regs.address += uladv;
2195 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2196 uladv, state_machine_regs.address);
2199 case DW_LNS_set_prologue_end:
2200 printf (_(" Set prologue_end to true\n"));
2203 case DW_LNS_set_epilogue_begin:
2204 printf (_(" Set epilogue_begin to true\n"));
2207 case DW_LNS_set_isa:
2208 uladv = read_leb128 (data, & bytes_read, 0);
2210 printf (_(" Set ISA to %lu\n"), uladv);
2214 printf (_(" Unknown opcode %d with operands: "), op_code);
2216 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2218 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2219 i == 1 ? "" : ", ");
2233 display_debug_pubnames (struct dwarf_section *section,
2234 void *file ATTRIBUTE_UNUSED)
2236 DWARF2_Internal_PubNames pubnames;
2237 unsigned char *start = section->start;
2238 unsigned char *end = start + section->size;
2240 printf (_("Contents of the %s section:\n\n"), section->name);
2244 unsigned char *data;
2245 unsigned long offset;
2246 int offset_size, initial_length_size;
2250 pubnames.pn_length = byte_get (data, 4);
2252 if (pubnames.pn_length == 0xffffffff)
2254 pubnames.pn_length = byte_get (data, 8);
2257 initial_length_size = 12;
2262 initial_length_size = 4;
2265 pubnames.pn_version = byte_get (data, 2);
2267 pubnames.pn_offset = byte_get (data, offset_size);
2268 data += offset_size;
2269 pubnames.pn_size = byte_get (data, offset_size);
2270 data += offset_size;
2272 start += pubnames.pn_length + initial_length_size;
2274 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2276 static int warned = 0;
2280 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2287 printf (_(" Length: %ld\n"),
2288 pubnames.pn_length);
2289 printf (_(" Version: %d\n"),
2290 pubnames.pn_version);
2291 printf (_(" Offset into .debug_info section: %ld\n"),
2292 pubnames.pn_offset);
2293 printf (_(" Size of area in .debug_info section: %ld\n"),
2296 printf (_("\n Offset\tName\n"));
2300 offset = byte_get (data, offset_size);
2304 data += offset_size;
2305 printf (" %-6ld\t\t%s\n", offset, data);
2306 data += strlen ((char *) data) + 1;
2309 while (offset != 0);
2317 display_debug_macinfo (struct dwarf_section *section,
2318 void *file ATTRIBUTE_UNUSED)
2320 unsigned char *start = section->start;
2321 unsigned char *end = start + section->size;
2322 unsigned char *curr = start;
2323 unsigned int bytes_read;
2324 enum dwarf_macinfo_record_type op;
2326 printf (_("Contents of the %s section:\n\n"), section->name);
2330 unsigned int lineno;
2338 case DW_MACINFO_start_file:
2340 unsigned int filenum;
2342 lineno = read_leb128 (curr, & bytes_read, 0);
2344 filenum = read_leb128 (curr, & bytes_read, 0);
2347 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2352 case DW_MACINFO_end_file:
2353 printf (_(" DW_MACINFO_end_file\n"));
2356 case DW_MACINFO_define:
2357 lineno = read_leb128 (curr, & bytes_read, 0);
2359 string = (char *) curr;
2360 curr += strlen (string) + 1;
2361 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2365 case DW_MACINFO_undef:
2366 lineno = read_leb128 (curr, & bytes_read, 0);
2368 string = (char *) curr;
2369 curr += strlen (string) + 1;
2370 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2374 case DW_MACINFO_vendor_ext:
2376 unsigned int constant;
2378 constant = read_leb128 (curr, & bytes_read, 0);
2380 string = (char *) curr;
2381 curr += strlen (string) + 1;
2382 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2393 display_debug_abbrev (struct dwarf_section *section,
2394 void *file ATTRIBUTE_UNUSED)
2396 abbrev_entry *entry;
2397 unsigned char *start = section->start;
2398 unsigned char *end = start + section->size;
2400 printf (_("Contents of the %s section:\n\n"), section->name);
2406 start = process_abbrev_section (start, end);
2408 if (first_abbrev == NULL)
2411 printf (_(" Number TAG\n"));
2413 for (entry = first_abbrev; entry; entry = entry->next)
2417 printf (_(" %ld %s [%s]\n"),
2419 get_TAG_name (entry->tag),
2420 entry->children ? _("has children") : _("no children"));
2422 for (attr = entry->first_attr; attr; attr = attr->next)
2423 printf (_(" %-18s %s\n"),
2424 get_AT_name (attr->attribute),
2425 get_FORM_name (attr->form));
2436 display_debug_loc (struct dwarf_section *section, void *file)
2438 unsigned char *start = section->start;
2439 unsigned char *section_end;
2440 unsigned long bytes;
2441 unsigned char *section_begin = start;
2442 unsigned int num_loc_list = 0;
2443 unsigned long last_offset = 0;
2444 unsigned int first = 0;
2447 int seen_first_offset = 0;
2448 int use_debug_info = 1;
2449 unsigned char *next;
2451 bytes = section->size;
2452 section_end = start + bytes;
2456 printf (_("\nThe %s section is empty.\n"), section->name);
2460 load_debug_info (file);
2462 /* Check the order of location list in .debug_info section. If
2463 offsets of location lists are in the ascending order, we can
2464 use `debug_information' directly. */
2465 for (i = 0; i < num_debug_info_entries; i++)
2469 num = debug_information [i].num_loc_offsets;
2470 num_loc_list += num;
2472 /* Check if we can use `debug_information' directly. */
2473 if (use_debug_info && num != 0)
2475 if (!seen_first_offset)
2477 /* This is the first location list. */
2478 last_offset = debug_information [i].loc_offsets [0];
2480 seen_first_offset = 1;
2486 for (; j < num; j++)
2489 debug_information [i].loc_offsets [j])
2494 last_offset = debug_information [i].loc_offsets [j];
2499 if (!use_debug_info)
2500 /* FIXME: Should we handle this case? */
2501 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2503 if (!seen_first_offset)
2504 error (_("No location lists in .debug_info section!\n"));
2506 /* DWARF sections under Mach-O have non-zero addresses. */
2507 if (debug_information [first].num_loc_offsets > 0
2508 && debug_information [first].loc_offsets [0] != section->address)
2509 warn (_("Location lists in %s section start at 0x%lx\n"),
2510 section->name, debug_information [first].loc_offsets [0]);
2512 printf (_("Contents of the %s section:\n\n"), section->name);
2513 printf (_(" Offset Begin End Expression\n"));
2515 seen_first_offset = 0;
2516 for (i = first; i < num_debug_info_entries; i++)
2518 unsigned long begin;
2520 unsigned short length;
2521 unsigned long offset;
2522 unsigned int pointer_size;
2523 unsigned long cu_offset;
2524 unsigned long base_address;
2525 int need_frame_base;
2528 pointer_size = debug_information [i].pointer_size;
2529 cu_offset = debug_information [i].cu_offset;
2531 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2533 has_frame_base = debug_information [i].have_frame_base [j];
2534 /* DWARF sections under Mach-O have non-zero addresses. */
2535 offset = debug_information [i].loc_offsets [j] - section->address;
2536 next = section_begin + offset;
2537 base_address = debug_information [i].base_address;
2539 if (!seen_first_offset)
2540 seen_first_offset = 1;
2544 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2545 (long)(start - section_begin), (long)(next - section_begin));
2546 else if (start > next)
2547 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2548 (long)(start - section_begin), (long)(next - section_begin));
2552 if (offset >= bytes)
2554 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2561 if (start + 2 * pointer_size > section_end)
2563 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2568 begin = byte_get (start, pointer_size);
2569 start += pointer_size;
2570 end = byte_get (start, pointer_size);
2571 start += pointer_size;
2573 if (begin == 0 && end == 0)
2575 printf (_(" %8.8lx <End of list>\n"), offset);
2579 /* Check base address specifiers. */
2580 if (begin == -1UL && end != -1UL)
2583 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2584 offset, begin, end);
2588 if (start + 2 > section_end)
2590 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2595 length = byte_get (start, 2);
2598 if (start + length > section_end)
2600 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2605 printf (" %8.8lx %8.8lx %8.8lx (",
2606 offset, begin + base_address, end + base_address);
2607 need_frame_base = decode_location_expression (start,
2613 if (need_frame_base && !has_frame_base)
2614 printf (_(" [without DW_AT_frame_base]"));
2617 fputs (_(" (start == end)"), stdout);
2618 else if (begin > end)
2619 fputs (_(" (start > end)"), stdout);
2628 if (start < section_end)
2629 warn (_("There are %ld unused bytes at the end of section %s\n"),
2630 (long) (section_end - start), section->name);
2635 display_debug_str (struct dwarf_section *section,
2636 void *file ATTRIBUTE_UNUSED)
2638 unsigned char *start = section->start;
2639 unsigned long bytes = section->size;
2640 dwarf_vma addr = section->address;
2644 printf (_("\nThe %s section is empty.\n"), section->name);
2648 printf (_("Contents of the %s section:\n\n"), section->name);
2656 lbytes = (bytes > 16 ? 16 : bytes);
2658 printf (" 0x%8.8lx ", (unsigned long) addr);
2660 for (j = 0; j < 16; j++)
2663 printf ("%2.2x", start[j]);
2671 for (j = 0; j < lbytes; j++)
2674 if (k >= ' ' && k < 0x80)
2693 display_debug_info (struct dwarf_section *section, void *file)
2695 return process_debug_info (section, file, 0);
2700 display_debug_aranges (struct dwarf_section *section,
2701 void *file ATTRIBUTE_UNUSED)
2703 unsigned char *start = section->start;
2704 unsigned char *end = start + section->size;
2706 printf (_("The section %s contains:\n\n"), section->name);
2710 unsigned char *hdrptr;
2711 DWARF2_Internal_ARange arange;
2712 unsigned char *ranges;
2713 unsigned long length;
2714 unsigned long address;
2715 unsigned char address_size;
2718 int initial_length_size;
2722 arange.ar_length = byte_get (hdrptr, 4);
2725 if (arange.ar_length == 0xffffffff)
2727 arange.ar_length = byte_get (hdrptr, 8);
2730 initial_length_size = 12;
2735 initial_length_size = 4;
2738 arange.ar_version = byte_get (hdrptr, 2);
2741 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2742 hdrptr += offset_size;
2744 arange.ar_pointer_size = byte_get (hdrptr, 1);
2747 arange.ar_segment_size = byte_get (hdrptr, 1);
2750 if (arange.ar_version != 2 && arange.ar_version != 3)
2752 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2756 printf (_(" Length: %ld\n"), arange.ar_length);
2757 printf (_(" Version: %d\n"), arange.ar_version);
2758 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
2759 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2760 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2762 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2764 /* The DWARF spec does not require that the address size be a power
2765 of two, but we do. This will have to change if we ever encounter
2766 an uneven architecture. */
2767 if ((address_size & (address_size - 1)) != 0)
2769 warn (_("Pointer size + Segment size is not a power of two.\n"));
2773 if (address_size > 4)
2774 printf (_("\n Address Length\n"));
2776 printf (_("\n Address Length\n"));
2780 /* Must pad to an alignment boundary that is twice the address size. */
2781 excess = (hdrptr - start) % (2 * address_size);
2783 ranges += (2 * address_size) - excess;
2785 start += arange.ar_length + initial_length_size;
2787 while (ranges + 2 * address_size <= start)
2789 address = byte_get (ranges, address_size);
2791 ranges += address_size;
2793 length = byte_get (ranges, address_size);
2795 ranges += address_size;
2797 if (address_size > 4)
2798 printf (" 0x%16.16lx 0x%lx\n", address, length);
2800 printf (" 0x%8.8lx 0x%lx\n", address, length);
2810 display_debug_ranges (struct dwarf_section *section,
2811 void *file ATTRIBUTE_UNUSED)
2813 unsigned char *start = section->start;
2814 unsigned char *section_end;
2815 unsigned long bytes;
2816 unsigned char *section_begin = start;
2817 unsigned int num_range_list = 0;
2818 unsigned long last_offset = 0;
2819 unsigned int first = 0;
2822 int seen_first_offset = 0;
2823 int use_debug_info = 1;
2824 unsigned char *next;
2826 bytes = section->size;
2827 section_end = start + bytes;
2831 printf (_("\nThe %s section is empty.\n"), section->name);
2835 load_debug_info (file);
2837 /* Check the order of range list in .debug_info section. If
2838 offsets of range lists are in the ascending order, we can
2839 use `debug_information' directly. */
2840 for (i = 0; i < num_debug_info_entries; i++)
2844 num = debug_information [i].num_range_lists;
2845 num_range_list += num;
2847 /* Check if we can use `debug_information' directly. */
2848 if (use_debug_info && num != 0)
2850 if (!seen_first_offset)
2852 /* This is the first range list. */
2853 last_offset = debug_information [i].range_lists [0];
2855 seen_first_offset = 1;
2861 for (; j < num; j++)
2864 debug_information [i].range_lists [j])
2869 last_offset = debug_information [i].range_lists [j];
2874 if (!use_debug_info)
2875 /* FIXME: Should we handle this case? */
2876 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2878 if (!seen_first_offset)
2879 error (_("No range lists in .debug_info section!\n"));
2881 /* DWARF sections under Mach-O have non-zero addresses. */
2882 if (debug_information [first].num_range_lists > 0
2883 && debug_information [first].range_lists [0] != section->address)
2884 warn (_("Range lists in %s section start at 0x%lx\n"),
2885 section->name, debug_information [first].range_lists [0]);
2887 printf (_("Contents of the %s section:\n\n"), section->name);
2888 printf (_(" Offset Begin End\n"));
2890 seen_first_offset = 0;
2891 for (i = first; i < num_debug_info_entries; i++)
2893 unsigned long begin;
2895 unsigned long offset;
2896 unsigned int pointer_size;
2897 unsigned long base_address;
2899 pointer_size = debug_information [i].pointer_size;
2901 for (j = 0; j < debug_information [i].num_range_lists; j++)
2903 /* DWARF sections under Mach-O have non-zero addresses. */
2904 offset = debug_information [i].range_lists [j] - section->address;
2905 next = section_begin + offset;
2906 base_address = debug_information [i].base_address;
2908 if (!seen_first_offset)
2909 seen_first_offset = 1;
2913 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2914 (long)(start - section_begin),
2915 (long)(next - section_begin), section->name);
2916 else if (start > next)
2917 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2918 (long)(start - section_begin),
2919 (long)(next - section_begin), section->name);
2925 begin = byte_get (start, pointer_size);
2926 start += pointer_size;
2927 end = byte_get (start, pointer_size);
2928 start += pointer_size;
2930 if (begin == 0 && end == 0)
2932 printf (_(" %8.8lx <End of list>\n"), offset);
2936 /* Check base address specifiers. */
2937 if (begin == -1UL && end != -1UL)
2940 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
2941 offset, begin, end);
2945 printf (" %8.8lx %8.8lx %8.8lx",
2946 offset, begin + base_address, end + base_address);
2949 fputs (_(" (start == end)"), stdout);
2950 else if (begin > end)
2951 fputs (_(" (start > end)"), stdout);
2961 typedef struct Frame_Chunk
2963 struct Frame_Chunk *next;
2964 unsigned char *chunk_start;
2966 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
2967 short int *col_type;
2970 unsigned int code_factor;
2972 unsigned long pc_begin;
2973 unsigned long pc_range;
2977 unsigned char fde_encoding;
2978 unsigned char cfa_exp;
2982 /* A marker for a col_type that means this column was never referenced
2983 in the frame info. */
2984 #define DW_CFA_unreferenced (-1)
2987 frame_need_space (Frame_Chunk *fc, int reg)
2989 int prev = fc->ncols;
2991 if (reg < fc->ncols)
2994 fc->ncols = reg + 1;
2995 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2996 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2998 while (prev < fc->ncols)
3000 fc->col_type[prev] = DW_CFA_unreferenced;
3001 fc->col_offset[prev] = 0;
3007 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3012 if (*max_regs < fc->ncols)
3013 *max_regs = fc->ncols;
3015 if (*need_col_headers)
3017 *need_col_headers = 0;
3019 printf (" LOC CFA ");
3021 for (r = 0; r < *max_regs; r++)
3022 if (fc->col_type[r] != DW_CFA_unreferenced)
3027 printf ("r%-4d", r);
3033 printf ("%08lx ", fc->pc_begin);
3035 strcpy (tmp, "exp");
3037 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
3038 printf ("%-8s ", tmp);
3040 for (r = 0; r < fc->ncols; r++)
3042 if (fc->col_type[r] != DW_CFA_unreferenced)
3044 switch (fc->col_type[r])
3046 case DW_CFA_undefined:
3049 case DW_CFA_same_value:
3053 sprintf (tmp, "c%+d", fc->col_offset[r]);
3055 case DW_CFA_val_offset:
3056 sprintf (tmp, "v%+d", fc->col_offset[r]);
3058 case DW_CFA_register:
3059 sprintf (tmp, "r%d", fc->col_offset[r]);
3061 case DW_CFA_expression:
3062 strcpy (tmp, "exp");
3064 case DW_CFA_val_expression:
3065 strcpy (tmp, "vexp");
3068 strcpy (tmp, "n/a");
3071 printf ("%-5s", tmp);
3078 size_of_encoded_value (int encoding)
3080 switch (encoding & 0x7)
3083 case 0: return eh_addr_size;
3091 get_encoded_value (unsigned char *data, int encoding)
3093 int size = size_of_encoded_value (encoding);
3095 if (encoding & DW_EH_PE_signed)
3096 return byte_get_signed (data, size);
3098 return byte_get (data, size);
3101 #define GET(N) byte_get (start, N); start += N
3102 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3103 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3106 display_debug_frames (struct dwarf_section *section,
3107 void *file ATTRIBUTE_UNUSED)
3109 unsigned char *start = section->start;
3110 unsigned char *end = start + section->size;
3111 unsigned char *section_start = start;
3112 Frame_Chunk *chunks = 0;
3113 Frame_Chunk *remembered_state = 0;
3115 int is_eh = strcmp (section->name, ".eh_frame") == 0;
3116 unsigned int length_return;
3119 printf (_("The section %s contains:\n"), section->name);
3123 unsigned char *saved_start;
3124 unsigned char *block_end;
3125 unsigned long length;
3126 unsigned long cie_id;
3129 int need_col_headers = 1;
3130 unsigned char *augmentation_data = NULL;
3131 unsigned long augmentation_data_len = 0;
3132 int encoded_ptr_size = eh_addr_size;
3134 int initial_length_size;
3136 saved_start = start;
3137 length = byte_get (start, 4); start += 4;
3141 printf ("\n%08lx ZERO terminator\n\n",
3142 (unsigned long)(saved_start - section_start));
3146 if (length == 0xffffffff)
3148 length = byte_get (start, 8);
3151 initial_length_size = 12;
3156 initial_length_size = 4;
3159 block_end = saved_start + length + initial_length_size;
3160 if (block_end > end)
3162 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3163 length, (unsigned long)(saved_start - section_start));
3166 cie_id = byte_get (start, offset_size); start += offset_size;
3168 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3172 fc = xmalloc (sizeof (Frame_Chunk));
3173 memset (fc, 0, sizeof (Frame_Chunk));
3177 fc->chunk_start = saved_start;
3179 fc->col_type = xmalloc (sizeof (short int));
3180 fc->col_offset = xmalloc (sizeof (int));
3181 frame_need_space (fc, max_regs-1);
3185 fc->augmentation = (char *) start;
3186 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3188 if (fc->augmentation[0] == 'z')
3190 fc->code_factor = LEB ();
3191 fc->data_factor = SLEB ();
3200 augmentation_data_len = LEB ();
3201 augmentation_data = start;
3202 start += augmentation_data_len;
3204 else if (strcmp (fc->augmentation, "eh") == 0)
3206 start += eh_addr_size;
3207 fc->code_factor = LEB ();
3208 fc->data_factor = SLEB ();
3220 fc->code_factor = LEB ();
3221 fc->data_factor = SLEB ();
3233 if (do_debug_frames_interp)
3234 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3235 (unsigned long)(saved_start - section_start), length, cie_id,
3236 fc->augmentation, fc->code_factor, fc->data_factor,
3240 printf ("\n%08lx %08lx %08lx CIE\n",
3241 (unsigned long)(saved_start - section_start), length, cie_id);
3242 printf (" Version: %d\n", version);
3243 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3244 printf (" Code alignment factor: %u\n", fc->code_factor);
3245 printf (" Data alignment factor: %d\n", fc->data_factor);
3246 printf (" Return address column: %d\n", fc->ra);
3248 if (augmentation_data_len)
3251 printf (" Augmentation data: ");
3252 for (i = 0; i < augmentation_data_len; ++i)
3253 printf (" %02x", augmentation_data[i]);
3259 if (augmentation_data_len)
3261 unsigned char *p, *q;
3262 p = (unsigned char *) fc->augmentation + 1;
3263 q = augmentation_data;
3270 q += 1 + size_of_encoded_value (*q);
3272 fc->fde_encoding = *q++;
3278 if (fc->fde_encoding)
3279 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3282 frame_need_space (fc, fc->ra);
3286 unsigned char *look_for;
3287 static Frame_Chunk fde_fc;
3290 memset (fc, 0, sizeof (Frame_Chunk));
3292 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3294 for (cie = chunks; cie ; cie = cie->next)
3295 if (cie->chunk_start == look_for)
3300 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3301 cie_id, (unsigned long)(saved_start - section_start));
3303 fc->col_type = xmalloc (sizeof (short int));
3304 fc->col_offset = xmalloc (sizeof (int));
3305 frame_need_space (fc, max_regs - 1);
3307 fc->augmentation = "";
3308 fc->fde_encoding = 0;
3312 fc->ncols = cie->ncols;
3313 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3314 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3315 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3316 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3317 fc->augmentation = cie->augmentation;
3318 fc->code_factor = cie->code_factor;
3319 fc->data_factor = cie->data_factor;
3320 fc->cfa_reg = cie->cfa_reg;
3321 fc->cfa_offset = cie->cfa_offset;
3323 frame_need_space (fc, max_regs-1);
3324 fc->fde_encoding = cie->fde_encoding;
3327 if (fc->fde_encoding)
3328 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3330 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3331 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3332 fc->pc_begin += section->address + (start - section_start);
3333 start += encoded_ptr_size;
3334 fc->pc_range = byte_get (start, encoded_ptr_size);
3335 start += encoded_ptr_size;
3337 if (cie->augmentation[0] == 'z')
3339 augmentation_data_len = LEB ();
3340 augmentation_data = start;
3341 start += augmentation_data_len;
3344 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3345 (unsigned long)(saved_start - section_start), length, cie_id,
3346 (unsigned long)(cie->chunk_start - section_start),
3347 fc->pc_begin, fc->pc_begin + fc->pc_range);
3348 if (! do_debug_frames_interp && augmentation_data_len)
3352 printf (" Augmentation data: ");
3353 for (i = 0; i < augmentation_data_len; ++i)
3354 printf (" %02x", augmentation_data[i]);
3360 /* At this point, fc is the current chunk, cie (if any) is set, and
3361 we're about to interpret instructions for the chunk. */
3362 /* ??? At present we need to do this always, since this sizes the
3363 fc->col_type and fc->col_offset arrays, which we write into always.
3364 We should probably split the interpreted and non-interpreted bits
3365 into two different routines, since there's so much that doesn't
3366 really overlap between them. */
3367 if (1 || do_debug_frames_interp)
3369 /* Start by making a pass over the chunk, allocating storage
3370 and taking note of what registers are used. */
3371 unsigned char *tmp = start;
3373 while (start < block_end)
3376 unsigned long reg, tmp;
3383 /* Warning: if you add any more cases to this switch, be
3384 sure to add them to the corresponding switch below. */
3387 case DW_CFA_advance_loc:
3391 frame_need_space (fc, opa);
3392 fc->col_type[opa] = DW_CFA_undefined;
3394 case DW_CFA_restore:
3395 frame_need_space (fc, opa);
3396 fc->col_type[opa] = DW_CFA_undefined;
3398 case DW_CFA_set_loc:
3399 start += encoded_ptr_size;
3401 case DW_CFA_advance_loc1:
3404 case DW_CFA_advance_loc2:
3407 case DW_CFA_advance_loc4:
3410 case DW_CFA_offset_extended:
3411 case DW_CFA_val_offset:
3412 reg = LEB (); LEB ();
3413 frame_need_space (fc, reg);
3414 fc->col_type[reg] = DW_CFA_undefined;
3416 case DW_CFA_restore_extended:
3418 frame_need_space (fc, reg);
3419 fc->col_type[reg] = DW_CFA_undefined;
3421 case DW_CFA_undefined:
3423 frame_need_space (fc, reg);
3424 fc->col_type[reg] = DW_CFA_undefined;
3426 case DW_CFA_same_value:
3428 frame_need_space (fc, reg);
3429 fc->col_type[reg] = DW_CFA_undefined;
3431 case DW_CFA_register:
3432 reg = LEB (); LEB ();
3433 frame_need_space (fc, reg);
3434 fc->col_type[reg] = DW_CFA_undefined;
3436 case DW_CFA_def_cfa:
3439 case DW_CFA_def_cfa_register:
3442 case DW_CFA_def_cfa_offset:
3445 case DW_CFA_def_cfa_expression:
3449 case DW_CFA_expression:
3450 case DW_CFA_val_expression:
3454 frame_need_space (fc, reg);
3455 fc->col_type[reg] = DW_CFA_undefined;
3457 case DW_CFA_offset_extended_sf:
3458 case DW_CFA_val_offset_sf:
3459 reg = LEB (); SLEB ();
3460 frame_need_space (fc, reg);
3461 fc->col_type[reg] = DW_CFA_undefined;
3463 case DW_CFA_def_cfa_sf:
3466 case DW_CFA_def_cfa_offset_sf:
3469 case DW_CFA_MIPS_advance_loc8:
3472 case DW_CFA_GNU_args_size:
3475 case DW_CFA_GNU_negative_offset_extended:
3476 reg = LEB (); LEB ();
3477 frame_need_space (fc, reg);
3478 fc->col_type[reg] = DW_CFA_undefined;
3487 /* Now we know what registers are used, make a second pass over
3488 the chunk, this time actually printing out the info. */
3490 while (start < block_end)
3493 unsigned long ul, reg, roffs;
3502 /* Warning: if you add any more cases to this switch, be
3503 sure to add them to the corresponding switch above. */
3506 case DW_CFA_advance_loc:
3507 if (do_debug_frames_interp)
3508 frame_display_row (fc, &need_col_headers, &max_regs);
3510 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3511 opa * fc->code_factor,
3512 fc->pc_begin + opa * fc->code_factor);
3513 fc->pc_begin += opa * fc->code_factor;
3518 if (! do_debug_frames_interp)
3519 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3520 opa, roffs * fc->data_factor);
3521 fc->col_type[opa] = DW_CFA_offset;
3522 fc->col_offset[opa] = roffs * fc->data_factor;
3525 case DW_CFA_restore:
3526 if (! do_debug_frames_interp)
3527 printf (" DW_CFA_restore: r%d\n", opa);
3528 fc->col_type[opa] = cie->col_type[opa];
3529 fc->col_offset[opa] = cie->col_offset[opa];
3532 case DW_CFA_set_loc:
3533 vma = get_encoded_value (start, fc->fde_encoding);
3534 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3535 vma += section->address + (start - section_start);
3536 start += encoded_ptr_size;
3537 if (do_debug_frames_interp)
3538 frame_display_row (fc, &need_col_headers, &max_regs);
3540 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3544 case DW_CFA_advance_loc1:
3545 ofs = byte_get (start, 1); start += 1;
3546 if (do_debug_frames_interp)
3547 frame_display_row (fc, &need_col_headers, &max_regs);
3549 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3550 ofs * fc->code_factor,
3551 fc->pc_begin + ofs * fc->code_factor);
3552 fc->pc_begin += ofs * fc->code_factor;
3555 case DW_CFA_advance_loc2:
3556 ofs = byte_get (start, 2); start += 2;
3557 if (do_debug_frames_interp)
3558 frame_display_row (fc, &need_col_headers, &max_regs);
3560 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3561 ofs * fc->code_factor,
3562 fc->pc_begin + ofs * fc->code_factor);
3563 fc->pc_begin += ofs * fc->code_factor;
3566 case DW_CFA_advance_loc4:
3567 ofs = byte_get (start, 4); start += 4;
3568 if (do_debug_frames_interp)
3569 frame_display_row (fc, &need_col_headers, &max_regs);
3571 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3572 ofs * fc->code_factor,
3573 fc->pc_begin + ofs * fc->code_factor);
3574 fc->pc_begin += ofs * fc->code_factor;
3577 case DW_CFA_offset_extended:
3580 if (! do_debug_frames_interp)
3581 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3582 reg, roffs * fc->data_factor);
3583 fc->col_type[reg] = DW_CFA_offset;
3584 fc->col_offset[reg] = roffs * fc->data_factor;
3587 case DW_CFA_val_offset:
3590 if (! do_debug_frames_interp)
3591 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3592 reg, roffs * fc->data_factor);
3593 fc->col_type[reg] = DW_CFA_val_offset;
3594 fc->col_offset[reg] = roffs * fc->data_factor;
3597 case DW_CFA_restore_extended:
3599 if (! do_debug_frames_interp)
3600 printf (" DW_CFA_restore_extended: r%ld\n", reg);
3601 fc->col_type[reg] = cie->col_type[reg];
3602 fc->col_offset[reg] = cie->col_offset[reg];
3605 case DW_CFA_undefined:
3607 if (! do_debug_frames_interp)
3608 printf (" DW_CFA_undefined: r%ld\n", reg);
3609 fc->col_type[reg] = DW_CFA_undefined;
3610 fc->col_offset[reg] = 0;
3613 case DW_CFA_same_value:
3615 if (! do_debug_frames_interp)
3616 printf (" DW_CFA_same_value: r%ld\n", reg);
3617 fc->col_type[reg] = DW_CFA_same_value;
3618 fc->col_offset[reg] = 0;
3621 case DW_CFA_register:
3624 if (! do_debug_frames_interp)
3625 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3626 fc->col_type[reg] = DW_CFA_register;
3627 fc->col_offset[reg] = roffs;
3630 case DW_CFA_remember_state:
3631 if (! do_debug_frames_interp)
3632 printf (" DW_CFA_remember_state\n");
3633 rs = xmalloc (sizeof (Frame_Chunk));
3634 rs->ncols = fc->ncols;
3635 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3636 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3637 memcpy (rs->col_type, fc->col_type, rs->ncols);
3638 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3639 rs->next = remembered_state;
3640 remembered_state = rs;
3643 case DW_CFA_restore_state:
3644 if (! do_debug_frames_interp)
3645 printf (" DW_CFA_restore_state\n");
3646 rs = remembered_state;
3649 remembered_state = rs->next;
3650 frame_need_space (fc, rs->ncols-1);
3651 memcpy (fc->col_type, rs->col_type, rs->ncols);
3652 memcpy (fc->col_offset, rs->col_offset,
3653 rs->ncols * sizeof (int));
3654 free (rs->col_type);
3655 free (rs->col_offset);
3658 else if (do_debug_frames_interp)
3659 printf ("Mismatched DW_CFA_restore_state\n");
3662 case DW_CFA_def_cfa:
3663 fc->cfa_reg = LEB ();
3664 fc->cfa_offset = LEB ();
3666 if (! do_debug_frames_interp)
3667 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3668 fc->cfa_reg, fc->cfa_offset);
3671 case DW_CFA_def_cfa_register:
3672 fc->cfa_reg = LEB ();
3674 if (! do_debug_frames_interp)
3675 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3678 case DW_CFA_def_cfa_offset:
3679 fc->cfa_offset = LEB ();
3680 if (! do_debug_frames_interp)
3681 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3685 if (! do_debug_frames_interp)
3686 printf (" DW_CFA_nop\n");
3689 case DW_CFA_def_cfa_expression:
3691 if (! do_debug_frames_interp)
3693 printf (" DW_CFA_def_cfa_expression (");
3694 decode_location_expression (start, eh_addr_size, ul, 0);
3701 case DW_CFA_expression:
3704 if (! do_debug_frames_interp)
3706 printf (" DW_CFA_expression: r%ld (", reg);
3707 decode_location_expression (start, eh_addr_size, ul, 0);
3710 fc->col_type[reg] = DW_CFA_expression;
3714 case DW_CFA_val_expression:
3717 if (! do_debug_frames_interp)
3719 printf (" DW_CFA_val_expression: r%ld (", reg);
3720 decode_location_expression (start, eh_addr_size, ul, 0);
3723 fc->col_type[reg] = DW_CFA_val_expression;
3727 case DW_CFA_offset_extended_sf:
3730 frame_need_space (fc, reg);
3731 if (! do_debug_frames_interp)
3732 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3733 reg, l * fc->data_factor);
3734 fc->col_type[reg] = DW_CFA_offset;
3735 fc->col_offset[reg] = l * fc->data_factor;
3738 case DW_CFA_val_offset_sf:
3741 frame_need_space (fc, reg);
3742 if (! do_debug_frames_interp)
3743 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3744 reg, l * fc->data_factor);
3745 fc->col_type[reg] = DW_CFA_val_offset;
3746 fc->col_offset[reg] = l * fc->data_factor;
3749 case DW_CFA_def_cfa_sf:
3750 fc->cfa_reg = LEB ();
3751 fc->cfa_offset = SLEB ();
3752 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3754 if (! do_debug_frames_interp)
3755 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3756 fc->cfa_reg, fc->cfa_offset);
3759 case DW_CFA_def_cfa_offset_sf:
3760 fc->cfa_offset = SLEB ();
3761 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3762 if (! do_debug_frames_interp)
3763 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3766 case DW_CFA_MIPS_advance_loc8:
3767 ofs = byte_get (start, 8); start += 8;
3768 if (do_debug_frames_interp)
3769 frame_display_row (fc, &need_col_headers, &max_regs);
3771 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3772 ofs * fc->code_factor,
3773 fc->pc_begin + ofs * fc->code_factor);
3774 fc->pc_begin += ofs * fc->code_factor;
3777 case DW_CFA_GNU_window_save:
3778 if (! do_debug_frames_interp)
3779 printf (" DW_CFA_GNU_window_save\n");
3782 case DW_CFA_GNU_args_size:
3784 if (! do_debug_frames_interp)
3785 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
3788 case DW_CFA_GNU_negative_offset_extended:
3791 frame_need_space (fc, reg);
3792 if (! do_debug_frames_interp)
3793 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3794 reg, l * fc->data_factor);
3795 fc->col_type[reg] = DW_CFA_offset;
3796 fc->col_offset[reg] = l * fc->data_factor;
3800 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3801 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3803 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3808 if (do_debug_frames_interp)
3809 frame_display_row (fc, &need_col_headers, &max_regs);
3824 display_debug_not_supported (struct dwarf_section *section,
3825 void *file ATTRIBUTE_UNUSED)
3827 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3834 cmalloc (size_t nmemb, size_t size)
3836 /* Check for overflow. */
3837 if (nmemb >= ~(size_t) 0 / size)
3840 return malloc (nmemb * size);
3844 xcmalloc (size_t nmemb, size_t size)
3846 /* Check for overflow. */
3847 if (nmemb >= ~(size_t) 0 / size)
3850 return xmalloc (nmemb * size);
3854 xcrealloc (void *ptr, size_t nmemb, size_t size)
3856 /* Check for overflow. */
3857 if (nmemb >= ~(size_t) 0 / size)
3860 return xrealloc (ptr, nmemb * size);
3864 error (const char *message, ...)
3868 va_start (args, message);
3869 fprintf (stderr, _("%s: Error: "), program_name);
3870 vfprintf (stderr, message, args);
3875 warn (const char *message, ...)
3879 va_start (args, message);
3880 fprintf (stderr, _("%s: Warning: "), program_name);
3881 vfprintf (stderr, message, args);
3886 free_debug_memory (void)
3888 enum dwarf_section_display_enum i;
3892 for (i = 0; i < max; i++)
3893 free_debug_section (i);
3895 if (debug_information)
3897 for (i = 0; i < num_debug_info_entries; i++)
3899 if (!debug_information [i].max_loc_offsets)
3901 free (debug_information [i].loc_offsets);
3902 free (debug_information [i].have_frame_base);
3904 if (!debug_information [i].max_range_lists)
3905 free (debug_information [i].range_lists);
3907 free (debug_information);
3908 debug_information = NULL;
3909 num_debug_info_entries = 0;
3914 struct dwarf_section_display debug_displays[] =
3916 { { ".debug_abbrev", NULL, 0, 0 },
3917 display_debug_abbrev, 0, 0 },
3918 { { ".debug_aranges", NULL, 0, 0 },
3919 display_debug_aranges, 0, 0 },
3920 { { ".debug_frame", NULL, 0, 0 },
3921 display_debug_frames, 1, 0 },
3922 { { ".debug_info", NULL, 0, 0 },
3923 display_debug_info, 1, 0 },
3924 { { ".debug_line", NULL, 0, 0 },
3925 display_debug_lines, 0, 0 },
3926 { { ".debug_pubnames", NULL, 0, 0 },
3927 display_debug_pubnames, 0, 0 },
3928 { { ".eh_frame", NULL, 0, 0 },
3929 display_debug_frames, 1, 1 },
3930 { { ".debug_macinfo", NULL, 0, 0 },
3931 display_debug_macinfo, 0, 0 },
3932 { { ".debug_str", NULL, 0, 0 },
3933 display_debug_str, 0, 0 },
3934 { { ".debug_loc", NULL, 0, 0 },
3935 display_debug_loc, 0, 0 },
3936 { { ".debug_pubtypes", NULL, 0, 0 },
3937 display_debug_pubnames, 0, 0 },
3938 { { ".debug_ranges", NULL, 0, 0 },
3939 display_debug_ranges, 0, 0 },
3940 { { ".debug_static_func", NULL, 0, 0 },
3941 display_debug_not_supported, 0, 0 },
3942 { { ".debug_static_vars", NULL, 0, 0 },
3943 display_debug_not_supported, 0, 0 },
3944 { { ".debug_types", NULL, 0, 0 },
3945 display_debug_not_supported, 0, 0 },
3946 { { ".debug_weaknames", NULL, 0, 0 },
3947 display_debug_not_supported, 0, 0 }