1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/common.h"
30 static int have_frame_base;
31 static int need_base_address;
33 static unsigned int last_pointer_size = 0;
34 static int warned_about_missing_comp_units = FALSE;
36 static unsigned int num_debug_info_entries = 0;
37 static debug_info *debug_information = NULL;
38 /* Special value for num_debug_info_entries to indicate
39 that the .debug_info section could not be loaded/parsed. */
40 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
47 int do_debug_pubnames;
48 int do_debug_pubtypes;
52 int do_debug_frames_interp;
61 /* Values for do_debug_lines. */
62 #define FLAG_DEBUG_LINES_RAW 1
63 #define FLAG_DEBUG_LINES_DECODED 2
65 dwarf_vma (*byte_get) (unsigned char *, int);
68 byte_get_little_endian (unsigned char *field, int size)
76 return ((unsigned int) (field[0]))
77 | (((unsigned int) (field[1])) << 8);
80 return ((unsigned long) (field[0]))
81 | (((unsigned long) (field[1])) << 8)
82 | (((unsigned long) (field[2])) << 16);
85 return ((unsigned long) (field[0]))
86 | (((unsigned long) (field[1])) << 8)
87 | (((unsigned long) (field[2])) << 16)
88 | (((unsigned long) (field[3])) << 24);
91 if (sizeof (dwarf_vma) == 8)
92 return ((dwarf_vma) (field[0]))
93 | (((dwarf_vma) (field[1])) << 8)
94 | (((dwarf_vma) (field[2])) << 16)
95 | (((dwarf_vma) (field[3])) << 24)
96 | (((dwarf_vma) (field[4])) << 32)
97 | (((dwarf_vma) (field[5])) << 40)
98 | (((dwarf_vma) (field[6])) << 48)
99 | (((dwarf_vma) (field[7])) << 56);
100 else if (sizeof (dwarf_vma) == 4)
101 /* We want to extract data from an 8 byte wide field and
102 place it into a 4 byte wide field. Since this is a little
103 endian source we can just use the 4 byte extraction code. */
104 return ((unsigned long) (field[0]))
105 | (((unsigned long) (field[1])) << 8)
106 | (((unsigned long) (field[2])) << 16)
107 | (((unsigned long) (field[3])) << 24);
110 error (_("Unhandled data length: %d\n"), size);
116 byte_get_big_endian (unsigned char *field, int size)
124 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
127 return ((unsigned long) (field[2]))
128 | (((unsigned long) (field[1])) << 8)
129 | (((unsigned long) (field[0])) << 16);
132 return ((unsigned long) (field[3]))
133 | (((unsigned long) (field[2])) << 8)
134 | (((unsigned long) (field[1])) << 16)
135 | (((unsigned long) (field[0])) << 24);
138 if (sizeof (dwarf_vma) == 8)
139 return ((dwarf_vma) (field[7]))
140 | (((dwarf_vma) (field[6])) << 8)
141 | (((dwarf_vma) (field[5])) << 16)
142 | (((dwarf_vma) (field[4])) << 24)
143 | (((dwarf_vma) (field[3])) << 32)
144 | (((dwarf_vma) (field[2])) << 40)
145 | (((dwarf_vma) (field[1])) << 48)
146 | (((dwarf_vma) (field[0])) << 56);
147 else if (sizeof (dwarf_vma) == 4)
149 /* Although we are extracing data from an 8 byte wide field,
150 we are returning only 4 bytes of data. */
152 return ((unsigned long) (field[3]))
153 | (((unsigned long) (field[2])) << 8)
154 | (((unsigned long) (field[1])) << 16)
155 | (((unsigned long) (field[0])) << 24);
159 error (_("Unhandled data length: %d\n"), size);
165 byte_get_signed (unsigned char *field, int size)
167 dwarf_vma x = byte_get (field, size);
172 return (x ^ 0x80) - 0x80;
174 return (x ^ 0x8000) - 0x8000;
176 return (x ^ 0x80000000) - 0x80000000;
185 size_of_encoded_value (int encoding)
187 switch (encoding & 0x7)
190 case 0: return eh_addr_size;
198 get_encoded_value (unsigned char *data, int encoding)
200 int size = size_of_encoded_value (encoding);
202 if (encoding & DW_EH_PE_signed)
203 return byte_get_signed (data, size);
205 return byte_get (data, size);
208 /* Print a dwarf_vma value (typically an address, offset or length) in
209 hexadecimal format, followed by a space. The length of the value (and
210 hence the precision displayed) is determined by the byte_size parameter. */
213 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
215 static char buff[18];
217 /* Printf does not have a way of specifiying a maximum field width for an
218 integer value, so we print the full value into a buffer and then select
219 the precision we need. */
220 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
222 snprintf (buff, sizeof (buff), "%16.16llx ", val);
224 snprintf (buff, sizeof (buff), "%016I64x ", val);
227 snprintf (buff, sizeof (buff), "%16.16lx ", val);
230 fputs (buff + (byte_size == 4 ? 8 : 0), stdout);
234 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
236 unsigned long int result = 0;
237 unsigned int num_read = 0;
238 unsigned int shift = 0;
246 result |= ((unsigned long int) (byte & 0x7f)) << shift;
253 if (length_return != NULL)
254 *length_return = num_read;
256 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
257 result |= -1L << shift;
262 typedef struct State_Machine_Registers
264 unsigned long address;
270 unsigned char op_index;
271 unsigned char end_sequence;
272 /* This variable hold the number of the last entry seen
273 in the File Table. */
274 unsigned int last_file_entry;
277 static SMR state_machine_regs;
280 reset_state_machine (int is_stmt)
282 state_machine_regs.address = 0;
283 state_machine_regs.op_index = 0;
284 state_machine_regs.file = 1;
285 state_machine_regs.line = 1;
286 state_machine_regs.column = 0;
287 state_machine_regs.is_stmt = is_stmt;
288 state_machine_regs.basic_block = 0;
289 state_machine_regs.end_sequence = 0;
290 state_machine_regs.last_file_entry = 0;
293 /* Handled an extend line op.
294 Returns the number of bytes read. */
297 process_extended_line_op (unsigned char *data, int is_stmt)
299 unsigned char op_code;
300 unsigned int bytes_read;
305 len = read_leb128 (data, & bytes_read, 0);
310 warn (_("badly formed extended line op encountered!\n"));
317 printf (_(" Extended opcode %d: "), op_code);
321 case DW_LNE_end_sequence:
322 printf (_("End of Sequence\n\n"));
323 reset_state_machine (is_stmt);
326 case DW_LNE_set_address:
327 adr = byte_get (data, len - bytes_read - 1);
328 printf (_("set Address to 0x%lx\n"), adr);
329 state_machine_regs.address = adr;
330 state_machine_regs.op_index = 0;
333 case DW_LNE_define_file:
334 printf (_(" define new File Table entry\n"));
335 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
337 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
339 data += strlen ((char *) data) + 1;
340 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
342 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
344 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
345 printf (_("%s\n\n"), name);
348 case DW_LNE_set_discriminator:
349 printf (_("set Discriminator to %lu\n"),
350 read_leb128 (data, & bytes_read, 0));
354 case DW_LNE_HP_negate_is_UV_update:
355 printf ("DW_LNE_HP_negate_is_UV_update\n");
357 case DW_LNE_HP_push_context:
358 printf ("DW_LNE_HP_push_context\n");
360 case DW_LNE_HP_pop_context:
361 printf ("DW_LNE_HP_pop_context\n");
363 case DW_LNE_HP_set_file_line_column:
364 printf ("DW_LNE_HP_set_file_line_column\n");
366 case DW_LNE_HP_set_routine_name:
367 printf ("DW_LNE_HP_set_routine_name\n");
369 case DW_LNE_HP_set_sequence:
370 printf ("DW_LNE_HP_set_sequence\n");
372 case DW_LNE_HP_negate_post_semantics:
373 printf ("DW_LNE_HP_negate_post_semantics\n");
375 case DW_LNE_HP_negate_function_exit:
376 printf ("DW_LNE_HP_negate_function_exit\n");
378 case DW_LNE_HP_negate_front_end_logical:
379 printf ("DW_LNE_HP_negate_front_end_logical\n");
381 case DW_LNE_HP_define_proc:
382 printf ("DW_LNE_HP_define_proc\n");
386 if (op_code >= DW_LNE_lo_user
387 /* The test against DW_LNW_hi_user is redundant due to
388 the limited range of the unsigned char data type used
390 /*&& op_code <= DW_LNE_hi_user*/)
391 printf (_("user defined: length %d\n"), len - bytes_read);
393 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
401 fetch_indirect_string (unsigned long offset)
403 struct dwarf_section *section = &debug_displays [str].section;
405 if (section->start == NULL)
406 return _("<no .debug_str section>");
408 /* DWARF sections under Mach-O have non-zero addresses. */
409 offset -= section->address;
410 if (offset > section->size)
412 warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
413 return _("<offset is too big>");
416 return (const char *) section->start + offset;
419 /* FIXME: There are better and more efficient ways to handle
420 these structures. For now though, I just want something that
421 is simple to implement. */
422 typedef struct abbrev_attr
424 unsigned long attribute;
426 struct abbrev_attr *next;
430 typedef struct abbrev_entry
435 struct abbrev_attr *first_attr;
436 struct abbrev_attr *last_attr;
437 struct abbrev_entry *next;
441 static abbrev_entry *first_abbrev = NULL;
442 static abbrev_entry *last_abbrev = NULL;
449 for (abbrv = first_abbrev; abbrv;)
451 abbrev_entry *next_abbrev = abbrv->next;
454 for (attr = abbrv->first_attr; attr;)
456 abbrev_attr *next_attr = attr->next;
466 last_abbrev = first_abbrev = NULL;
470 add_abbrev (unsigned long number, unsigned long tag, int children)
474 entry = (abbrev_entry *) malloc (sizeof (*entry));
480 entry->entry = number;
482 entry->children = children;
483 entry->first_attr = NULL;
484 entry->last_attr = NULL;
487 if (first_abbrev == NULL)
488 first_abbrev = entry;
490 last_abbrev->next = entry;
496 add_abbrev_attr (unsigned long attribute, unsigned long form)
500 attr = (abbrev_attr *) malloc (sizeof (*attr));
506 attr->attribute = attribute;
510 if (last_abbrev->first_attr == NULL)
511 last_abbrev->first_attr = attr;
513 last_abbrev->last_attr->next = attr;
515 last_abbrev->last_attr = attr;
518 /* Processes the (partial) contents of a .debug_abbrev section.
519 Returns NULL if the end of the section was encountered.
520 Returns the address after the last byte read if the end of
521 an abbreviation set was found. */
523 static unsigned char *
524 process_abbrev_section (unsigned char *start, unsigned char *end)
526 if (first_abbrev != NULL)
531 unsigned int bytes_read;
534 unsigned long attribute;
537 entry = read_leb128 (start, & bytes_read, 0);
540 /* A single zero is supposed to end the section according
541 to the standard. If there's more, then signal that to
544 return start == end ? NULL : start;
546 tag = read_leb128 (start, & bytes_read, 0);
551 add_abbrev (entry, tag, children);
557 attribute = read_leb128 (start, & bytes_read, 0);
560 form = read_leb128 (start, & bytes_read, 0);
564 add_abbrev_attr (attribute, form);
566 while (attribute != 0);
573 get_TAG_name (unsigned long tag)
577 case DW_TAG_padding: return "DW_TAG_padding";
578 case DW_TAG_array_type: return "DW_TAG_array_type";
579 case DW_TAG_class_type: return "DW_TAG_class_type";
580 case DW_TAG_entry_point: return "DW_TAG_entry_point";
581 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
582 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
583 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
584 case DW_TAG_label: return "DW_TAG_label";
585 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
586 case DW_TAG_member: return "DW_TAG_member";
587 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
588 case DW_TAG_reference_type: return "DW_TAG_reference_type";
589 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
590 case DW_TAG_string_type: return "DW_TAG_string_type";
591 case DW_TAG_structure_type: return "DW_TAG_structure_type";
592 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
593 case DW_TAG_typedef: return "DW_TAG_typedef";
594 case DW_TAG_union_type: return "DW_TAG_union_type";
595 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
596 case DW_TAG_variant: return "DW_TAG_variant";
597 case DW_TAG_common_block: return "DW_TAG_common_block";
598 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
599 case DW_TAG_inheritance: return "DW_TAG_inheritance";
600 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
601 case DW_TAG_module: return "DW_TAG_module";
602 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
603 case DW_TAG_set_type: return "DW_TAG_set_type";
604 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
605 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
606 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
607 case DW_TAG_base_type: return "DW_TAG_base_type";
608 case DW_TAG_catch_block: return "DW_TAG_catch_block";
609 case DW_TAG_const_type: return "DW_TAG_const_type";
610 case DW_TAG_constant: return "DW_TAG_constant";
611 case DW_TAG_enumerator: return "DW_TAG_enumerator";
612 case DW_TAG_file_type: return "DW_TAG_file_type";
613 case DW_TAG_friend: return "DW_TAG_friend";
614 case DW_TAG_namelist: return "DW_TAG_namelist";
615 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
616 case DW_TAG_packed_type: return "DW_TAG_packed_type";
617 case DW_TAG_subprogram: return "DW_TAG_subprogram";
618 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
619 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
620 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
621 case DW_TAG_try_block: return "DW_TAG_try_block";
622 case DW_TAG_variant_part: return "DW_TAG_variant_part";
623 case DW_TAG_variable: return "DW_TAG_variable";
624 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
625 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
626 case DW_TAG_format_label: return "DW_TAG_format_label";
627 case DW_TAG_function_template: return "DW_TAG_function_template";
628 case DW_TAG_class_template: return "DW_TAG_class_template";
629 /* DWARF 2.1 values. */
630 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
631 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
632 case DW_TAG_interface_type: return "DW_TAG_interface_type";
633 case DW_TAG_namespace: return "DW_TAG_namespace";
634 case DW_TAG_imported_module: return "DW_TAG_imported_module";
635 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
636 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
637 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
638 case DW_TAG_condition: return "DW_TAG_condition";
639 case DW_TAG_shared_type: return "DW_TAG_shared_type";
640 /* DWARF 4 values. */
641 case DW_TAG_type_unit: return "DW_TAG_type_unit";
642 case DW_TAG_rvalue_reference_type: return "DW_TAG_rvalue_reference_type";
643 case DW_TAG_template_alias: return "DW_TAG_template_alias";
645 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
646 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
647 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
650 static char buffer[100];
652 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
659 get_FORM_name (unsigned long form)
663 case DW_FORM_addr: return "DW_FORM_addr";
664 case DW_FORM_block2: return "DW_FORM_block2";
665 case DW_FORM_block4: return "DW_FORM_block4";
666 case DW_FORM_data2: return "DW_FORM_data2";
667 case DW_FORM_data4: return "DW_FORM_data4";
668 case DW_FORM_data8: return "DW_FORM_data8";
669 case DW_FORM_string: return "DW_FORM_string";
670 case DW_FORM_block: return "DW_FORM_block";
671 case DW_FORM_block1: return "DW_FORM_block1";
672 case DW_FORM_data1: return "DW_FORM_data1";
673 case DW_FORM_flag: return "DW_FORM_flag";
674 case DW_FORM_sdata: return "DW_FORM_sdata";
675 case DW_FORM_strp: return "DW_FORM_strp";
676 case DW_FORM_udata: return "DW_FORM_udata";
677 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
678 case DW_FORM_ref1: return "DW_FORM_ref1";
679 case DW_FORM_ref2: return "DW_FORM_ref2";
680 case DW_FORM_ref4: return "DW_FORM_ref4";
681 case DW_FORM_ref8: return "DW_FORM_ref8";
682 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
683 case DW_FORM_indirect: return "DW_FORM_indirect";
684 /* DWARF 4 values. */
685 case DW_FORM_sec_offset: return "DW_FORM_sec_offset";
686 case DW_FORM_exprloc: return "DW_FORM_exprloc";
687 case DW_FORM_flag_present: return "DW_FORM_flag_present";
688 case DW_FORM_ref_sig8: return "DW_FORM_ref_sig8";
691 static char buffer[100];
693 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
699 static unsigned char *
700 display_block (unsigned char *data, unsigned long length)
702 printf (_(" %lu byte block: "), length);
705 printf ("%lx ", (unsigned long) byte_get (data++, 1));
711 decode_location_expression (unsigned char * data,
712 unsigned int pointer_size,
713 unsigned long length,
714 unsigned long cu_offset,
715 struct dwarf_section * section)
718 unsigned int bytes_read;
719 unsigned long uvalue;
720 unsigned char *end = data + length;
721 int need_frame_base = 0;
730 printf ("DW_OP_addr: %lx",
731 (unsigned long) byte_get (data, pointer_size));
732 data += pointer_size;
735 printf ("DW_OP_deref");
738 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
741 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
744 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
748 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
752 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
756 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
760 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
761 (unsigned long) byte_get (data + 4, 4));
765 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
766 (long) byte_get (data + 4, 4));
770 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
774 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
778 printf ("DW_OP_dup");
781 printf ("DW_OP_drop");
784 printf ("DW_OP_over");
787 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
790 printf ("DW_OP_swap");
793 printf ("DW_OP_rot");
796 printf ("DW_OP_xderef");
799 printf ("DW_OP_abs");
802 printf ("DW_OP_and");
805 printf ("DW_OP_div");
808 printf ("DW_OP_minus");
811 printf ("DW_OP_mod");
814 printf ("DW_OP_mul");
817 printf ("DW_OP_neg");
820 printf ("DW_OP_not");
826 printf ("DW_OP_plus");
828 case DW_OP_plus_uconst:
829 printf ("DW_OP_plus_uconst: %lu",
830 read_leb128 (data, &bytes_read, 0));
834 printf ("DW_OP_shl");
837 printf ("DW_OP_shr");
840 printf ("DW_OP_shra");
843 printf ("DW_OP_xor");
846 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
868 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
904 printf ("DW_OP_lit%d", op - DW_OP_lit0);
939 printf ("DW_OP_reg%d", op - DW_OP_reg0);
974 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
975 read_leb128 (data, &bytes_read, 1));
980 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
985 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
989 uvalue = read_leb128 (data, &bytes_read, 0);
991 printf ("DW_OP_bregx: %lu %ld", uvalue,
992 read_leb128 (data, &bytes_read, 1));
996 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
999 case DW_OP_deref_size:
1000 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
1002 case DW_OP_xderef_size:
1003 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
1006 printf ("DW_OP_nop");
1009 /* DWARF 3 extensions. */
1010 case DW_OP_push_object_address:
1011 printf ("DW_OP_push_object_address");
1014 /* XXX: Strictly speaking for 64-bit DWARF3 files
1015 this ought to be an 8-byte wide computation. */
1016 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
1020 /* XXX: Strictly speaking for 64-bit DWARF3 files
1021 this ought to be an 8-byte wide computation. */
1022 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
1025 case DW_OP_call_ref:
1026 /* XXX: Strictly speaking for 64-bit DWARF3 files
1027 this ought to be an 8-byte wide computation. */
1028 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
1031 case DW_OP_form_tls_address:
1032 printf ("DW_OP_form_tls_address");
1034 case DW_OP_call_frame_cfa:
1035 printf ("DW_OP_call_frame_cfa");
1037 case DW_OP_bit_piece:
1038 printf ("DW_OP_bit_piece: ");
1039 printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
1041 printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
1045 /* DWARF 4 extensions. */
1046 case DW_OP_stack_value:
1047 printf ("DW_OP_stack_value");
1050 case DW_OP_implicit_value:
1051 printf ("DW_OP_implicit_value");
1052 uvalue = read_leb128 (data, &bytes_read, 0);
1054 display_block (data, uvalue);
1058 /* GNU extensions. */
1059 case DW_OP_GNU_push_tls_address:
1060 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1062 case DW_OP_GNU_uninit:
1063 printf ("DW_OP_GNU_uninit");
1064 /* FIXME: Is there data associated with this OP ? */
1066 case DW_OP_GNU_encoded_addr:
1072 addr = get_encoded_value (data, encoding);
1073 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1074 addr += section->address + (data - section->start);
1075 data += size_of_encoded_value (encoding);
1077 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1078 print_dwarf_vma (addr, pointer_size);
1082 /* HP extensions. */
1083 case DW_OP_HP_is_value:
1084 printf ("DW_OP_HP_is_value");
1085 /* FIXME: Is there data associated with this OP ? */
1087 case DW_OP_HP_fltconst4:
1088 printf ("DW_OP_HP_fltconst4");
1089 /* FIXME: Is there data associated with this OP ? */
1091 case DW_OP_HP_fltconst8:
1092 printf ("DW_OP_HP_fltconst8");
1093 /* FIXME: Is there data associated with this OP ? */
1095 case DW_OP_HP_mod_range:
1096 printf ("DW_OP_HP_mod_range");
1097 /* FIXME: Is there data associated with this OP ? */
1099 case DW_OP_HP_unmod_range:
1100 printf ("DW_OP_HP_unmod_range");
1101 /* FIXME: Is there data associated with this OP ? */
1104 printf ("DW_OP_HP_tls");
1105 /* FIXME: Is there data associated with this OP ? */
1108 /* PGI (STMicroelectronics) extensions. */
1109 case DW_OP_PGI_omp_thread_num:
1110 /* Pushes the thread number for the current thread as it would be
1111 returned by the standard OpenMP library function:
1112 omp_get_thread_num(). The "current thread" is the thread for
1113 which the expression is being evaluated. */
1114 printf ("DW_OP_PGI_omp_thread_num");
1118 if (op >= DW_OP_lo_user
1119 && op <= DW_OP_hi_user)
1120 printf (_("(User defined location op)"));
1122 printf (_("(Unknown location op)"));
1123 /* No way to tell where the next op is, so just bail. */
1124 return need_frame_base;
1127 /* Separate the ops. */
1132 return need_frame_base;
1135 static unsigned char *
1136 read_and_display_attr_value (unsigned long attribute,
1138 unsigned char * data,
1139 unsigned long cu_offset,
1140 unsigned long pointer_size,
1141 unsigned long offset_size,
1143 debug_info * debug_info_p,
1145 struct dwarf_section * section)
1147 unsigned long uvalue = 0;
1148 unsigned char *block_start = NULL;
1149 unsigned char * orig_data = data;
1150 unsigned int bytes_read;
1157 case DW_FORM_ref_addr:
1158 if (dwarf_version == 2)
1160 uvalue = byte_get (data, pointer_size);
1161 data += pointer_size;
1163 else if (dwarf_version == 3 || dwarf_version == 4)
1165 uvalue = byte_get (data, offset_size);
1166 data += offset_size;
1170 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1175 uvalue = byte_get (data, pointer_size);
1176 data += pointer_size;
1180 case DW_FORM_sec_offset:
1181 uvalue = byte_get (data, offset_size);
1182 data += offset_size;
1185 case DW_FORM_flag_present:
1192 uvalue = byte_get (data++, 1);
1197 uvalue = byte_get (data, 2);
1203 uvalue = byte_get (data, 4);
1208 uvalue = read_leb128 (data, & bytes_read, 1);
1212 case DW_FORM_ref_udata:
1214 uvalue = read_leb128 (data, & bytes_read, 0);
1218 case DW_FORM_indirect:
1219 form = read_leb128 (data, & bytes_read, 0);
1222 printf (" %s", get_FORM_name (form));
1223 return read_and_display_attr_value (attribute, form, data,
1224 cu_offset, pointer_size,
1225 offset_size, dwarf_version,
1226 debug_info_p, do_loc,
1232 case DW_FORM_ref_addr:
1234 printf (" <0x%lx>", uvalue);
1240 case DW_FORM_ref_udata:
1242 printf (" <0x%lx>", uvalue + cu_offset);
1247 case DW_FORM_sec_offset:
1249 printf (" 0x%lx", uvalue);
1252 case DW_FORM_flag_present:
1259 printf (" %ld", uvalue);
1266 uvalue = byte_get (data, 4);
1267 printf (" 0x%lx", uvalue);
1268 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1270 if ((do_loc || do_debug_loc || do_debug_ranges)
1271 && num_debug_info_entries == 0)
1273 if (sizeof (uvalue) == 8)
1274 uvalue = byte_get (data, 8);
1276 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1281 case DW_FORM_string:
1283 printf (" %s", data);
1284 data += strlen ((char *) data) + 1;
1288 case DW_FORM_exprloc:
1289 uvalue = read_leb128 (data, & bytes_read, 0);
1290 block_start = data + bytes_read;
1292 data = block_start + uvalue;
1294 data = display_block (block_start, uvalue);
1297 case DW_FORM_block1:
1298 uvalue = byte_get (data, 1);
1299 block_start = data + 1;
1301 data = block_start + uvalue;
1303 data = display_block (block_start, uvalue);
1306 case DW_FORM_block2:
1307 uvalue = byte_get (data, 2);
1308 block_start = data + 2;
1310 data = block_start + uvalue;
1312 data = display_block (block_start, uvalue);
1315 case DW_FORM_block4:
1316 uvalue = byte_get (data, 4);
1317 block_start = data + 4;
1319 data = block_start + uvalue;
1321 data = display_block (block_start, uvalue);
1326 printf (_(" (indirect string, offset: 0x%lx): %s"),
1327 uvalue, fetch_indirect_string (uvalue));
1330 case DW_FORM_indirect:
1331 /* Handled above. */
1334 case DW_FORM_ref_sig8:
1338 printf (" signature: ");
1339 for (i = 0; i < 8; i++)
1341 printf ("%02x", (unsigned) byte_get (data, 1));
1350 warn (_("Unrecognized form: %lu\n"), form);
1354 if ((do_loc || do_debug_loc || do_debug_ranges)
1355 && num_debug_info_entries == 0)
1359 case DW_AT_frame_base:
1360 have_frame_base = 1;
1361 case DW_AT_location:
1362 case DW_AT_string_length:
1363 case DW_AT_return_addr:
1364 case DW_AT_data_member_location:
1365 case DW_AT_vtable_elem_location:
1367 case DW_AT_static_link:
1368 case DW_AT_use_location:
1369 if (form == DW_FORM_data4
1370 || form == DW_FORM_data8
1371 || form == DW_FORM_sec_offset)
1373 /* Process location list. */
1374 unsigned int lmax = debug_info_p->max_loc_offsets;
1375 unsigned int num = debug_info_p->num_loc_offsets;
1377 if (lmax == 0 || num >= lmax)
1380 debug_info_p->loc_offsets = (long unsigned int *)
1381 xcrealloc (debug_info_p->loc_offsets,
1382 lmax, sizeof (*debug_info_p->loc_offsets));
1383 debug_info_p->have_frame_base = (int *)
1384 xcrealloc (debug_info_p->have_frame_base,
1385 lmax, sizeof (*debug_info_p->have_frame_base));
1386 debug_info_p->max_loc_offsets = lmax;
1388 debug_info_p->loc_offsets [num] = uvalue;
1389 debug_info_p->have_frame_base [num] = have_frame_base;
1390 debug_info_p->num_loc_offsets++;
1395 if (need_base_address)
1396 debug_info_p->base_address = uvalue;
1400 if (form == DW_FORM_data4
1401 || form == DW_FORM_data8
1402 || form == DW_FORM_sec_offset)
1404 /* Process range list. */
1405 unsigned int lmax = debug_info_p->max_range_lists;
1406 unsigned int num = debug_info_p->num_range_lists;
1408 if (lmax == 0 || num >= lmax)
1411 debug_info_p->range_lists = (long unsigned int *)
1412 xcrealloc (debug_info_p->range_lists,
1413 lmax, sizeof (*debug_info_p->range_lists));
1414 debug_info_p->max_range_lists = lmax;
1416 debug_info_p->range_lists [num] = uvalue;
1417 debug_info_p->num_range_lists++;
1429 /* For some attributes we can display further information. */
1437 case DW_INL_not_inlined:
1438 printf (_("(not inlined)"));
1440 case DW_INL_inlined:
1441 printf (_("(inlined)"));
1443 case DW_INL_declared_not_inlined:
1444 printf (_("(declared as inline but ignored)"));
1446 case DW_INL_declared_inlined:
1447 printf (_("(declared as inline and inlined)"));
1450 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1455 case DW_AT_language:
1458 /* Ordered by the numeric value of these constants. */
1459 case DW_LANG_C89: printf ("(ANSI C)"); break;
1460 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1461 case DW_LANG_Ada83: printf ("(Ada)"); break;
1462 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1463 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1464 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1465 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1466 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1467 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1468 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1469 /* DWARF 2.1 values. */
1470 case DW_LANG_Java: printf ("(Java)"); break;
1471 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1472 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1473 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1474 /* DWARF 3 values. */
1475 case DW_LANG_PLI: printf ("(PLI)"); break;
1476 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1477 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1478 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1479 case DW_LANG_D: printf ("(D)"); break;
1480 /* DWARF 4 values. */
1481 case DW_LANG_Python: printf ("(Python)"); break;
1482 /* MIPS extension. */
1483 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1484 /* UPC extension. */
1485 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1487 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1488 printf ("(implementation defined: %lx)", uvalue);
1490 printf ("(Unknown: %lx)", uvalue);
1495 case DW_AT_encoding:
1498 case DW_ATE_void: printf ("(void)"); break;
1499 case DW_ATE_address: printf ("(machine address)"); break;
1500 case DW_ATE_boolean: printf ("(boolean)"); break;
1501 case DW_ATE_complex_float: printf ("(complex float)"); break;
1502 case DW_ATE_float: printf ("(float)"); break;
1503 case DW_ATE_signed: printf ("(signed)"); break;
1504 case DW_ATE_signed_char: printf ("(signed char)"); break;
1505 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1506 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1507 /* DWARF 2.1 values: */
1508 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1509 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1510 /* DWARF 3 values: */
1511 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1512 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1513 case DW_ATE_edited: printf ("(edited)"); break;
1514 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1515 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1516 /* HP extensions: */
1517 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1518 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1519 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1520 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1521 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1522 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1523 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1526 if (uvalue >= DW_ATE_lo_user
1527 && uvalue <= DW_ATE_hi_user)
1528 printf ("(user defined type)");
1530 printf ("(unknown type)");
1535 case DW_AT_accessibility:
1538 case DW_ACCESS_public: printf ("(public)"); break;
1539 case DW_ACCESS_protected: printf ("(protected)"); break;
1540 case DW_ACCESS_private: printf ("(private)"); break;
1542 printf ("(unknown accessibility)");
1547 case DW_AT_visibility:
1550 case DW_VIS_local: printf ("(local)"); break;
1551 case DW_VIS_exported: printf ("(exported)"); break;
1552 case DW_VIS_qualified: printf ("(qualified)"); break;
1553 default: printf ("(unknown visibility)"); break;
1557 case DW_AT_virtuality:
1560 case DW_VIRTUALITY_none: printf ("(none)"); break;
1561 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1562 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1563 default: printf ("(unknown virtuality)"); break;
1567 case DW_AT_identifier_case:
1570 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1571 case DW_ID_up_case: printf ("(up_case)"); break;
1572 case DW_ID_down_case: printf ("(down_case)"); break;
1573 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1574 default: printf ("(unknown case)"); break;
1578 case DW_AT_calling_convention:
1581 case DW_CC_normal: printf ("(normal)"); break;
1582 case DW_CC_program: printf ("(program)"); break;
1583 case DW_CC_nocall: printf ("(nocall)"); break;
1585 if (uvalue >= DW_CC_lo_user
1586 && uvalue <= DW_CC_hi_user)
1587 printf ("(user defined)");
1589 printf ("(unknown convention)");
1593 case DW_AT_ordering:
1596 case -1: printf ("(undefined)"); break;
1597 case 0: printf ("(row major)"); break;
1598 case 1: printf ("(column major)"); break;
1602 case DW_AT_frame_base:
1603 have_frame_base = 1;
1604 case DW_AT_location:
1605 case DW_AT_string_length:
1606 case DW_AT_return_addr:
1607 case DW_AT_data_member_location:
1608 case DW_AT_vtable_elem_location:
1610 case DW_AT_static_link:
1611 case DW_AT_use_location:
1612 if (form == DW_FORM_data4
1613 || form == DW_FORM_data8
1614 || form == DW_FORM_sec_offset)
1615 printf (_("(location list)"));
1617 case DW_AT_allocated:
1618 case DW_AT_associated:
1619 case DW_AT_data_location:
1621 case DW_AT_upper_bound:
1622 case DW_AT_lower_bound:
1625 int need_frame_base;
1628 need_frame_base = decode_location_expression (block_start,
1631 cu_offset, section);
1633 if (need_frame_base && !have_frame_base)
1634 printf (_(" [without DW_AT_frame_base]"));
1640 if (form == DW_FORM_ref_sig8)
1643 if (form == DW_FORM_ref1
1644 || form == DW_FORM_ref2
1645 || form == DW_FORM_ref4)
1646 uvalue += cu_offset;
1648 if (uvalue >= section->size)
1649 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1650 uvalue, (unsigned long) (orig_data - section->start));
1653 unsigned long abbrev_number;
1654 abbrev_entry * entry;
1656 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1658 printf ("[Abbrev Number: %ld", abbrev_number);
1659 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1660 if (entry->entry == abbrev_number)
1663 printf (" (%s)", get_TAG_name (entry->tag));
1677 get_AT_name (unsigned long attribute)
1681 case DW_AT_sibling: return "DW_AT_sibling";
1682 case DW_AT_location: return "DW_AT_location";
1683 case DW_AT_name: return "DW_AT_name";
1684 case DW_AT_ordering: return "DW_AT_ordering";
1685 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1686 case DW_AT_byte_size: return "DW_AT_byte_size";
1687 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1688 case DW_AT_bit_size: return "DW_AT_bit_size";
1689 case DW_AT_element_list: return "DW_AT_element_list";
1690 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1691 case DW_AT_low_pc: return "DW_AT_low_pc";
1692 case DW_AT_high_pc: return "DW_AT_high_pc";
1693 case DW_AT_language: return "DW_AT_language";
1694 case DW_AT_member: return "DW_AT_member";
1695 case DW_AT_discr: return "DW_AT_discr";
1696 case DW_AT_discr_value: return "DW_AT_discr_value";
1697 case DW_AT_visibility: return "DW_AT_visibility";
1698 case DW_AT_import: return "DW_AT_import";
1699 case DW_AT_string_length: return "DW_AT_string_length";
1700 case DW_AT_common_reference: return "DW_AT_common_reference";
1701 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1702 case DW_AT_const_value: return "DW_AT_const_value";
1703 case DW_AT_containing_type: return "DW_AT_containing_type";
1704 case DW_AT_default_value: return "DW_AT_default_value";
1705 case DW_AT_inline: return "DW_AT_inline";
1706 case DW_AT_is_optional: return "DW_AT_is_optional";
1707 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1708 case DW_AT_producer: return "DW_AT_producer";
1709 case DW_AT_prototyped: return "DW_AT_prototyped";
1710 case DW_AT_return_addr: return "DW_AT_return_addr";
1711 case DW_AT_start_scope: return "DW_AT_start_scope";
1712 case DW_AT_stride_size: return "DW_AT_stride_size";
1713 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1714 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1715 case DW_AT_accessibility: return "DW_AT_accessibility";
1716 case DW_AT_address_class: return "DW_AT_address_class";
1717 case DW_AT_artificial: return "DW_AT_artificial";
1718 case DW_AT_base_types: return "DW_AT_base_types";
1719 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1720 case DW_AT_count: return "DW_AT_count";
1721 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1722 case DW_AT_decl_column: return "DW_AT_decl_column";
1723 case DW_AT_decl_file: return "DW_AT_decl_file";
1724 case DW_AT_decl_line: return "DW_AT_decl_line";
1725 case DW_AT_declaration: return "DW_AT_declaration";
1726 case DW_AT_discr_list: return "DW_AT_discr_list";
1727 case DW_AT_encoding: return "DW_AT_encoding";
1728 case DW_AT_external: return "DW_AT_external";
1729 case DW_AT_frame_base: return "DW_AT_frame_base";
1730 case DW_AT_friend: return "DW_AT_friend";
1731 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1732 case DW_AT_macro_info: return "DW_AT_macro_info";
1733 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1734 case DW_AT_priority: return "DW_AT_priority";
1735 case DW_AT_segment: return "DW_AT_segment";
1736 case DW_AT_specification: return "DW_AT_specification";
1737 case DW_AT_static_link: return "DW_AT_static_link";
1738 case DW_AT_type: return "DW_AT_type";
1739 case DW_AT_use_location: return "DW_AT_use_location";
1740 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1741 case DW_AT_virtuality: return "DW_AT_virtuality";
1742 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1743 /* DWARF 2.1 values. */
1744 case DW_AT_allocated: return "DW_AT_allocated";
1745 case DW_AT_associated: return "DW_AT_associated";
1746 case DW_AT_data_location: return "DW_AT_data_location";
1747 case DW_AT_stride: return "DW_AT_stride";
1748 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1749 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1750 case DW_AT_extension: return "DW_AT_extension";
1751 case DW_AT_ranges: return "DW_AT_ranges";
1752 case DW_AT_trampoline: return "DW_AT_trampoline";
1753 case DW_AT_call_column: return "DW_AT_call_column";
1754 case DW_AT_call_file: return "DW_AT_call_file";
1755 case DW_AT_call_line: return "DW_AT_call_line";
1756 case DW_AT_description: return "DW_AT_description";
1757 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1758 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1759 case DW_AT_small: return "DW_AT_small";
1760 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1761 case DW_AT_digit_count: return "DW_AT_digit_count";
1762 case DW_AT_picture_string: return "DW_AT_picture_string";
1763 case DW_AT_mutable: return "DW_AT_mutable";
1764 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1765 case DW_AT_explicit: return "DW_AT_explicit";
1766 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1767 case DW_AT_endianity: return "DW_AT_endianity";
1768 case DW_AT_elemental: return "DW_AT_elemental";
1769 case DW_AT_pure: return "DW_AT_pure";
1770 case DW_AT_recursive: return "DW_AT_recursive";
1771 /* DWARF 4 values. */
1772 case DW_AT_signature: return "DW_AT_signature";
1773 case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
1774 case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
1775 case DW_AT_const_expr: return "DW_AT_const_expr";
1776 case DW_AT_enum_class: return "DW_AT_enum_class";
1777 case DW_AT_linkage_name: return "DW_AT_linkage_name";
1779 /* HP and SGI/MIPS extensions. */
1780 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1781 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1782 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1783 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1784 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1785 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1786 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1787 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1788 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1789 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1791 /* HP Extensions. */
1792 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1793 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1794 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1795 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1796 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1797 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1798 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1799 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1800 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1801 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1802 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1803 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1804 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1806 /* One value is shared by the MIPS and HP extensions: */
1807 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1809 /* GNU extensions. */
1810 case DW_AT_sf_names: return "DW_AT_sf_names";
1811 case DW_AT_src_info: return "DW_AT_src_info";
1812 case DW_AT_mac_info: return "DW_AT_mac_info";
1813 case DW_AT_src_coords: return "DW_AT_src_coords";
1814 case DW_AT_body_begin: return "DW_AT_body_begin";
1815 case DW_AT_body_end: return "DW_AT_body_end";
1816 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1817 case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
1818 case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
1819 case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
1820 case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
1821 case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
1822 case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
1823 case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
1824 case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
1825 case DW_AT_use_GNAT_descriptive_type: return "DW_AT_use_GNAT_descriptive_type";
1826 case DW_AT_GNAT_descriptive_type: return "DW_AT_GNAT_descriptive_type";
1828 /* UPC extension. */
1829 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1831 /* PGI (STMicroelectronics) extensions. */
1832 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1833 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1834 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1838 static char buffer[100];
1840 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1847 static unsigned char *
1848 read_and_display_attr (unsigned long attribute,
1850 unsigned char * data,
1851 unsigned long cu_offset,
1852 unsigned long pointer_size,
1853 unsigned long offset_size,
1855 debug_info * debug_info_p,
1857 struct dwarf_section * section)
1860 printf (" %-18s:", get_AT_name (attribute));
1861 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1862 pointer_size, offset_size,
1863 dwarf_version, debug_info_p,
1871 /* Process the contents of a .debug_info section. If do_loc is non-zero
1872 then we are scanning for location lists and we do not want to display
1873 anything to the user. If do_types is non-zero, we are processing
1874 a .debug_types section instead of a .debug_info section. */
1877 process_debug_info (struct dwarf_section *section,
1879 enum dwarf_section_display_enum abbrev_sec,
1883 unsigned char *start = section->start;
1884 unsigned char *end = start + section->size;
1885 unsigned char *section_begin;
1887 unsigned int num_units = 0;
1889 if ((do_loc || do_debug_loc || do_debug_ranges)
1890 && num_debug_info_entries == 0
1893 unsigned long length;
1895 /* First scan the section to get the number of comp units. */
1896 for (section_begin = start, num_units = 0; section_begin < end;
1899 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1900 will be the length. For a 64-bit DWARF section, it'll be
1901 the escape code 0xffffffff followed by an 8 byte length. */
1902 length = byte_get (section_begin, 4);
1904 if (length == 0xffffffff)
1906 length = byte_get (section_begin + 4, 8);
1907 section_begin += length + 12;
1909 else if (length >= 0xfffffff0 && length < 0xffffffff)
1911 warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1915 section_begin += length + 4;
1917 /* Negative values are illegal, they may even cause infinite
1918 looping. This can happen if we can't accurately apply
1919 relocations to an object file. */
1920 if ((signed long) length <= 0)
1922 warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1929 error (_("No comp units in %s section ?"), section->name);
1933 /* Then allocate an array to hold the information. */
1934 debug_information = (debug_info *) cmalloc (num_units,
1935 sizeof (* debug_information));
1936 if (debug_information == NULL)
1938 error (_("Not enough memory for a debug info array of %u entries"),
1946 printf (_("Contents of the %s section:\n\n"), section->name);
1948 load_debug_section (str, file);
1951 load_debug_section (abbrev_sec, file);
1952 if (debug_displays [abbrev_sec].section.start == NULL)
1954 warn (_("Unable to locate %s section!\n"),
1955 debug_displays [abbrev_sec].section.name);
1959 for (section_begin = start, unit = 0; start < end; unit++)
1961 DWARF2_Internal_CompUnit compunit;
1962 unsigned char *hdrptr;
1963 unsigned char *tags;
1965 unsigned long cu_offset;
1967 int initial_length_size;
1968 unsigned char signature[8] = { 0 };
1969 unsigned long type_offset = 0;
1973 compunit.cu_length = byte_get (hdrptr, 4);
1976 if (compunit.cu_length == 0xffffffff)
1978 compunit.cu_length = byte_get (hdrptr, 8);
1981 initial_length_size = 12;
1986 initial_length_size = 4;
1989 compunit.cu_version = byte_get (hdrptr, 2);
1992 cu_offset = start - section_begin;
1994 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1995 hdrptr += offset_size;
1997 compunit.cu_pointer_size = byte_get (hdrptr, 1);
2004 for (i = 0; i < 8; i++)
2006 signature[i] = byte_get (hdrptr, 1);
2010 type_offset = byte_get (hdrptr, offset_size);
2011 hdrptr += offset_size;
2014 if ((do_loc || do_debug_loc || do_debug_ranges)
2015 && num_debug_info_entries == 0
2018 debug_information [unit].cu_offset = cu_offset;
2019 debug_information [unit].pointer_size
2020 = compunit.cu_pointer_size;
2021 debug_information [unit].base_address = 0;
2022 debug_information [unit].loc_offsets = NULL;
2023 debug_information [unit].have_frame_base = NULL;
2024 debug_information [unit].max_loc_offsets = 0;
2025 debug_information [unit].num_loc_offsets = 0;
2026 debug_information [unit].range_lists = NULL;
2027 debug_information [unit].max_range_lists= 0;
2028 debug_information [unit].num_range_lists = 0;
2033 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
2034 printf (_(" Length: 0x%lx (%s)\n"), compunit.cu_length,
2035 initial_length_size == 8 ? "64-bit" : "32-bit");
2036 printf (_(" Version: %d\n"), compunit.cu_version);
2037 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
2038 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2042 printf (_(" Signature: "));
2043 for (i = 0; i < 8; i++)
2044 printf ("%02x", signature[i]);
2046 printf (_(" Type Offset: 0x%lx\n"), type_offset);
2050 if (cu_offset + compunit.cu_length + initial_length_size
2053 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
2054 cu_offset, compunit.cu_length);
2058 start += compunit.cu_length + initial_length_size;
2060 if (compunit.cu_version != 2
2061 && compunit.cu_version != 3
2062 && compunit.cu_version != 4)
2064 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
2065 cu_offset, compunit.cu_version);
2071 /* Process the abbrevs used by this compilation unit. DWARF
2072 sections under Mach-O have non-zero addresses. */
2073 if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2074 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2075 (unsigned long) compunit.cu_abbrev_offset,
2076 (unsigned long) debug_displays [abbrev_sec].section.size);
2078 process_abbrev_section
2079 ((unsigned char *) debug_displays [abbrev_sec].section.start
2080 + compunit.cu_abbrev_offset,
2081 (unsigned char *) debug_displays [abbrev_sec].section.start
2082 + debug_displays [abbrev_sec].section.size);
2085 while (tags < start)
2087 unsigned int bytes_read;
2088 unsigned long abbrev_number;
2089 unsigned long die_offset;
2090 abbrev_entry *entry;
2093 die_offset = tags - section_begin;
2095 abbrev_number = read_leb128 (tags, & bytes_read, 0);
2098 /* A null DIE marks the end of a list of siblings or it may also be
2099 a section padding. */
2100 if (abbrev_number == 0)
2102 /* Check if it can be a section padding for the last CU. */
2103 if (level == 0 && start == end)
2107 for (chk = tags; chk < start; chk++)
2117 static unsigned num_bogus_warns = 0;
2119 if (num_bogus_warns < 3)
2121 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2124 if (num_bogus_warns == 3)
2125 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2132 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2133 level, die_offset, abbrev_number);
2135 /* Scan through the abbreviation list until we reach the
2137 for (entry = first_abbrev;
2138 entry && entry->entry != abbrev_number;
2139 entry = entry->next)
2149 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2150 die_offset, abbrev_number);
2155 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
2160 need_base_address = 0;
2162 case DW_TAG_compile_unit:
2163 need_base_address = 1;
2165 case DW_TAG_entry_point:
2166 case DW_TAG_subprogram:
2167 need_base_address = 0;
2168 /* Assuming that there is no DW_AT_frame_base. */
2169 have_frame_base = 0;
2173 for (attr = entry->first_attr; attr; attr = attr->next)
2176 /* Show the offset from where the tag was extracted. */
2177 printf (" <%2lx>", (unsigned long)(tags - section_begin));
2179 tags = read_and_display_attr (attr->attribute,
2182 compunit.cu_pointer_size,
2184 compunit.cu_version,
2185 debug_information + unit,
2189 if (entry->children)
2194 /* Set num_debug_info_entries here so that it can be used to check if
2195 we need to process .debug_loc and .debug_ranges sections. */
2196 if ((do_loc || do_debug_loc || do_debug_ranges)
2197 && num_debug_info_entries == 0
2199 num_debug_info_entries = num_units;
2209 /* Locate and scan the .debug_info section in the file and record the pointer
2210 sizes and offsets for the compilation units in it. Usually an executable
2211 will have just one pointer size, but this is not guaranteed, and so we try
2212 not to make any assumptions. Returns zero upon failure, or the number of
2213 compilation units upon success. */
2216 load_debug_info (void * file)
2218 /* Reset the last pointer size so that we can issue correct error
2219 messages if we are displaying the contents of more than one section. */
2220 last_pointer_size = 0;
2221 warned_about_missing_comp_units = FALSE;
2223 /* If we have already tried and failed to load the .debug_info
2224 section then do not bother to repear the task. */
2225 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2228 /* If we already have the information there is nothing else to do. */
2229 if (num_debug_info_entries > 0)
2230 return num_debug_info_entries;
2232 if (load_debug_section (info, file)
2233 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2234 return num_debug_info_entries;
2236 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2241 display_debug_lines_raw (struct dwarf_section *section,
2242 unsigned char *data,
2245 unsigned char *start = section->start;
2247 printf (_("Raw dump of debug contents of section %s:\n\n"),
2252 DWARF2_Internal_LineInfo linfo;
2253 unsigned char *standard_opcodes;
2254 unsigned char *end_of_sequence;
2255 unsigned char *hdrptr;
2256 unsigned long hdroff;
2257 int initial_length_size;
2262 hdroff = hdrptr - start;
2264 /* Check the length of the block. */
2265 linfo.li_length = byte_get (hdrptr, 4);
2268 if (linfo.li_length == 0xffffffff)
2270 /* This section is 64-bit DWARF 3. */
2271 linfo.li_length = byte_get (hdrptr, 8);
2274 initial_length_size = 12;
2279 initial_length_size = 4;
2282 if (linfo.li_length + initial_length_size > section->size)
2285 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2290 /* Check its version number. */
2291 linfo.li_version = byte_get (hdrptr, 2);
2293 if (linfo.li_version != 2
2294 && linfo.li_version != 3
2295 && linfo.li_version != 4)
2297 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2301 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2302 hdrptr += offset_size;
2303 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2305 if (linfo.li_version >= 4)
2307 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2309 if (linfo.li_max_ops_per_insn == 0)
2311 warn (_("Invalid maximum operations per insn.\n"));
2316 linfo.li_max_ops_per_insn = 1;
2317 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2319 linfo.li_line_base = byte_get (hdrptr, 1);
2321 linfo.li_line_range = byte_get (hdrptr, 1);
2323 linfo.li_opcode_base = byte_get (hdrptr, 1);
2326 /* Sign extend the line base field. */
2327 linfo.li_line_base <<= 24;
2328 linfo.li_line_base >>= 24;
2330 printf (_(" Offset: 0x%lx\n"), hdroff);
2331 printf (_(" Length: %ld\n"), linfo.li_length);
2332 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2333 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2334 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2335 if (linfo.li_version >= 4)
2336 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2337 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2338 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2339 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2340 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2342 end_of_sequence = data + linfo.li_length + initial_length_size;
2344 reset_state_machine (linfo.li_default_is_stmt);
2346 /* Display the contents of the Opcodes table. */
2347 standard_opcodes = hdrptr;
2349 printf (_("\n Opcodes:\n"));
2351 for (i = 1; i < linfo.li_opcode_base; i++)
2352 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2354 /* Display the contents of the Directory table. */
2355 data = standard_opcodes + linfo.li_opcode_base - 1;
2358 printf (_("\n The Directory Table is empty.\n"));
2361 printf (_("\n The Directory Table:\n"));
2365 printf (_(" %s\n"), data);
2367 data += strlen ((char *) data) + 1;
2371 /* Skip the NUL at the end of the table. */
2374 /* Display the contents of the File Name table. */
2376 printf (_("\n The File Name Table is empty.\n"));
2379 printf (_("\n The File Name Table:\n"));
2380 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2384 unsigned char *name;
2385 unsigned int bytes_read;
2387 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
2390 data += strlen ((char *) data) + 1;
2392 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2394 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2396 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2398 printf (_("%s\n"), name);
2402 /* Skip the NUL at the end of the table. */
2405 /* Now display the statements. */
2406 printf (_("\n Line Number Statements:\n"));
2408 while (data < end_of_sequence)
2410 unsigned char op_code;
2412 unsigned long int uladv;
2413 unsigned int bytes_read;
2417 if (op_code >= linfo.li_opcode_base)
2419 op_code -= linfo.li_opcode_base;
2420 uladv = (op_code / linfo.li_line_range);
2421 if (linfo.li_max_ops_per_insn == 1)
2423 uladv *= linfo.li_min_insn_length;
2424 state_machine_regs.address += uladv;
2425 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2426 op_code, uladv, state_machine_regs.address);
2430 state_machine_regs.address
2431 += ((state_machine_regs.op_index + uladv)
2432 / linfo.li_max_ops_per_insn)
2433 * linfo.li_min_insn_length;
2434 state_machine_regs.op_index
2435 = (state_machine_regs.op_index + uladv)
2436 % linfo.li_max_ops_per_insn;
2437 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx[%d]"),
2438 op_code, uladv, state_machine_regs.address,
2439 state_machine_regs.op_index);
2441 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2442 state_machine_regs.line += adv;
2443 printf (_(" and Line by %d to %d\n"),
2444 adv, state_machine_regs.line);
2446 else switch (op_code)
2448 case DW_LNS_extended_op:
2449 data += process_extended_line_op (data, linfo.li_default_is_stmt);
2453 printf (_(" Copy\n"));
2456 case DW_LNS_advance_pc:
2457 uladv = read_leb128 (data, & bytes_read, 0);
2459 if (linfo.li_max_ops_per_insn == 1)
2461 uladv *= linfo.li_min_insn_length;
2462 state_machine_regs.address += uladv;
2463 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
2464 state_machine_regs.address);
2468 state_machine_regs.address
2469 += ((state_machine_regs.op_index + uladv)
2470 / linfo.li_max_ops_per_insn)
2471 * linfo.li_min_insn_length;
2472 state_machine_regs.op_index
2473 = (state_machine_regs.op_index + uladv)
2474 % linfo.li_max_ops_per_insn;
2475 printf (_(" Advance PC by %lu to 0x%lx[%d]\n"), uladv,
2476 state_machine_regs.address,
2477 state_machine_regs.op_index);
2481 case DW_LNS_advance_line:
2482 adv = read_leb128 (data, & bytes_read, 1);
2484 state_machine_regs.line += adv;
2485 printf (_(" Advance Line by %d to %d\n"), adv,
2486 state_machine_regs.line);
2489 case DW_LNS_set_file:
2490 adv = read_leb128 (data, & bytes_read, 0);
2492 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2494 state_machine_regs.file = adv;
2497 case DW_LNS_set_column:
2498 uladv = read_leb128 (data, & bytes_read, 0);
2500 printf (_(" Set column to %lu\n"), uladv);
2501 state_machine_regs.column = uladv;
2504 case DW_LNS_negate_stmt:
2505 adv = state_machine_regs.is_stmt;
2507 printf (_(" Set is_stmt to %d\n"), adv);
2508 state_machine_regs.is_stmt = adv;
2511 case DW_LNS_set_basic_block:
2512 printf (_(" Set basic block\n"));
2513 state_machine_regs.basic_block = 1;
2516 case DW_LNS_const_add_pc:
2517 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2518 if (linfo.li_max_ops_per_insn)
2520 uladv *= linfo.li_min_insn_length;
2521 state_machine_regs.address += uladv;
2522 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2523 state_machine_regs.address);
2527 state_machine_regs.address
2528 += ((state_machine_regs.op_index + uladv)
2529 / linfo.li_max_ops_per_insn)
2530 * linfo.li_min_insn_length;
2531 state_machine_regs.op_index
2532 = (state_machine_regs.op_index + uladv)
2533 % linfo.li_max_ops_per_insn;
2534 printf (_(" Advance PC by constant %lu to 0x%lx[%d]\n"),
2535 uladv, state_machine_regs.address,
2536 state_machine_regs.op_index);
2540 case DW_LNS_fixed_advance_pc:
2541 uladv = byte_get (data, 2);
2543 state_machine_regs.address += uladv;
2544 state_machine_regs.op_index = 0;
2545 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2546 uladv, state_machine_regs.address);
2549 case DW_LNS_set_prologue_end:
2550 printf (_(" Set prologue_end to true\n"));
2553 case DW_LNS_set_epilogue_begin:
2554 printf (_(" Set epilogue_begin to true\n"));
2557 case DW_LNS_set_isa:
2558 uladv = read_leb128 (data, & bytes_read, 0);
2560 printf (_(" Set ISA to %lu\n"), uladv);
2564 printf (_(" Unknown opcode %d with operands: "), op_code);
2566 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2568 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2569 i == 1 ? "" : ", ");
2584 unsigned char *name;
2585 unsigned int directory_index;
2586 unsigned int modification_date;
2587 unsigned int length;
2590 /* Output a decoded representation of the .debug_line section. */
2593 display_debug_lines_decoded (struct dwarf_section *section,
2594 unsigned char *data,
2597 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2602 /* This loop amounts to one iteration per compilation unit. */
2603 DWARF2_Internal_LineInfo linfo;
2604 unsigned char *standard_opcodes;
2605 unsigned char *end_of_sequence;
2606 unsigned char *hdrptr;
2607 int initial_length_size;
2610 File_Entry *file_table = NULL;
2611 unsigned char **directory_table = NULL;
2615 /* Extract information from the Line Number Program Header.
2616 (section 6.2.4 in the Dwarf3 doc). */
2618 /* Get the length of this CU's line number information block. */
2619 linfo.li_length = byte_get (hdrptr, 4);
2622 if (linfo.li_length == 0xffffffff)
2624 /* This section is 64-bit DWARF 3. */
2625 linfo.li_length = byte_get (hdrptr, 8);
2628 initial_length_size = 12;
2633 initial_length_size = 4;
2636 if (linfo.li_length + initial_length_size > section->size)
2638 warn (_("The line info appears to be corrupt - "
2639 "the section is too small\n"));
2643 /* Get this CU's Line Number Block version number. */
2644 linfo.li_version = byte_get (hdrptr, 2);
2646 if (linfo.li_version != 2
2647 && linfo.li_version != 3
2648 && linfo.li_version != 4)
2650 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2655 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2656 hdrptr += offset_size;
2657 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2659 if (linfo.li_version >= 4)
2661 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2663 if (linfo.li_max_ops_per_insn == 0)
2665 warn (_("Invalid maximum operations per insn.\n"));
2670 linfo.li_max_ops_per_insn = 1;
2671 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2673 linfo.li_line_base = byte_get (hdrptr, 1);
2675 linfo.li_line_range = byte_get (hdrptr, 1);
2677 linfo.li_opcode_base = byte_get (hdrptr, 1);
2680 /* Sign extend the line base field. */
2681 linfo.li_line_base <<= 24;
2682 linfo.li_line_base >>= 24;
2684 /* Find the end of this CU's Line Number Information Block. */
2685 end_of_sequence = data + linfo.li_length + initial_length_size;
2687 reset_state_machine (linfo.li_default_is_stmt);
2689 /* Save a pointer to the contents of the Opcodes table. */
2690 standard_opcodes = hdrptr;
2692 /* Traverse the Directory table just to count entries. */
2693 data = standard_opcodes + linfo.li_opcode_base - 1;
2696 unsigned int n_directories = 0;
2697 unsigned char *ptr_directory_table = data;
2701 data += strlen ((char *) data) + 1;
2705 /* Go through the directory table again to save the directories. */
2706 directory_table = (unsigned char **)
2707 xmalloc (n_directories * sizeof (unsigned char *));
2710 while (*ptr_directory_table != 0)
2712 directory_table[i] = ptr_directory_table;
2713 ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2717 /* Skip the NUL at the end of the table. */
2720 /* Traverse the File Name table just to count the entries. */
2723 unsigned int n_files = 0;
2724 unsigned char *ptr_file_name_table = data;
2728 unsigned int bytes_read;
2730 /* Skip Name, directory index, last modification time and length
2732 data += strlen ((char *) data) + 1;
2733 read_leb128 (data, & bytes_read, 0);
2735 read_leb128 (data, & bytes_read, 0);
2737 read_leb128 (data, & bytes_read, 0);
2743 /* Go through the file table again to save the strings. */
2744 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2747 while (*ptr_file_name_table != 0)
2749 unsigned int bytes_read;
2751 file_table[i].name = ptr_file_name_table;
2752 ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2754 /* We are not interested in directory, time or size. */
2755 file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2757 ptr_file_name_table += bytes_read;
2758 file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2760 ptr_file_name_table += bytes_read;
2761 file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2762 ptr_file_name_table += bytes_read;
2767 /* Print the Compilation Unit's name and a header. */
2768 if (directory_table == NULL)
2770 printf (_("CU: %s:\n"), file_table[0].name);
2771 printf (_("File name Line number Starting address\n"));
2775 if (do_wide || strlen ((char *) directory_table[0]) < 76)
2777 printf (_("CU: %s/%s:\n"), directory_table[0],
2778 file_table[0].name);
2782 printf (_("%s:\n"), file_table[0].name);
2784 printf (_("File name Line number Starting address\n"));
2788 /* Skip the NUL at the end of the table. */
2791 /* This loop iterates through the Dwarf Line Number Program. */
2792 while (data < end_of_sequence)
2794 unsigned char op_code;
2796 unsigned long int uladv;
2797 unsigned int bytes_read;
2798 int is_special_opcode = 0;
2802 if (op_code >= linfo.li_opcode_base)
2804 op_code -= linfo.li_opcode_base;
2805 uladv = (op_code / linfo.li_line_range);
2806 if (linfo.li_max_ops_per_insn == 1)
2808 uladv *= linfo.li_min_insn_length;
2809 state_machine_regs.address += uladv;
2813 state_machine_regs.address
2814 += ((state_machine_regs.op_index + uladv)
2815 / linfo.li_max_ops_per_insn)
2816 * linfo.li_min_insn_length;
2817 state_machine_regs.op_index
2818 = (state_machine_regs.op_index + uladv)
2819 % linfo.li_max_ops_per_insn;
2822 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2823 state_machine_regs.line += adv;
2824 is_special_opcode = 1;
2826 else switch (op_code)
2828 case DW_LNS_extended_op:
2830 unsigned int ext_op_code_len;
2831 unsigned char ext_op_code;
2832 unsigned char *op_code_data = data;
2834 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
2835 op_code_data += bytes_read;
2837 if (ext_op_code_len == 0)
2839 warn (_("badly formed extended line op encountered!\n"));
2842 ext_op_code_len += bytes_read;
2843 ext_op_code = *op_code_data++;
2845 switch (ext_op_code)
2847 case DW_LNE_end_sequence:
2848 reset_state_machine (linfo.li_default_is_stmt);
2850 case DW_LNE_set_address:
2851 state_machine_regs.address =
2852 byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
2853 state_machine_regs.op_index = 0;
2855 case DW_LNE_define_file:
2857 unsigned int dir_index = 0;
2859 ++state_machine_regs.last_file_entry;
2860 op_code_data += strlen ((char *) op_code_data) + 1;
2861 dir_index = read_leb128 (op_code_data, & bytes_read, 0);
2862 op_code_data += bytes_read;
2863 read_leb128 (op_code_data, & bytes_read, 0);
2864 op_code_data += bytes_read;
2865 read_leb128 (op_code_data, & bytes_read, 0);
2867 printf (_("%s:\n"), directory_table[dir_index]);
2871 printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
2874 data += ext_op_code_len;
2880 case DW_LNS_advance_pc:
2881 uladv = read_leb128 (data, & bytes_read, 0);
2883 if (linfo.li_max_ops_per_insn == 1)
2885 uladv *= linfo.li_min_insn_length;
2886 state_machine_regs.address += uladv;
2890 state_machine_regs.address
2891 += ((state_machine_regs.op_index + uladv)
2892 / linfo.li_max_ops_per_insn)
2893 * linfo.li_min_insn_length;
2894 state_machine_regs.op_index
2895 = (state_machine_regs.op_index + uladv)
2896 % linfo.li_max_ops_per_insn;
2900 case DW_LNS_advance_line:
2901 adv = read_leb128 (data, & bytes_read, 1);
2903 state_machine_regs.line += adv;
2906 case DW_LNS_set_file:
2907 adv = read_leb128 (data, & bytes_read, 0);
2909 state_machine_regs.file = adv;
2910 if (file_table[state_machine_regs.file - 1].directory_index == 0)
2912 /* If directory index is 0, that means current directory. */
2913 printf (_("\n./%s:[++]\n"),
2914 file_table[state_machine_regs.file - 1].name);
2918 /* The directory index starts counting at 1. */
2919 printf (_("\n%s/%s:\n"),
2920 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
2921 file_table[state_machine_regs.file - 1].name);
2925 case DW_LNS_set_column:
2926 uladv = read_leb128 (data, & bytes_read, 0);
2928 state_machine_regs.column = uladv;
2931 case DW_LNS_negate_stmt:
2932 adv = state_machine_regs.is_stmt;
2934 state_machine_regs.is_stmt = adv;
2937 case DW_LNS_set_basic_block:
2938 state_machine_regs.basic_block = 1;
2941 case DW_LNS_const_add_pc:
2942 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2943 if (linfo.li_max_ops_per_insn == 1)
2945 uladv *= linfo.li_min_insn_length;
2946 state_machine_regs.address += uladv;
2950 state_machine_regs.address
2951 += ((state_machine_regs.op_index + uladv)
2952 / linfo.li_max_ops_per_insn)
2953 * linfo.li_min_insn_length;
2954 state_machine_regs.op_index
2955 = (state_machine_regs.op_index + uladv)
2956 % linfo.li_max_ops_per_insn;
2960 case DW_LNS_fixed_advance_pc:
2961 uladv = byte_get (data, 2);
2963 state_machine_regs.address += uladv;
2964 state_machine_regs.op_index = 0;
2967 case DW_LNS_set_prologue_end:
2970 case DW_LNS_set_epilogue_begin:
2973 case DW_LNS_set_isa:
2974 uladv = read_leb128 (data, & bytes_read, 0);
2976 printf (_(" Set ISA to %lu\n"), uladv);
2980 printf (_(" Unknown opcode %d with operands: "), op_code);
2982 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2984 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2985 i == 1 ? "" : ", ");
2992 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2993 to the DWARF address/line matrix. */
2994 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
2995 || (op_code == DW_LNS_copy))
2997 const unsigned int MAX_FILENAME_LENGTH = 35;
2998 char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
2999 char *newFileName = NULL;
3000 size_t fileNameLength = strlen (fileName);
3002 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3004 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3005 /* Truncate file name */
3006 strncpy (newFileName,
3007 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3008 MAX_FILENAME_LENGTH + 1);
3012 newFileName = (char *) xmalloc (fileNameLength + 1);
3013 strncpy (newFileName, fileName, fileNameLength + 1);
3016 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3018 if (linfo.li_max_ops_per_insn == 1)
3019 printf (_("%-35s %11d %#18lx\n"), newFileName,
3020 state_machine_regs.line,
3021 state_machine_regs.address);
3023 printf (_("%-35s %11d %#18lx[%d]\n"), newFileName,
3024 state_machine_regs.line,
3025 state_machine_regs.address,
3026 state_machine_regs.op_index);
3030 if (linfo.li_max_ops_per_insn == 1)
3031 printf (_("%s %11d %#18lx\n"), newFileName,
3032 state_machine_regs.line,
3033 state_machine_regs.address);
3035 printf (_("%s %11d %#18lx[%d]\n"), newFileName,
3036 state_machine_regs.line,
3037 state_machine_regs.address,
3038 state_machine_regs.op_index);
3041 if (op_code == DW_LNE_end_sequence)
3049 free (directory_table);
3050 directory_table = NULL;
3058 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3060 unsigned char *data = section->start;
3061 unsigned char *end = data + section->size;
3063 int retValDecoded = 1;
3065 if (do_debug_lines == 0)
3066 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3068 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3069 retValRaw = display_debug_lines_raw (section, data, end);
3071 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3072 retValDecoded = display_debug_lines_decoded (section, data, end);
3074 if (!retValRaw || !retValDecoded)
3081 find_debug_info_for_offset (unsigned long offset)
3085 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3088 for (i = 0; i < num_debug_info_entries; i++)
3089 if (debug_information[i].cu_offset == offset)
3090 return debug_information + i;
3096 display_debug_pubnames (struct dwarf_section *section,
3097 void *file ATTRIBUTE_UNUSED)
3099 DWARF2_Internal_PubNames names;
3100 unsigned char *start = section->start;
3101 unsigned char *end = start + section->size;
3103 /* It does not matter if this load fails,
3104 we test for that later on. */
3105 load_debug_info (file);
3107 printf (_("Contents of the %s section:\n\n"), section->name);
3111 unsigned char *data;
3112 unsigned long offset;
3113 int offset_size, initial_length_size;
3117 names.pn_length = byte_get (data, 4);
3119 if (names.pn_length == 0xffffffff)
3121 names.pn_length = byte_get (data, 8);
3124 initial_length_size = 12;
3129 initial_length_size = 4;
3132 names.pn_version = byte_get (data, 2);
3135 names.pn_offset = byte_get (data, offset_size);
3136 data += offset_size;
3138 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3139 && num_debug_info_entries > 0
3140 && find_debug_info_for_offset (names.pn_offset) == NULL)
3141 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3142 names.pn_offset, section->name);
3144 names.pn_size = byte_get (data, offset_size);
3145 data += offset_size;
3147 start += names.pn_length + initial_length_size;
3149 if (names.pn_version != 2 && names.pn_version != 3)
3151 static int warned = 0;
3155 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3162 printf (_(" Length: %ld\n"),
3164 printf (_(" Version: %d\n"),
3166 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3168 printf (_(" Size of area in .debug_info section: %ld\n"),
3171 printf (_("\n Offset\tName\n"));
3175 offset = byte_get (data, offset_size);
3179 data += offset_size;
3180 printf (" %-6lx\t%s\n", offset, data);
3181 data += strlen ((char *) data) + 1;
3184 while (offset != 0);
3192 display_debug_macinfo (struct dwarf_section *section,
3193 void *file ATTRIBUTE_UNUSED)
3195 unsigned char *start = section->start;
3196 unsigned char *end = start + section->size;
3197 unsigned char *curr = start;
3198 unsigned int bytes_read;
3199 enum dwarf_macinfo_record_type op;
3201 printf (_("Contents of the %s section:\n\n"), section->name);
3205 unsigned int lineno;
3208 op = (enum dwarf_macinfo_record_type) *curr;
3213 case DW_MACINFO_start_file:
3215 unsigned int filenum;
3217 lineno = read_leb128 (curr, & bytes_read, 0);
3219 filenum = read_leb128 (curr, & bytes_read, 0);
3222 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3227 case DW_MACINFO_end_file:
3228 printf (_(" DW_MACINFO_end_file\n"));
3231 case DW_MACINFO_define:
3232 lineno = read_leb128 (curr, & bytes_read, 0);
3234 string = (char *) curr;
3235 curr += strlen (string) + 1;
3236 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3240 case DW_MACINFO_undef:
3241 lineno = read_leb128 (curr, & bytes_read, 0);
3243 string = (char *) curr;
3244 curr += strlen (string) + 1;
3245 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3249 case DW_MACINFO_vendor_ext:
3251 unsigned int constant;
3253 constant = read_leb128 (curr, & bytes_read, 0);
3255 string = (char *) curr;
3256 curr += strlen (string) + 1;
3257 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3268 display_debug_abbrev (struct dwarf_section *section,
3269 void *file ATTRIBUTE_UNUSED)
3271 abbrev_entry *entry;
3272 unsigned char *start = section->start;
3273 unsigned char *end = start + section->size;
3275 printf (_("Contents of the %s section:\n\n"), section->name);
3281 start = process_abbrev_section (start, end);
3283 if (first_abbrev == NULL)
3286 printf (_(" Number TAG\n"));
3288 for (entry = first_abbrev; entry; entry = entry->next)
3292 printf (_(" %ld %s [%s]\n"),
3294 get_TAG_name (entry->tag),
3295 entry->children ? _("has children") : _("no children"));
3297 for (attr = entry->first_attr; attr; attr = attr->next)
3298 printf (_(" %-18s %s\n"),
3299 get_AT_name (attr->attribute),
3300 get_FORM_name (attr->form));
3311 display_debug_loc (struct dwarf_section *section, void *file)
3313 unsigned char *start = section->start;
3314 unsigned char *section_end;
3315 unsigned long bytes;
3316 unsigned char *section_begin = start;
3317 unsigned int num_loc_list = 0;
3318 unsigned long last_offset = 0;
3319 unsigned int first = 0;
3322 int seen_first_offset = 0;
3323 int use_debug_info = 1;
3324 unsigned char *next;
3326 bytes = section->size;
3327 section_end = start + bytes;
3331 printf (_("\nThe %s section is empty.\n"), section->name);
3335 if (load_debug_info (file) == 0)
3337 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3342 /* Check the order of location list in .debug_info section. If
3343 offsets of location lists are in the ascending order, we can
3344 use `debug_information' directly. */
3345 for (i = 0; i < num_debug_info_entries; i++)
3349 num = debug_information [i].num_loc_offsets;
3350 num_loc_list += num;
3352 /* Check if we can use `debug_information' directly. */
3353 if (use_debug_info && num != 0)
3355 if (!seen_first_offset)
3357 /* This is the first location list. */
3358 last_offset = debug_information [i].loc_offsets [0];
3360 seen_first_offset = 1;
3366 for (; j < num; j++)
3369 debug_information [i].loc_offsets [j])
3374 last_offset = debug_information [i].loc_offsets [j];
3379 if (!use_debug_info)
3380 /* FIXME: Should we handle this case? */
3381 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3383 if (!seen_first_offset)
3384 error (_("No location lists in .debug_info section!\n"));
3386 /* DWARF sections under Mach-O have non-zero addresses. */
3387 if (debug_information [first].num_loc_offsets > 0
3388 && debug_information [first].loc_offsets [0] != section->address)
3389 warn (_("Location lists in %s section start at 0x%lx\n"),
3390 section->name, debug_information [first].loc_offsets [0]);
3392 printf (_("Contents of the %s section:\n\n"), section->name);
3393 printf (_(" Offset Begin End Expression\n"));
3395 seen_first_offset = 0;
3396 for (i = first; i < num_debug_info_entries; i++)
3400 unsigned short length;
3401 unsigned long offset;
3402 unsigned int pointer_size;
3403 unsigned long cu_offset;
3404 unsigned long base_address;
3405 int need_frame_base;
3408 pointer_size = debug_information [i].pointer_size;
3409 cu_offset = debug_information [i].cu_offset;
3411 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
3413 has_frame_base = debug_information [i].have_frame_base [j];
3414 /* DWARF sections under Mach-O have non-zero addresses. */
3415 offset = debug_information [i].loc_offsets [j] - section->address;
3416 next = section_begin + offset;
3417 base_address = debug_information [i].base_address;
3419 if (!seen_first_offset)
3420 seen_first_offset = 1;
3424 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3425 (unsigned long) (start - section_begin),
3426 (unsigned long) (next - section_begin));
3427 else if (start > next)
3428 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3429 (unsigned long) (start - section_begin),
3430 (unsigned long) (next - section_begin));
3434 if (offset >= bytes)
3436 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3443 if (start + 2 * pointer_size > section_end)
3445 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3450 /* Note: we use sign extension here in order to be sure that
3451 we can detect the -1 escape value. Sign extension into the
3452 top 32 bits of a 32-bit address will not affect the values
3453 that we display since we always show hex values, and always
3454 the bottom 32-bits. */
3455 begin = byte_get_signed (start, pointer_size);
3456 start += pointer_size;
3457 end = byte_get_signed (start, pointer_size);
3458 start += pointer_size;
3460 printf (" %8.8lx ", offset);
3462 if (begin == 0 && end == 0)
3464 printf (_("<End of list>\n"));
3468 /* Check base address specifiers. */
3469 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3472 print_dwarf_vma (begin, pointer_size);
3473 print_dwarf_vma (end, pointer_size);
3474 printf (_("(base address)\n"));
3478 if (start + 2 > section_end)
3480 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3485 length = byte_get (start, 2);
3488 if (start + length > section_end)
3490 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3495 print_dwarf_vma (begin + base_address, pointer_size);
3496 print_dwarf_vma (end + base_address, pointer_size);
3499 need_frame_base = decode_location_expression (start,
3502 cu_offset, section);
3505 if (need_frame_base && !has_frame_base)
3506 printf (_(" [without DW_AT_frame_base]"));
3509 fputs (_(" (start == end)"), stdout);
3510 else if (begin > end)
3511 fputs (_(" (start > end)"), stdout);
3520 if (start < section_end)
3521 warn (_("There are %ld unused bytes at the end of section %s\n"),
3522 (long) (section_end - start), section->name);
3528 display_debug_str (struct dwarf_section *section,
3529 void *file ATTRIBUTE_UNUSED)
3531 unsigned char *start = section->start;
3532 unsigned long bytes = section->size;
3533 dwarf_vma addr = section->address;
3537 printf (_("\nThe %s section is empty.\n"), section->name);
3541 printf (_("Contents of the %s section:\n\n"), section->name);
3549 lbytes = (bytes > 16 ? 16 : bytes);
3551 printf (" 0x%8.8lx ", (unsigned long) addr);
3553 for (j = 0; j < 16; j++)
3556 printf ("%2.2x", start[j]);
3564 for (j = 0; j < lbytes; j++)
3567 if (k >= ' ' && k < 0x80)
3586 display_debug_info (struct dwarf_section *section, void *file)
3588 return process_debug_info (section, file, abbrev, 0, 0);
3592 display_debug_types (struct dwarf_section *section, void *file)
3594 return process_debug_info (section, file, abbrev, 0, 1);
3598 display_trace_info (struct dwarf_section *section, void *file)
3600 return process_debug_info (section, file, trace_abbrev, 0, 0);
3604 display_debug_aranges (struct dwarf_section *section,
3605 void *file ATTRIBUTE_UNUSED)
3607 unsigned char *start = section->start;
3608 unsigned char *end = start + section->size;
3610 printf (_("Contents of the %s section:\n\n"), section->name);
3612 /* It does not matter if this load fails,
3613 we test for that later on. */
3614 load_debug_info (file);
3618 unsigned char *hdrptr;
3619 DWARF2_Internal_ARange arange;
3620 unsigned char *addr_ranges;
3623 unsigned char address_size;
3626 int initial_length_size;
3630 arange.ar_length = byte_get (hdrptr, 4);
3633 if (arange.ar_length == 0xffffffff)
3635 arange.ar_length = byte_get (hdrptr, 8);
3638 initial_length_size = 12;
3643 initial_length_size = 4;
3646 arange.ar_version = byte_get (hdrptr, 2);
3649 arange.ar_info_offset = byte_get (hdrptr, offset_size);
3650 hdrptr += offset_size;
3652 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3653 && num_debug_info_entries > 0
3654 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3655 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3656 arange.ar_info_offset, section->name);
3658 arange.ar_pointer_size = byte_get (hdrptr, 1);
3661 arange.ar_segment_size = byte_get (hdrptr, 1);
3664 if (arange.ar_version != 2 && arange.ar_version != 3)
3666 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3670 printf (_(" Length: %ld\n"), arange.ar_length);
3671 printf (_(" Version: %d\n"), arange.ar_version);
3672 printf (_(" Offset into .debug_info: 0x%lx\n"), arange.ar_info_offset);
3673 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
3674 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
3676 address_size = arange.ar_pointer_size + arange.ar_segment_size;
3678 /* The DWARF spec does not require that the address size be a power
3679 of two, but we do. This will have to change if we ever encounter
3680 an uneven architecture. */
3681 if ((address_size & (address_size - 1)) != 0)
3683 warn (_("Pointer size + Segment size is not a power of two.\n"));
3687 if (address_size > 4)
3688 printf (_("\n Address Length\n"));
3690 printf (_("\n Address Length\n"));
3692 addr_ranges = hdrptr;
3694 /* Must pad to an alignment boundary that is twice the address size. */
3695 excess = (hdrptr - start) % (2 * address_size);
3697 addr_ranges += (2 * address_size) - excess;
3699 start += arange.ar_length + initial_length_size;
3701 while (addr_ranges + 2 * address_size <= start)
3703 address = byte_get (addr_ranges, address_size);
3705 addr_ranges += address_size;
3707 length = byte_get (addr_ranges, address_size);
3709 addr_ranges += address_size;
3712 print_dwarf_vma (address, address_size);
3713 print_dwarf_vma (length, address_size);
3723 /* Each debug_information[x].range_lists[y] gets this representation for
3724 sorting purposes. */
3728 /* The debug_information[x].range_lists[y] value. */
3729 unsigned long ranges_offset;
3731 /* Original debug_information to find parameters of the data. */
3732 debug_info *debug_info_p;
3735 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3738 range_entry_compar (const void *ap, const void *bp)
3740 const struct range_entry *a_re = (const struct range_entry *) ap;
3741 const struct range_entry *b_re = (const struct range_entry *) bp;
3742 const unsigned long a = a_re->ranges_offset;
3743 const unsigned long b = b_re->ranges_offset;
3745 return (a > b) - (b > a);
3749 display_debug_ranges (struct dwarf_section *section,
3750 void *file ATTRIBUTE_UNUSED)
3752 unsigned char *start = section->start;
3753 unsigned long bytes;
3754 unsigned char *section_begin = start;
3755 unsigned int num_range_list, i;
3756 struct range_entry *range_entries, *range_entry_fill;
3758 bytes = section->size;
3762 printf (_("\nThe %s section is empty.\n"), section->name);
3766 if (load_debug_info (file) == 0)
3768 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3774 for (i = 0; i < num_debug_info_entries; i++)
3775 num_range_list += debug_information [i].num_range_lists;
3777 if (num_range_list == 0)
3778 error (_("No range lists in .debug_info section!\n"));
3780 range_entries = (struct range_entry *)
3781 xmalloc (sizeof (*range_entries) * num_range_list);
3782 range_entry_fill = range_entries;
3784 for (i = 0; i < num_debug_info_entries; i++)
3786 debug_info *debug_info_p = &debug_information[i];
3789 for (j = 0; j < debug_info_p->num_range_lists; j++)
3791 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
3792 range_entry_fill->debug_info_p = debug_info_p;
3797 qsort (range_entries, num_range_list, sizeof (*range_entries),
3798 range_entry_compar);
3800 /* DWARF sections under Mach-O have non-zero addresses. */
3801 if (range_entries[0].ranges_offset != section->address)
3802 warn (_("Range lists in %s section start at 0x%lx\n"),
3803 section->name, range_entries[0].ranges_offset);
3805 printf (_("Contents of the %s section:\n\n"), section->name);
3806 printf (_(" Offset Begin End\n"));
3808 for (i = 0; i < num_range_list; i++)
3810 struct range_entry *range_entry = &range_entries[i];
3811 debug_info *debug_info_p = range_entry->debug_info_p;
3812 unsigned int pointer_size;
3813 unsigned long offset;
3814 unsigned char *next;
3815 unsigned long base_address;
3817 pointer_size = debug_info_p->pointer_size;
3819 /* DWARF sections under Mach-O have non-zero addresses. */
3820 offset = range_entry->ranges_offset - section->address;
3821 next = section_begin + offset;
3822 base_address = debug_info_p->base_address;
3827 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3828 (unsigned long) (start - section_begin),
3829 (unsigned long) (next - section_begin), section->name);
3830 else if (start > next)
3831 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3832 (unsigned long) (start - section_begin),
3833 (unsigned long) (next - section_begin), section->name);
3842 /* Note: we use sign extension here in order to be sure that
3843 we can detect the -1 escape value. Sign extension into the
3844 top 32 bits of a 32-bit address will not affect the values
3845 that we display since we always show hex values, and always
3846 the bottom 32-bits. */
3847 begin = byte_get_signed (start, pointer_size);
3848 start += pointer_size;
3849 end = byte_get_signed (start, pointer_size);
3850 start += pointer_size;
3852 printf (" %8.8lx ", offset);
3854 if (begin == 0 && end == 0)
3856 printf (_("<End of list>\n"));
3860 /* Check base address specifiers. */
3861 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3864 print_dwarf_vma (begin, pointer_size);
3865 print_dwarf_vma (end, pointer_size);
3866 printf ("(base address)\n");
3870 print_dwarf_vma (begin + base_address, pointer_size);
3871 print_dwarf_vma (end + base_address, pointer_size);
3874 fputs (_("(start == end)"), stdout);
3875 else if (begin > end)
3876 fputs (_("(start > end)"), stdout);
3883 free (range_entries);
3888 typedef struct Frame_Chunk
3890 struct Frame_Chunk *next;
3891 unsigned char *chunk_start;
3893 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3894 short int *col_type;
3897 unsigned int code_factor;
3899 unsigned long pc_begin;
3900 unsigned long pc_range;
3904 unsigned char fde_encoding;
3905 unsigned char cfa_exp;
3906 unsigned char ptr_size;
3907 unsigned char segment_size;
3911 static const char *const *dwarf_regnames;
3912 static unsigned int dwarf_regnames_count;
3914 /* A marker for a col_type that means this column was never referenced
3915 in the frame info. */
3916 #define DW_CFA_unreferenced (-1)
3918 /* Return 0 if not more space is needed, 1 if more space is needed,
3919 -1 for invalid reg. */
3922 frame_need_space (Frame_Chunk *fc, unsigned int reg)
3924 int prev = fc->ncols;
3926 if (reg < (unsigned int) fc->ncols)
3929 if (dwarf_regnames_count
3930 && reg > dwarf_regnames_count)
3933 fc->ncols = reg + 1;
3934 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
3935 sizeof (short int));
3936 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3938 while (prev < fc->ncols)
3940 fc->col_type[prev] = DW_CFA_unreferenced;
3941 fc->col_offset[prev] = 0;
3947 static const char *const dwarf_regnames_i386[] =
3949 "eax", "ecx", "edx", "ebx",
3950 "esp", "ebp", "esi", "edi",
3951 "eip", "eflags", NULL,
3952 "st0", "st1", "st2", "st3",
3953 "st4", "st5", "st6", "st7",
3955 "xmm0", "xmm1", "xmm2", "xmm3",
3956 "xmm4", "xmm5", "xmm6", "xmm7",
3957 "mm0", "mm1", "mm2", "mm3",
3958 "mm4", "mm5", "mm6", "mm7",
3959 "fcw", "fsw", "mxcsr",
3960 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3965 init_dwarf_regnames_i386 (void)
3967 dwarf_regnames = dwarf_regnames_i386;
3968 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
3971 static const char *const dwarf_regnames_x86_64[] =
3973 "rax", "rdx", "rcx", "rbx",
3974 "rsi", "rdi", "rbp", "rsp",
3975 "r8", "r9", "r10", "r11",
3976 "r12", "r13", "r14", "r15",
3978 "xmm0", "xmm1", "xmm2", "xmm3",
3979 "xmm4", "xmm5", "xmm6", "xmm7",
3980 "xmm8", "xmm9", "xmm10", "xmm11",
3981 "xmm12", "xmm13", "xmm14", "xmm15",
3982 "st0", "st1", "st2", "st3",
3983 "st4", "st5", "st6", "st7",
3984 "mm0", "mm1", "mm2", "mm3",
3985 "mm4", "mm5", "mm6", "mm7",
3987 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3988 "fs.base", "gs.base", NULL, NULL,
3990 "mxcsr", "fcw", "fsw"
3994 init_dwarf_regnames_x86_64 (void)
3996 dwarf_regnames = dwarf_regnames_x86_64;
3997 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4001 init_dwarf_regnames (unsigned int e_machine)
4007 init_dwarf_regnames_i386 ();
4012 init_dwarf_regnames_x86_64 ();
4021 regname (unsigned int regno, int row)
4023 static char reg[64];
4025 && regno < dwarf_regnames_count
4026 && dwarf_regnames [regno] != NULL)
4029 return dwarf_regnames [regno];
4030 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4031 dwarf_regnames [regno]);
4034 snprintf (reg, sizeof (reg), "r%d", regno);
4039 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4044 if (*max_regs < fc->ncols)
4045 *max_regs = fc->ncols;
4047 if (*need_col_headers)
4049 static const char *sloc = " LOC";
4051 *need_col_headers = 0;
4053 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
4055 for (r = 0; r < *max_regs; r++)
4056 if (fc->col_type[r] != DW_CFA_unreferenced)
4061 printf ("%-5s ", regname (r, 1));
4067 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4069 strcpy (tmp, "exp");
4071 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4072 printf ("%-8s ", tmp);
4074 for (r = 0; r < fc->ncols; r++)
4076 if (fc->col_type[r] != DW_CFA_unreferenced)
4078 switch (fc->col_type[r])
4080 case DW_CFA_undefined:
4083 case DW_CFA_same_value:
4087 sprintf (tmp, "c%+d", fc->col_offset[r]);
4089 case DW_CFA_val_offset:
4090 sprintf (tmp, "v%+d", fc->col_offset[r]);
4092 case DW_CFA_register:
4093 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4095 case DW_CFA_expression:
4096 strcpy (tmp, "exp");
4098 case DW_CFA_val_expression:
4099 strcpy (tmp, "vexp");
4102 strcpy (tmp, "n/a");
4105 printf ("%-5s ", tmp);
4111 #define GET(N) byte_get (start, N); start += N
4112 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4113 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
4116 display_debug_frames (struct dwarf_section *section,
4117 void *file ATTRIBUTE_UNUSED)
4119 unsigned char *start = section->start;
4120 unsigned char *end = start + section->size;
4121 unsigned char *section_start = start;
4122 Frame_Chunk *chunks = 0;
4123 Frame_Chunk *remembered_state = 0;
4125 int is_eh = strcmp (section->name, ".eh_frame") == 0;
4126 unsigned int length_return;
4128 const char *bad_reg = _("bad register: ");
4129 int saved_eh_addr_size = eh_addr_size;
4131 printf (_("Contents of the %s section:\n"), section->name);
4135 unsigned char *saved_start;
4136 unsigned char *block_end;
4137 unsigned long length;
4138 unsigned long cie_id;
4141 int need_col_headers = 1;
4142 unsigned char *augmentation_data = NULL;
4143 unsigned long augmentation_data_len = 0;
4144 int encoded_ptr_size = saved_eh_addr_size;
4146 int initial_length_size;
4148 saved_start = start;
4149 length = byte_get (start, 4); start += 4;
4153 printf ("\n%08lx ZERO terminator\n\n",
4154 (unsigned long)(saved_start - section_start));
4158 if (length == 0xffffffff)
4160 length = byte_get (start, 8);
4163 initial_length_size = 12;
4168 initial_length_size = 4;
4171 block_end = saved_start + length + initial_length_size;
4172 if (block_end > end)
4174 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4175 length, (unsigned long)(saved_start - section_start));
4178 cie_id = byte_get (start, offset_size); start += offset_size;
4180 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4184 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4185 memset (fc, 0, sizeof (Frame_Chunk));
4189 fc->chunk_start = saved_start;
4191 fc->col_type = (short int *) xmalloc (sizeof (short int));
4192 fc->col_offset = (int *) xmalloc (sizeof (int));
4193 frame_need_space (fc, max_regs - 1);
4197 fc->augmentation = (char *) start;
4198 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4200 if (strcmp (fc->augmentation, "eh") == 0)
4201 start += eh_addr_size;
4205 fc->ptr_size = GET (1);
4206 fc->segment_size = GET (1);
4207 eh_addr_size = fc->ptr_size;
4211 fc->ptr_size = eh_addr_size;
4212 fc->segment_size = 0;
4214 fc->code_factor = LEB ();
4215 fc->data_factor = SLEB ();
4225 if (fc->augmentation[0] == 'z')
4227 augmentation_data_len = LEB ();
4228 augmentation_data = start;
4229 start += augmentation_data_len;
4233 if (do_debug_frames_interp)
4234 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4235 (unsigned long)(saved_start - section_start), length, cie_id,
4236 fc->augmentation, fc->code_factor, fc->data_factor,
4240 printf ("\n%08lx %08lx %08lx CIE\n",
4241 (unsigned long)(saved_start - section_start), length, cie_id);
4242 printf (" Version: %d\n", version);
4243 printf (" Augmentation: \"%s\"\n", fc->augmentation);
4246 printf (" Pointer Size: %u\n", fc->ptr_size);
4247 printf (" Segment Size: %u\n", fc->segment_size);
4249 printf (" Code alignment factor: %u\n", fc->code_factor);
4250 printf (" Data alignment factor: %d\n", fc->data_factor);
4251 printf (" Return address column: %d\n", fc->ra);
4253 if (augmentation_data_len)
4256 printf (" Augmentation data: ");
4257 for (i = 0; i < augmentation_data_len; ++i)
4258 printf (" %02x", augmentation_data[i]);
4264 if (augmentation_data_len)
4266 unsigned char *p, *q;
4267 p = (unsigned char *) fc->augmentation + 1;
4268 q = augmentation_data;
4275 q += 1 + size_of_encoded_value (*q);
4277 fc->fde_encoding = *q++;
4285 if (fc->fde_encoding)
4286 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4289 frame_need_space (fc, fc->ra);
4293 unsigned char *look_for;
4294 static Frame_Chunk fde_fc;
4295 unsigned long segment_selector;
4298 memset (fc, 0, sizeof (Frame_Chunk));
4300 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4302 for (cie = chunks; cie ; cie = cie->next)
4303 if (cie->chunk_start == look_for)
4308 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4309 cie_id, (unsigned long)(saved_start - section_start));
4311 fc->col_type = (short int *) xmalloc (sizeof (short int));
4312 fc->col_offset = (int *) xmalloc (sizeof (int));
4313 frame_need_space (fc, max_regs - 1);
4315 fc->augmentation = "";
4316 fc->fde_encoding = 0;
4317 fc->ptr_size = eh_addr_size;
4318 fc->segment_size = 0;
4322 fc->ncols = cie->ncols;
4323 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4324 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
4325 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4326 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4327 fc->augmentation = cie->augmentation;
4328 fc->ptr_size = cie->ptr_size;
4329 eh_addr_size = cie->ptr_size;
4330 fc->segment_size = cie->segment_size;
4331 fc->code_factor = cie->code_factor;
4332 fc->data_factor = cie->data_factor;
4333 fc->cfa_reg = cie->cfa_reg;
4334 fc->cfa_offset = cie->cfa_offset;
4336 frame_need_space (fc, max_regs - 1);
4337 fc->fde_encoding = cie->fde_encoding;
4340 if (fc->fde_encoding)
4341 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4343 segment_selector = 0;
4344 if (fc->segment_size)
4346 segment_selector = byte_get (start, fc->segment_size);
4347 start += fc->segment_size;
4349 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
4350 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4351 fc->pc_begin += section->address + (start - section_start);
4352 start += encoded_ptr_size;
4353 fc->pc_range = byte_get (start, encoded_ptr_size);
4354 start += encoded_ptr_size;
4356 if (cie->augmentation[0] == 'z')
4358 augmentation_data_len = LEB ();
4359 augmentation_data = start;
4360 start += augmentation_data_len;
4363 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4364 (unsigned long)(saved_start - section_start), length, cie_id,
4365 (unsigned long)(cie->chunk_start - section_start));
4366 if (fc->segment_size)
4367 printf ("%04lx:", segment_selector);
4368 printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4369 if (! do_debug_frames_interp && augmentation_data_len)
4373 printf (" Augmentation data: ");
4374 for (i = 0; i < augmentation_data_len; ++i)
4375 printf (" %02x", augmentation_data[i]);
4381 /* At this point, fc is the current chunk, cie (if any) is set, and
4382 we're about to interpret instructions for the chunk. */
4383 /* ??? At present we need to do this always, since this sizes the
4384 fc->col_type and fc->col_offset arrays, which we write into always.
4385 We should probably split the interpreted and non-interpreted bits
4386 into two different routines, since there's so much that doesn't
4387 really overlap between them. */
4388 if (1 || do_debug_frames_interp)
4390 /* Start by making a pass over the chunk, allocating storage
4391 and taking note of what registers are used. */
4392 unsigned char *tmp = start;
4394 while (start < block_end)
4397 unsigned long reg, temp;
4404 /* Warning: if you add any more cases to this switch, be
4405 sure to add them to the corresponding switch below. */
4408 case DW_CFA_advance_loc:
4412 if (frame_need_space (fc, opa) >= 0)
4413 fc->col_type[opa] = DW_CFA_undefined;
4415 case DW_CFA_restore:
4416 if (frame_need_space (fc, opa) >= 0)
4417 fc->col_type[opa] = DW_CFA_undefined;
4419 case DW_CFA_set_loc:
4420 start += encoded_ptr_size;
4422 case DW_CFA_advance_loc1:
4425 case DW_CFA_advance_loc2:
4428 case DW_CFA_advance_loc4:
4431 case DW_CFA_offset_extended:
4432 case DW_CFA_val_offset:
4433 reg = LEB (); LEB ();
4434 if (frame_need_space (fc, reg) >= 0)
4435 fc->col_type[reg] = DW_CFA_undefined;
4437 case DW_CFA_restore_extended:
4439 frame_need_space (fc, reg);
4440 if (frame_need_space (fc, reg) >= 0)
4441 fc->col_type[reg] = DW_CFA_undefined;
4443 case DW_CFA_undefined:
4445 if (frame_need_space (fc, reg) >= 0)
4446 fc->col_type[reg] = DW_CFA_undefined;
4448 case DW_CFA_same_value:
4450 if (frame_need_space (fc, reg) >= 0)
4451 fc->col_type[reg] = DW_CFA_undefined;
4453 case DW_CFA_register:
4454 reg = LEB (); LEB ();
4455 if (frame_need_space (fc, reg) >= 0)
4456 fc->col_type[reg] = DW_CFA_undefined;
4458 case DW_CFA_def_cfa:
4461 case DW_CFA_def_cfa_register:
4464 case DW_CFA_def_cfa_offset:
4467 case DW_CFA_def_cfa_expression:
4471 case DW_CFA_expression:
4472 case DW_CFA_val_expression:
4476 if (frame_need_space (fc, reg) >= 0)
4477 fc->col_type[reg] = DW_CFA_undefined;
4479 case DW_CFA_offset_extended_sf:
4480 case DW_CFA_val_offset_sf:
4481 reg = LEB (); SLEB ();
4482 if (frame_need_space (fc, reg) >= 0)
4483 fc->col_type[reg] = DW_CFA_undefined;
4485 case DW_CFA_def_cfa_sf:
4488 case DW_CFA_def_cfa_offset_sf:
4491 case DW_CFA_MIPS_advance_loc8:
4494 case DW_CFA_GNU_args_size:
4497 case DW_CFA_GNU_negative_offset_extended:
4498 reg = LEB (); LEB ();
4499 if (frame_need_space (fc, reg) >= 0)
4500 fc->col_type[reg] = DW_CFA_undefined;
4509 /* Now we know what registers are used, make a second pass over
4510 the chunk, this time actually printing out the info. */
4512 while (start < block_end)
4515 unsigned long ul, reg, roffs;
4518 const char *reg_prefix = "";
4525 /* Warning: if you add any more cases to this switch, be
4526 sure to add them to the corresponding switch above. */
4529 case DW_CFA_advance_loc:
4530 if (do_debug_frames_interp)
4531 frame_display_row (fc, &need_col_headers, &max_regs);
4533 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4534 opa * fc->code_factor,
4535 fc->pc_begin + opa * fc->code_factor);
4536 fc->pc_begin += opa * fc->code_factor;
4541 if (opa >= (unsigned int) fc->ncols)
4542 reg_prefix = bad_reg;
4543 if (! do_debug_frames_interp || *reg_prefix != '\0')
4544 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4545 reg_prefix, regname (opa, 0),
4546 roffs * fc->data_factor);
4547 if (*reg_prefix == '\0')
4549 fc->col_type[opa] = DW_CFA_offset;
4550 fc->col_offset[opa] = roffs * fc->data_factor;
4554 case DW_CFA_restore:
4555 if (opa >= (unsigned int) cie->ncols
4556 || opa >= (unsigned int) fc->ncols)
4557 reg_prefix = bad_reg;
4558 if (! do_debug_frames_interp || *reg_prefix != '\0')
4559 printf (" DW_CFA_restore: %s%s\n",
4560 reg_prefix, regname (opa, 0));
4561 if (*reg_prefix == '\0')
4563 fc->col_type[opa] = cie->col_type[opa];
4564 fc->col_offset[opa] = cie->col_offset[opa];
4568 case DW_CFA_set_loc:
4569 vma = get_encoded_value (start, fc->fde_encoding);
4570 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4571 vma += section->address + (start - section_start);
4572 start += encoded_ptr_size;
4573 if (do_debug_frames_interp)
4574 frame_display_row (fc, &need_col_headers, &max_regs);
4576 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4580 case DW_CFA_advance_loc1:
4581 ofs = byte_get (start, 1); start += 1;
4582 if (do_debug_frames_interp)
4583 frame_display_row (fc, &need_col_headers, &max_regs);
4585 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4586 ofs * fc->code_factor,
4587 fc->pc_begin + ofs * fc->code_factor);
4588 fc->pc_begin += ofs * fc->code_factor;
4591 case DW_CFA_advance_loc2:
4592 ofs = byte_get (start, 2); start += 2;
4593 if (do_debug_frames_interp)
4594 frame_display_row (fc, &need_col_headers, &max_regs);
4596 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4597 ofs * fc->code_factor,
4598 fc->pc_begin + ofs * fc->code_factor);
4599 fc->pc_begin += ofs * fc->code_factor;
4602 case DW_CFA_advance_loc4:
4603 ofs = byte_get (start, 4); start += 4;
4604 if (do_debug_frames_interp)
4605 frame_display_row (fc, &need_col_headers, &max_regs);
4607 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4608 ofs * fc->code_factor,
4609 fc->pc_begin + ofs * fc->code_factor);
4610 fc->pc_begin += ofs * fc->code_factor;
4613 case DW_CFA_offset_extended:
4616 if (reg >= (unsigned int) fc->ncols)
4617 reg_prefix = bad_reg;
4618 if (! do_debug_frames_interp || *reg_prefix != '\0')
4619 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4620 reg_prefix, regname (reg, 0),
4621 roffs * fc->data_factor);
4622 if (*reg_prefix == '\0')
4624 fc->col_type[reg] = DW_CFA_offset;
4625 fc->col_offset[reg] = roffs * fc->data_factor;
4629 case DW_CFA_val_offset:
4632 if (reg >= (unsigned int) fc->ncols)
4633 reg_prefix = bad_reg;
4634 if (! do_debug_frames_interp || *reg_prefix != '\0')
4635 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4636 reg_prefix, regname (reg, 0),
4637 roffs * fc->data_factor);
4638 if (*reg_prefix == '\0')
4640 fc->col_type[reg] = DW_CFA_val_offset;
4641 fc->col_offset[reg] = roffs * fc->data_factor;
4645 case DW_CFA_restore_extended:
4647 if (reg >= (unsigned int) cie->ncols
4648 || reg >= (unsigned int) fc->ncols)
4649 reg_prefix = bad_reg;
4650 if (! do_debug_frames_interp || *reg_prefix != '\0')
4651 printf (" DW_CFA_restore_extended: %s%s\n",
4652 reg_prefix, regname (reg, 0));
4653 if (*reg_prefix == '\0')
4655 fc->col_type[reg] = cie->col_type[reg];
4656 fc->col_offset[reg] = cie->col_offset[reg];
4660 case DW_CFA_undefined:
4662 if (reg >= (unsigned int) fc->ncols)
4663 reg_prefix = bad_reg;
4664 if (! do_debug_frames_interp || *reg_prefix != '\0')
4665 printf (" DW_CFA_undefined: %s%s\n",
4666 reg_prefix, regname (reg, 0));
4667 if (*reg_prefix == '\0')
4669 fc->col_type[reg] = DW_CFA_undefined;
4670 fc->col_offset[reg] = 0;
4674 case DW_CFA_same_value:
4676 if (reg >= (unsigned int) fc->ncols)
4677 reg_prefix = bad_reg;
4678 if (! do_debug_frames_interp || *reg_prefix != '\0')
4679 printf (" DW_CFA_same_value: %s%s\n",
4680 reg_prefix, regname (reg, 0));
4681 if (*reg_prefix == '\0')
4683 fc->col_type[reg] = DW_CFA_same_value;
4684 fc->col_offset[reg] = 0;
4688 case DW_CFA_register:
4691 if (reg >= (unsigned int) fc->ncols)
4692 reg_prefix = bad_reg;
4693 if (! do_debug_frames_interp || *reg_prefix != '\0')
4695 printf (" DW_CFA_register: %s%s in ",
4696 reg_prefix, regname (reg, 0));
4697 puts (regname (roffs, 0));
4699 if (*reg_prefix == '\0')
4701 fc->col_type[reg] = DW_CFA_register;
4702 fc->col_offset[reg] = roffs;
4706 case DW_CFA_remember_state:
4707 if (! do_debug_frames_interp)
4708 printf (" DW_CFA_remember_state\n");
4709 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4710 rs->ncols = fc->ncols;
4711 rs->col_type = (short int *) xcmalloc (rs->ncols,
4712 sizeof (short int));
4713 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
4714 memcpy (rs->col_type, fc->col_type, rs->ncols);
4715 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4716 rs->next = remembered_state;
4717 remembered_state = rs;
4720 case DW_CFA_restore_state:
4721 if (! do_debug_frames_interp)
4722 printf (" DW_CFA_restore_state\n");
4723 rs = remembered_state;
4726 remembered_state = rs->next;
4727 frame_need_space (fc, rs->ncols - 1);
4728 memcpy (fc->col_type, rs->col_type, rs->ncols);
4729 memcpy (fc->col_offset, rs->col_offset,
4730 rs->ncols * sizeof (int));
4731 free (rs->col_type);
4732 free (rs->col_offset);
4735 else if (do_debug_frames_interp)
4736 printf ("Mismatched DW_CFA_restore_state\n");
4739 case DW_CFA_def_cfa:
4740 fc->cfa_reg = LEB ();
4741 fc->cfa_offset = LEB ();
4743 if (! do_debug_frames_interp)
4744 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4745 regname (fc->cfa_reg, 0), fc->cfa_offset);
4748 case DW_CFA_def_cfa_register:
4749 fc->cfa_reg = LEB ();
4751 if (! do_debug_frames_interp)
4752 printf (" DW_CFA_def_cfa_register: %s\n",
4753 regname (fc->cfa_reg, 0));
4756 case DW_CFA_def_cfa_offset:
4757 fc->cfa_offset = LEB ();
4758 if (! do_debug_frames_interp)
4759 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4763 if (! do_debug_frames_interp)
4764 printf (" DW_CFA_nop\n");
4767 case DW_CFA_def_cfa_expression:
4769 if (! do_debug_frames_interp)
4771 printf (" DW_CFA_def_cfa_expression (");
4772 decode_location_expression (start, eh_addr_size, ul, 0,
4780 case DW_CFA_expression:
4783 if (reg >= (unsigned int) fc->ncols)
4784 reg_prefix = bad_reg;
4785 if (! do_debug_frames_interp || *reg_prefix != '\0')
4787 printf (" DW_CFA_expression: %s%s (",
4788 reg_prefix, regname (reg, 0));
4789 decode_location_expression (start, eh_addr_size,
4793 if (*reg_prefix == '\0')
4794 fc->col_type[reg] = DW_CFA_expression;
4798 case DW_CFA_val_expression:
4801 if (reg >= (unsigned int) fc->ncols)
4802 reg_prefix = bad_reg;
4803 if (! do_debug_frames_interp || *reg_prefix != '\0')
4805 printf (" DW_CFA_val_expression: %s%s (",
4806 reg_prefix, regname (reg, 0));
4807 decode_location_expression (start, eh_addr_size, ul, 0,
4811 if (*reg_prefix == '\0')
4812 fc->col_type[reg] = DW_CFA_val_expression;
4816 case DW_CFA_offset_extended_sf:
4819 if (frame_need_space (fc, reg) < 0)
4820 reg_prefix = bad_reg;
4821 if (! do_debug_frames_interp || *reg_prefix != '\0')
4822 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4823 reg_prefix, regname (reg, 0),
4824 l * fc->data_factor);
4825 if (*reg_prefix == '\0')
4827 fc->col_type[reg] = DW_CFA_offset;
4828 fc->col_offset[reg] = l * fc->data_factor;
4832 case DW_CFA_val_offset_sf:
4835 if (frame_need_space (fc, reg) < 0)
4836 reg_prefix = bad_reg;
4837 if (! do_debug_frames_interp || *reg_prefix != '\0')
4838 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4839 reg_prefix, regname (reg, 0),
4840 l * fc->data_factor);
4841 if (*reg_prefix == '\0')
4843 fc->col_type[reg] = DW_CFA_val_offset;
4844 fc->col_offset[reg] = l * fc->data_factor;
4848 case DW_CFA_def_cfa_sf:
4849 fc->cfa_reg = LEB ();
4850 fc->cfa_offset = SLEB ();
4851 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4853 if (! do_debug_frames_interp)
4854 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4855 regname (fc->cfa_reg, 0), fc->cfa_offset);
4858 case DW_CFA_def_cfa_offset_sf:
4859 fc->cfa_offset = SLEB ();
4860 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4861 if (! do_debug_frames_interp)
4862 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4865 case DW_CFA_MIPS_advance_loc8:
4866 ofs = byte_get (start, 8); start += 8;
4867 if (do_debug_frames_interp)
4868 frame_display_row (fc, &need_col_headers, &max_regs);
4870 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4871 ofs * fc->code_factor,
4872 fc->pc_begin + ofs * fc->code_factor);
4873 fc->pc_begin += ofs * fc->code_factor;
4876 case DW_CFA_GNU_window_save:
4877 if (! do_debug_frames_interp)
4878 printf (" DW_CFA_GNU_window_save\n");
4881 case DW_CFA_GNU_args_size:
4883 if (! do_debug_frames_interp)
4884 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
4887 case DW_CFA_GNU_negative_offset_extended:
4890 if (frame_need_space (fc, reg) < 0)
4891 reg_prefix = bad_reg;
4892 if (! do_debug_frames_interp || *reg_prefix != '\0')
4893 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4894 reg_prefix, regname (reg, 0),
4895 l * fc->data_factor);
4896 if (*reg_prefix == '\0')
4898 fc->col_type[reg] = DW_CFA_offset;
4899 fc->col_offset[reg] = l * fc->data_factor;
4904 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4905 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4907 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4912 if (do_debug_frames_interp)
4913 frame_display_row (fc, &need_col_headers, &max_regs);
4916 eh_addr_size = saved_eh_addr_size;
4929 display_debug_not_supported (struct dwarf_section *section,
4930 void *file ATTRIBUTE_UNUSED)
4932 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4939 cmalloc (size_t nmemb, size_t size)
4941 /* Check for overflow. */
4942 if (nmemb >= ~(size_t) 0 / size)
4945 return malloc (nmemb * size);
4949 xcmalloc (size_t nmemb, size_t size)
4951 /* Check for overflow. */
4952 if (nmemb >= ~(size_t) 0 / size)
4955 return xmalloc (nmemb * size);
4959 xcrealloc (void *ptr, size_t nmemb, size_t size)
4961 /* Check for overflow. */
4962 if (nmemb >= ~(size_t) 0 / size)
4965 return xrealloc (ptr, nmemb * size);
4969 error (const char *message, ...)
4973 va_start (args, message);
4974 fprintf (stderr, _("%s: Error: "), program_name);
4975 vfprintf (stderr, message, args);
4980 warn (const char *message, ...)
4984 va_start (args, message);
4985 fprintf (stderr, _("%s: Warning: "), program_name);
4986 vfprintf (stderr, message, args);
4991 free_debug_memory (void)
4997 for (i = 0; i < max; i++)
4998 free_debug_section ((enum dwarf_section_display_enum) i);
5000 if (debug_information != NULL)
5002 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5004 for (i = 0; i < num_debug_info_entries; i++)
5006 if (!debug_information [i].max_loc_offsets)
5008 free (debug_information [i].loc_offsets);
5009 free (debug_information [i].have_frame_base);
5011 if (!debug_information [i].max_range_lists)
5012 free (debug_information [i].range_lists);
5016 free (debug_information);
5017 debug_information = NULL;
5018 num_debug_info_entries = 0;
5023 dwarf_select_sections_by_names (const char *names)
5027 const char * option;
5031 debug_dump_long_opts;
5033 static const debug_dump_long_opts opts_table [] =
5035 /* Please keep this table alpha- sorted. */
5036 { "Ranges", & do_debug_ranges, 1 },
5037 { "abbrev", & do_debug_abbrevs, 1 },
5038 { "aranges", & do_debug_aranges, 1 },
5039 { "frames", & do_debug_frames, 1 },
5040 { "frames-interp", & do_debug_frames_interp, 1 },
5041 { "info", & do_debug_info, 1 },
5042 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
5043 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5044 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5045 { "loc", & do_debug_loc, 1 },
5046 { "macro", & do_debug_macinfo, 1 },
5047 { "pubnames", & do_debug_pubnames, 1 },
5048 { "pubtypes", & do_debug_pubtypes, 1 },
5049 /* This entry is for compatability
5050 with earlier versions of readelf. */
5051 { "ranges", & do_debug_aranges, 1 },
5052 { "str", & do_debug_str, 1 },
5053 /* These trace_* sections are used by Itanium VMS. */
5054 { "trace_abbrev", & do_trace_abbrevs, 1 },
5055 { "trace_aranges", & do_trace_aranges, 1 },
5056 { "trace_info", & do_trace_info, 1 },
5065 const debug_dump_long_opts * entry;
5067 for (entry = opts_table; entry->option; entry++)
5069 size_t len = strlen (entry->option);
5071 if (strncmp (p, entry->option, len) == 0
5072 && (p[len] == ',' || p[len] == '\0'))
5074 * entry->variable |= entry->val;
5076 /* The --debug-dump=frames-interp option also
5077 enables the --debug-dump=frames option. */
5078 if (do_debug_frames_interp)
5079 do_debug_frames = 1;
5086 if (entry->option == NULL)
5088 warn (_("Unrecognized debug option '%s'\n"), p);
5089 p = strchr (p, ',');
5100 dwarf_select_sections_by_letters (const char *letters)
5102 unsigned int lindex = 0;
5104 while (letters[lindex])
5105 switch (letters[lindex++])
5112 do_debug_abbrevs = 1;
5116 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5120 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5124 do_debug_pubnames = 1;
5128 do_debug_pubtypes = 1;
5132 do_debug_aranges = 1;
5136 do_debug_ranges = 1;
5140 do_debug_frames_interp = 1;
5142 do_debug_frames = 1;
5146 do_debug_macinfo = 1;
5158 warn (_("Unrecognized debug option '%s'\n"), optarg);
5164 dwarf_select_sections_all (void)
5167 do_debug_abbrevs = 1;
5168 do_debug_lines = FLAG_DEBUG_LINES_RAW;
5169 do_debug_pubnames = 1;
5170 do_debug_pubtypes = 1;
5171 do_debug_aranges = 1;
5172 do_debug_ranges = 1;
5173 do_debug_frames = 1;
5174 do_debug_macinfo = 1;
5178 do_trace_abbrevs = 1;
5179 do_trace_aranges = 1;
5182 struct dwarf_section_display debug_displays[] =
5184 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
5185 display_debug_abbrev, &do_debug_abbrevs, 0 },
5186 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
5187 display_debug_aranges, &do_debug_aranges, 1 },
5188 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
5189 display_debug_frames, &do_debug_frames, 1 },
5190 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
5191 display_debug_info, &do_debug_info, 1 },
5192 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
5193 display_debug_lines, &do_debug_lines, 1 },
5194 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
5195 display_debug_pubnames, &do_debug_pubnames, 0 },
5196 { { ".eh_frame", "", NULL, NULL, 0, 0 },
5197 display_debug_frames, &do_debug_frames, 1 },
5198 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
5199 display_debug_macinfo, &do_debug_macinfo, 0 },
5200 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
5201 display_debug_str, &do_debug_str, 0 },
5202 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
5203 display_debug_loc, &do_debug_loc, 1 },
5204 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
5205 display_debug_pubnames, &do_debug_pubtypes, 0 },
5206 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
5207 display_debug_ranges, &do_debug_ranges, 1 },
5208 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
5209 display_debug_not_supported, NULL, 0 },
5210 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
5211 display_debug_not_supported, NULL, 0 },
5212 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
5213 display_debug_types, &do_debug_info, 1 },
5214 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
5215 display_debug_not_supported, NULL, 0 },
5216 { { ".trace_info", "", NULL, NULL, 0, 0 },
5217 display_trace_info, &do_trace_info, 1 },
5218 { { ".trace_abbrev", "", NULL, NULL, 0, 0 },
5219 display_debug_abbrev, &do_trace_abbrevs, 0 },
5220 { { ".trace_aranges", "", NULL, NULL, 0, 0 },
5221 display_debug_aranges, &do_trace_aranges, 0 }