1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2014 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
32 static const char *regname (unsigned int regno, int row);
34 static int have_frame_base;
35 static int need_base_address;
37 static unsigned int last_pointer_size = 0;
38 static int warned_about_missing_comp_units = FALSE;
40 static unsigned int num_debug_info_entries = 0;
41 static debug_info *debug_information = NULL;
42 /* Special value for num_debug_info_entries to indicate
43 that the .debug_info section could not be loaded/parsed. */
44 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
51 int do_debug_pubnames;
52 int do_debug_pubtypes;
56 int do_debug_frames_interp;
65 int do_debug_cu_index;
68 int dwarf_cutoff_level = -1;
69 unsigned long dwarf_start_die;
73 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
74 sections. For version 1 package files, each set is stored in SHNDX_POOL
75 as a zero-terminated list of section indexes comprising one set of debug
76 sections from a .dwo file. */
78 static int cu_tu_indexes_read = 0;
79 static unsigned int *shndx_pool = NULL;
80 static unsigned int shndx_pool_size = 0;
81 static unsigned int shndx_pool_used = 0;
83 /* For version 2 package files, each set contains an array of section offsets
84 and an array of section sizes, giving the offset and size of the
85 contribution from a CU or TU within one of the debug sections.
86 When displaying debug info from a package file, we need to use these
87 tables to locate the corresponding contributions to each section. */
92 dwarf_vma section_offsets[DW_SECT_MAX];
93 size_t section_sizes[DW_SECT_MAX];
96 static int cu_count = 0;
97 static int tu_count = 0;
98 static struct cu_tu_set *cu_sets = NULL;
99 static struct cu_tu_set *tu_sets = NULL;
101 static void load_cu_tu_indexes (void *file);
103 /* Values for do_debug_lines. */
104 #define FLAG_DEBUG_LINES_RAW 1
105 #define FLAG_DEBUG_LINES_DECODED 2
108 size_of_encoded_value (int encoding)
110 switch (encoding & 0x7)
113 case 0: return eh_addr_size;
121 get_encoded_value (unsigned char *data,
123 struct dwarf_section *section)
125 int size = size_of_encoded_value (encoding);
128 if (encoding & DW_EH_PE_signed)
129 val = byte_get_signed (data, size);
131 val = byte_get (data, size);
133 if ((encoding & 0x70) == DW_EH_PE_pcrel)
134 val += section->address + (data - section->start);
138 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
140 #define DWARF_VMA_FMT "ll"
141 #define DWARF_VMA_FMT_LONG "%16.16llx"
143 #define DWARF_VMA_FMT "I64"
144 #define DWARF_VMA_FMT_LONG "%016I64x"
147 #define DWARF_VMA_FMT "l"
148 #define DWARF_VMA_FMT_LONG "%16.16lx"
151 /* Convert a dwarf vma value into a string. Returns a pointer to a static
152 buffer containing the converted VALUE. The value is converted according
153 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
154 it specifies the maximum number of bytes to be displayed in the converted
155 value and FMTCH is ignored - hex is always used. */
158 dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)
160 /* As dwarf_vmatoa is used more then once in a printf call
161 for output, we are cycling through an fixed array of pointers
162 for return address. */
163 static int buf_pos = 0;
164 static struct dwarf_vmatoa_buf
170 ret = buf[buf_pos++].place;
171 buf_pos %= ARRAY_SIZE (buf);
175 /* Printf does not have a way of specifiying a maximum field width for an
176 integer value, so we print the full value into a buffer and then select
177 the precision we need. */
178 snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);
181 return ret + (16 - 2 * num_bytes);
187 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
188 snprintf (ret, sizeof (buf[0].place), fmt, value);
193 static inline const char *
194 dwarf_vmatoa (const char * fmtch, dwarf_vma value)
196 return dwarf_vmatoa_1 (fmtch, value, 0);
199 /* Print a dwarf_vma value (typically an address, offset or length) in
200 hexadecimal format, followed by a space. The length of the VALUE (and
201 hence the precision displayed) is determined by the NUM_BYTES parameter. */
204 print_dwarf_vma (dwarf_vma value, unsigned num_bytes)
206 printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));
209 /* Format a 64-bit value, given as two 32-bit values, in hex.
210 For reentrancy, this uses a buffer provided by the caller. */
213 dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
214 unsigned int buf_len)
219 snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
222 len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
223 snprintf (buf + len, buf_len - len,
224 "%08" DWARF_VMA_FMT "x", lvalue);
230 /* Read in a LEB128 encoded value starting at address DATA.
231 If SIGN is true, return a signed LEB128 value.
232 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
233 No bytes will be read at address END or beyond. */
236 read_leb128 (unsigned char *data,
237 unsigned int *length_return,
239 const unsigned char * const end)
241 dwarf_vma result = 0;
242 unsigned int num_read = 0;
243 unsigned int shift = 0;
244 unsigned char byte = 0;
251 result |= ((dwarf_vma) (byte & 0x7f)) << shift;
254 if ((byte & 0x80) == 0)
258 if (length_return != NULL)
259 *length_return = num_read;
261 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
262 result |= -1L << shift;
267 /* Create a signed version to avoid painful typecasts. */
268 static inline dwarf_signed_vma
269 read_sleb128 (unsigned char * data,
270 unsigned int * length_return,
271 const unsigned char * const end)
273 return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
276 static inline dwarf_vma
277 read_uleb128 (unsigned char * data,
278 unsigned int * length_return,
279 const unsigned char * const end)
281 return read_leb128 (data, length_return, FALSE, end);
284 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
287 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
288 unsigned int amount = (AMOUNT); \
289 if (((PTR) + amount) >= (END)) \
292 amount = (END) - (PTR); \
297 VAL = byte_get ((PTR), amount); \
303 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
306 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
311 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
314 unsigned int amount = (AMOUNT); \
315 if (((PTR) + amount) >= (END)) \
318 amount = (END) - (PTR); \
323 VAL = byte_get_signed ((PTR), amount); \
329 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
332 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
337 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
340 if (((PTR) + 8) <= (END)) \
342 byte_get_64 ((PTR), (HIGH), (LOW)); \
346 * (LOW) = * (HIGH) = 0; \
351 typedef struct State_Machine_Registers
359 unsigned char op_index;
360 unsigned char end_sequence;
361 /* This variable hold the number of the last entry seen
362 in the File Table. */
363 unsigned int last_file_entry;
366 static SMR state_machine_regs;
369 reset_state_machine (int is_stmt)
371 state_machine_regs.address = 0;
372 state_machine_regs.op_index = 0;
373 state_machine_regs.file = 1;
374 state_machine_regs.line = 1;
375 state_machine_regs.column = 0;
376 state_machine_regs.is_stmt = is_stmt;
377 state_machine_regs.basic_block = 0;
378 state_machine_regs.end_sequence = 0;
379 state_machine_regs.last_file_entry = 0;
382 /* Handled an extend line op.
383 Returns the number of bytes read. */
386 process_extended_line_op (unsigned char * data,
390 unsigned char op_code;
391 unsigned int bytes_read;
394 unsigned char *orig_data = data;
397 len = read_uleb128 (data, & bytes_read, end);
400 if (len == 0 || data == end)
402 warn (_("badly formed extended line op encountered!\n"));
409 printf (_(" Extended opcode %d: "), op_code);
413 case DW_LNE_end_sequence:
414 printf (_("End of Sequence\n\n"));
415 reset_state_machine (is_stmt);
418 case DW_LNE_set_address:
419 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
420 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
421 state_machine_regs.address = adr;
422 state_machine_regs.op_index = 0;
425 case DW_LNE_define_file:
426 printf (_("define new File Table entry\n"));
427 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
428 printf (" %d\t", ++state_machine_regs.last_file_entry);
431 data += strnlen ((char *) data, end - data) + 1;
432 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
434 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
436 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
438 printf ("%s\n\n", name);
440 if (((unsigned int) (data - orig_data) != len) || data == end)
441 warn (_("DW_LNE_define_file: Bad opcode length\n"));
444 case DW_LNE_set_discriminator:
445 printf (_("set Discriminator to %s\n"),
446 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
450 case DW_LNE_HP_negate_is_UV_update:
451 printf ("DW_LNE_HP_negate_is_UV_update\n");
453 case DW_LNE_HP_push_context:
454 printf ("DW_LNE_HP_push_context\n");
456 case DW_LNE_HP_pop_context:
457 printf ("DW_LNE_HP_pop_context\n");
459 case DW_LNE_HP_set_file_line_column:
460 printf ("DW_LNE_HP_set_file_line_column\n");
462 case DW_LNE_HP_set_routine_name:
463 printf ("DW_LNE_HP_set_routine_name\n");
465 case DW_LNE_HP_set_sequence:
466 printf ("DW_LNE_HP_set_sequence\n");
468 case DW_LNE_HP_negate_post_semantics:
469 printf ("DW_LNE_HP_negate_post_semantics\n");
471 case DW_LNE_HP_negate_function_exit:
472 printf ("DW_LNE_HP_negate_function_exit\n");
474 case DW_LNE_HP_negate_front_end_logical:
475 printf ("DW_LNE_HP_negate_front_end_logical\n");
477 case DW_LNE_HP_define_proc:
478 printf ("DW_LNE_HP_define_proc\n");
480 case DW_LNE_HP_source_file_correlation:
482 unsigned char *edata = data + len - bytes_read - 1;
484 printf ("DW_LNE_HP_source_file_correlation\n");
490 opc = read_uleb128 (data, & bytes_read, edata);
495 case DW_LNE_HP_SFC_formfeed:
496 printf (" DW_LNE_HP_SFC_formfeed\n");
498 case DW_LNE_HP_SFC_set_listing_line:
499 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
501 read_uleb128 (data, & bytes_read, edata)));
504 case DW_LNE_HP_SFC_associate:
505 printf (" DW_LNE_HP_SFC_associate ");
508 read_uleb128 (data, & bytes_read, edata)));
512 read_uleb128 (data, & bytes_read, edata)));
516 read_uleb128 (data, & bytes_read, edata)));
520 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
530 unsigned int rlen = len - bytes_read - 1;
532 if (op_code >= DW_LNE_lo_user
533 /* The test against DW_LNW_hi_user is redundant due to
534 the limited range of the unsigned char data type used
536 /*&& op_code <= DW_LNE_hi_user*/)
537 printf (_("user defined: "));
539 printf (_("UNKNOWN: "));
540 printf (_("length %d ["), rlen);
542 printf (" %02x", *data++);
551 static const unsigned char *
552 fetch_indirect_string (dwarf_vma offset)
554 struct dwarf_section *section = &debug_displays [str].section;
556 if (section->start == NULL)
557 return (const unsigned char *) _("<no .debug_str section>");
559 if (offset > section->size)
561 warn (_("DW_FORM_strp offset too big: %s\n"),
562 dwarf_vmatoa ("x", offset));
563 return (const unsigned char *) _("<offset is too big>");
566 return (const unsigned char *) section->start + offset;
570 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
571 dwarf_vma offset_size, int dwo)
573 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
574 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
575 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
576 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
577 dwarf_vma index_offset = idx * offset_size;
578 dwarf_vma str_offset;
580 if (index_section->start == NULL)
581 return (dwo ? _("<no .debug_str_offsets.dwo section>")
582 : _("<no .debug_str_offsets section>"));
584 if (this_set != NULL)
585 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
586 if (index_offset > index_section->size)
588 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
589 dwarf_vmatoa ("x", index_offset));
590 return _("<index offset is too big>");
593 if (str_section->start == NULL)
594 return (dwo ? _("<no .debug_str.dwo section>")
595 : _("<no .debug_str section>"));
597 str_offset = byte_get (index_section->start + index_offset, offset_size);
598 str_offset -= str_section->address;
599 if (str_offset > str_section->size)
601 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
602 dwarf_vmatoa ("x", str_offset));
603 return _("<indirect index offset is too big>");
606 return (const char *) str_section->start + str_offset;
610 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
612 struct dwarf_section *section = &debug_displays [debug_addr].section;
614 if (section->start == NULL)
615 return (_("<no .debug_addr section>"));
617 if (offset + bytes > section->size)
619 warn (_("Offset into section %s too big: %s\n"),
620 section->name, dwarf_vmatoa ("x", offset));
621 return "<offset too big>";
624 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
628 /* FIXME: There are better and more efficient ways to handle
629 these structures. For now though, I just want something that
630 is simple to implement. */
631 typedef struct abbrev_attr
633 unsigned long attribute;
635 struct abbrev_attr *next;
639 typedef struct abbrev_entry
644 struct abbrev_attr *first_attr;
645 struct abbrev_attr *last_attr;
646 struct abbrev_entry *next;
650 static abbrev_entry *first_abbrev = NULL;
651 static abbrev_entry *last_abbrev = NULL;
658 for (abbrv = first_abbrev; abbrv;)
660 abbrev_entry *next_abbrev = abbrv->next;
663 for (attr = abbrv->first_attr; attr;)
665 abbrev_attr *next_attr = attr->next;
675 last_abbrev = first_abbrev = NULL;
679 add_abbrev (unsigned long number, unsigned long tag, int children)
683 entry = (abbrev_entry *) malloc (sizeof (*entry));
688 entry->entry = number;
690 entry->children = children;
691 entry->first_attr = NULL;
692 entry->last_attr = NULL;
695 if (first_abbrev == NULL)
696 first_abbrev = entry;
698 last_abbrev->next = entry;
704 add_abbrev_attr (unsigned long attribute, unsigned long form)
708 attr = (abbrev_attr *) malloc (sizeof (*attr));
713 attr->attribute = attribute;
717 if (last_abbrev->first_attr == NULL)
718 last_abbrev->first_attr = attr;
720 last_abbrev->last_attr->next = attr;
722 last_abbrev->last_attr = attr;
725 /* Processes the (partial) contents of a .debug_abbrev section.
726 Returns NULL if the end of the section was encountered.
727 Returns the address after the last byte read if the end of
728 an abbreviation set was found. */
730 static unsigned char *
731 process_abbrev_section (unsigned char *start, unsigned char *end)
733 if (first_abbrev != NULL)
738 unsigned int bytes_read;
741 unsigned long attribute;
744 entry = read_uleb128 (start, & bytes_read, end);
747 /* A single zero is supposed to end the section according
748 to the standard. If there's more, then signal that to
755 tag = read_uleb128 (start, & bytes_read, end);
762 add_abbrev (entry, tag, children);
768 attribute = read_uleb128 (start, & bytes_read, end);
773 form = read_uleb128 (start, & bytes_read, end);
778 add_abbrev_attr (attribute, form);
780 while (attribute != 0);
783 /* Report the missing single zero which ends the section. */
784 error (_(".debug_abbrev section not zero terminated\n"));
790 get_TAG_name (unsigned long tag)
792 const char *name = get_DW_TAG_name ((unsigned int)tag);
796 static char buffer[100];
798 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
806 get_FORM_name (unsigned long form)
811 return "DW_FORM value: 0";
813 name = get_DW_FORM_name (form);
816 static char buffer[100];
818 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
825 static unsigned char *
826 display_block (unsigned char *data,
828 const unsigned char * const end)
832 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
834 maxlen = (dwarf_vma) (end - data);
835 length = length > maxlen ? maxlen : length;
838 printf ("%lx ", (unsigned long) byte_get (data++, 1));
844 decode_location_expression (unsigned char * data,
845 unsigned int pointer_size,
846 unsigned int offset_size,
850 struct dwarf_section * section)
853 unsigned int bytes_read;
855 dwarf_signed_vma svalue;
856 unsigned char *end = data + length;
857 int need_frame_base = 0;
866 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
867 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
870 printf ("DW_OP_deref");
873 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
874 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
877 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
878 printf ("DW_OP_const1s: %ld", (long) svalue);
881 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
882 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
885 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
886 printf ("DW_OP_const2s: %ld", (long) svalue);
889 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
890 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
893 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
894 printf ("DW_OP_const4s: %ld", (long) svalue);
897 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
898 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
899 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
900 printf ("%lu", (unsigned long) uvalue);
903 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
904 printf ("DW_OP_const8s: %ld ", (long) svalue);
905 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
906 printf ("%ld", (long) svalue);
909 printf ("DW_OP_constu: %s",
910 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
914 printf ("DW_OP_consts: %s",
915 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
919 printf ("DW_OP_dup");
922 printf ("DW_OP_drop");
925 printf ("DW_OP_over");
928 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
929 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
932 printf ("DW_OP_swap");
935 printf ("DW_OP_rot");
938 printf ("DW_OP_xderef");
941 printf ("DW_OP_abs");
944 printf ("DW_OP_and");
947 printf ("DW_OP_div");
950 printf ("DW_OP_minus");
953 printf ("DW_OP_mod");
956 printf ("DW_OP_mul");
959 printf ("DW_OP_neg");
962 printf ("DW_OP_not");
968 printf ("DW_OP_plus");
970 case DW_OP_plus_uconst:
971 printf ("DW_OP_plus_uconst: %s",
972 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
976 printf ("DW_OP_shl");
979 printf ("DW_OP_shr");
982 printf ("DW_OP_shra");
985 printf ("DW_OP_xor");
988 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
989 printf ("DW_OP_bra: %ld", (long) svalue);
1001 printf ("DW_OP_le");
1004 printf ("DW_OP_lt");
1007 printf ("DW_OP_ne");
1010 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1011 printf ("DW_OP_skip: %ld", (long) svalue);
1046 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1081 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1082 regname (op - DW_OP_reg0, 1));
1117 printf ("DW_OP_breg%d (%s): %s",
1119 regname (op - DW_OP_breg0, 1),
1120 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1125 uvalue = read_uleb128 (data, &bytes_read, end);
1127 printf ("DW_OP_regx: %s (%s)",
1128 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1131 need_frame_base = 1;
1132 printf ("DW_OP_fbreg: %s",
1133 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1137 uvalue = read_uleb128 (data, &bytes_read, end);
1139 printf ("DW_OP_bregx: %s (%s) %s",
1140 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1141 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1145 printf ("DW_OP_piece: %s",
1146 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1149 case DW_OP_deref_size:
1150 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1151 printf ("DW_OP_deref_size: %ld", (long) uvalue);
1153 case DW_OP_xderef_size:
1154 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1155 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1158 printf ("DW_OP_nop");
1161 /* DWARF 3 extensions. */
1162 case DW_OP_push_object_address:
1163 printf ("DW_OP_push_object_address");
1166 /* XXX: Strictly speaking for 64-bit DWARF3 files
1167 this ought to be an 8-byte wide computation. */
1168 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1169 printf ("DW_OP_call2: <0x%s>",
1170 dwarf_vmatoa ("x", svalue + cu_offset));
1173 /* XXX: Strictly speaking for 64-bit DWARF3 files
1174 this ought to be an 8-byte wide computation. */
1175 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1176 printf ("DW_OP_call4: <0x%s>",
1177 dwarf_vmatoa ("x", svalue + cu_offset));
1179 case DW_OP_call_ref:
1180 /* XXX: Strictly speaking for 64-bit DWARF3 files
1181 this ought to be an 8-byte wide computation. */
1182 if (dwarf_version == -1)
1184 printf (_("(DW_OP_call_ref in frame info)"));
1185 /* No way to tell where the next op is, so just bail. */
1186 return need_frame_base;
1188 if (dwarf_version == 2)
1190 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1194 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1196 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1198 case DW_OP_form_tls_address:
1199 printf ("DW_OP_form_tls_address");
1201 case DW_OP_call_frame_cfa:
1202 printf ("DW_OP_call_frame_cfa");
1204 case DW_OP_bit_piece:
1205 printf ("DW_OP_bit_piece: ");
1206 printf (_("size: %s "),
1207 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1209 printf (_("offset: %s "),
1210 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1214 /* DWARF 4 extensions. */
1215 case DW_OP_stack_value:
1216 printf ("DW_OP_stack_value");
1219 case DW_OP_implicit_value:
1220 printf ("DW_OP_implicit_value");
1221 uvalue = read_uleb128 (data, &bytes_read, end);
1223 display_block (data, uvalue, end);
1227 /* GNU extensions. */
1228 case DW_OP_GNU_push_tls_address:
1229 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1231 case DW_OP_GNU_uninit:
1232 printf ("DW_OP_GNU_uninit");
1233 /* FIXME: Is there data associated with this OP ? */
1235 case DW_OP_GNU_encoded_addr:
1241 addr = get_encoded_value (data, encoding, section);
1242 data += size_of_encoded_value (encoding);
1244 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1245 print_dwarf_vma (addr, pointer_size);
1248 case DW_OP_GNU_implicit_pointer:
1249 /* XXX: Strictly speaking for 64-bit DWARF3 files
1250 this ought to be an 8-byte wide computation. */
1251 if (dwarf_version == -1)
1253 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1254 /* No way to tell where the next op is, so just bail. */
1255 return need_frame_base;
1257 if (dwarf_version == 2)
1259 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1263 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1265 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1266 dwarf_vmatoa ("x", uvalue),
1267 dwarf_vmatoa ("d", read_sleb128 (data,
1268 &bytes_read, end)));
1271 case DW_OP_GNU_entry_value:
1272 uvalue = read_uleb128 (data, &bytes_read, end);
1274 printf ("DW_OP_GNU_entry_value: (");
1275 if (decode_location_expression (data, pointer_size, offset_size,
1276 dwarf_version, uvalue,
1277 cu_offset, section))
1278 need_frame_base = 1;
1282 case DW_OP_GNU_const_type:
1283 uvalue = read_uleb128 (data, &bytes_read, end);
1285 printf ("DW_OP_GNU_const_type: <0x%s> ",
1286 dwarf_vmatoa ("x", cu_offset + uvalue));
1287 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1288 display_block (data, uvalue, end);
1291 case DW_OP_GNU_regval_type:
1292 uvalue = read_uleb128 (data, &bytes_read, end);
1294 printf ("DW_OP_GNU_regval_type: %s (%s)",
1295 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1296 uvalue = read_uleb128 (data, &bytes_read, end);
1298 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1300 case DW_OP_GNU_deref_type:
1301 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1302 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue);
1303 uvalue = read_uleb128 (data, &bytes_read, end);
1305 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1307 case DW_OP_GNU_convert:
1308 uvalue = read_uleb128 (data, &bytes_read, end);
1310 printf ("DW_OP_GNU_convert <0x%s>",
1311 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1313 case DW_OP_GNU_reinterpret:
1314 uvalue = read_uleb128 (data, &bytes_read, end);
1316 printf ("DW_OP_GNU_reinterpret <0x%s>",
1317 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1319 case DW_OP_GNU_parameter_ref:
1320 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1321 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1322 dwarf_vmatoa ("x", cu_offset + uvalue));
1324 case DW_OP_GNU_addr_index:
1325 uvalue = read_uleb128 (data, &bytes_read, end);
1327 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1329 case DW_OP_GNU_const_index:
1330 uvalue = read_uleb128 (data, &bytes_read, end);
1332 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1335 /* HP extensions. */
1336 case DW_OP_HP_is_value:
1337 printf ("DW_OP_HP_is_value");
1338 /* FIXME: Is there data associated with this OP ? */
1340 case DW_OP_HP_fltconst4:
1341 printf ("DW_OP_HP_fltconst4");
1342 /* FIXME: Is there data associated with this OP ? */
1344 case DW_OP_HP_fltconst8:
1345 printf ("DW_OP_HP_fltconst8");
1346 /* FIXME: Is there data associated with this OP ? */
1348 case DW_OP_HP_mod_range:
1349 printf ("DW_OP_HP_mod_range");
1350 /* FIXME: Is there data associated with this OP ? */
1352 case DW_OP_HP_unmod_range:
1353 printf ("DW_OP_HP_unmod_range");
1354 /* FIXME: Is there data associated with this OP ? */
1357 printf ("DW_OP_HP_tls");
1358 /* FIXME: Is there data associated with this OP ? */
1361 /* PGI (STMicroelectronics) extensions. */
1362 case DW_OP_PGI_omp_thread_num:
1363 /* Pushes the thread number for the current thread as it would be
1364 returned by the standard OpenMP library function:
1365 omp_get_thread_num(). The "current thread" is the thread for
1366 which the expression is being evaluated. */
1367 printf ("DW_OP_PGI_omp_thread_num");
1371 if (op >= DW_OP_lo_user
1372 && op <= DW_OP_hi_user)
1373 printf (_("(User defined location op)"));
1375 printf (_("(Unknown location op)"));
1376 /* No way to tell where the next op is, so just bail. */
1377 return need_frame_base;
1380 /* Separate the ops. */
1385 return need_frame_base;
1388 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1389 This is used for DWARF package files. */
1391 static struct cu_tu_set *
1392 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1394 struct cu_tu_set *p;
1396 unsigned int dw_sect;
1402 dw_sect = DW_SECT_TYPES;
1408 dw_sect = DW_SECT_INFO;
1412 if (p->section_offsets [dw_sect] == cu_offset)
1420 /* Add INC to HIGH_BITS:LOW_BITS. */
1422 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1424 dwarf_vma tmp = * low_bits;
1428 /* FIXME: There is probably a better way of handling this:
1430 We need to cope with dwarf_vma being a 32-bit or 64-bit
1431 type. Plus regardless of its size LOW_BITS is meant to
1432 only hold 32-bits, so if there is overflow or wrap around
1433 we must propagate into HIGH_BITS. */
1434 if (tmp < * low_bits)
1438 else if (sizeof (tmp) > 8
1448 static unsigned char *
1449 read_and_display_attr_value (unsigned long attribute,
1451 unsigned char * data,
1452 unsigned char * end,
1453 dwarf_vma cu_offset,
1454 dwarf_vma pointer_size,
1455 dwarf_vma offset_size,
1457 debug_info * debug_info_p,
1459 struct dwarf_section * section,
1460 struct cu_tu_set * this_set)
1462 dwarf_vma uvalue = 0;
1463 unsigned char *block_start = NULL;
1464 unsigned char * orig_data = data;
1465 unsigned int bytes_read;
1467 if (data == end && form != DW_FORM_flag_present)
1469 warn (_("corrupt attribute\n"));
1478 case DW_FORM_ref_addr:
1479 if (dwarf_version == 2)
1480 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1481 else if (dwarf_version == 3 || dwarf_version == 4)
1482 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1484 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1489 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1493 case DW_FORM_sec_offset:
1494 case DW_FORM_GNU_ref_alt:
1495 case DW_FORM_GNU_strp_alt:
1496 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1499 case DW_FORM_flag_present:
1506 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1511 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1516 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1520 uvalue = read_sleb128 (data, & bytes_read, end);
1524 case DW_FORM_GNU_str_index:
1525 uvalue = read_uleb128 (data, & bytes_read, end);
1529 case DW_FORM_ref_udata:
1531 uvalue = read_uleb128 (data, & bytes_read, end);
1535 case DW_FORM_indirect:
1536 form = read_uleb128 (data, & bytes_read, end);
1539 printf (" %s", get_FORM_name (form));
1540 return read_and_display_attr_value (attribute, form, data, end,
1541 cu_offset, pointer_size,
1542 offset_size, dwarf_version,
1543 debug_info_p, do_loc,
1545 case DW_FORM_GNU_addr_index:
1546 uvalue = read_uleb128 (data, & bytes_read, end);
1553 case DW_FORM_ref_addr:
1555 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1558 case DW_FORM_GNU_ref_alt:
1560 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue));
1566 case DW_FORM_ref_udata:
1568 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1573 case DW_FORM_sec_offset:
1575 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1578 case DW_FORM_flag_present:
1585 printf (" %s", dwarf_vmatoa ("d", uvalue));
1592 dwarf_vma high_bits;
1596 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1598 if (form == DW_FORM_ref8)
1599 add64 (& high_bits, & utmp, cu_offset);
1601 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1604 if ((do_loc || do_debug_loc || do_debug_ranges)
1605 && num_debug_info_entries == 0)
1607 if (sizeof (uvalue) == 8)
1608 SAFE_BYTE_GET (uvalue, data, 8, end);
1610 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1616 case DW_FORM_string:
1618 printf (" %.*s", (int) (end - data), data);
1619 data += strnlen ((char *) data, end - data) + 1;
1623 case DW_FORM_exprloc:
1624 uvalue = read_uleb128 (data, & bytes_read, end);
1625 block_start = data + bytes_read;
1627 data = block_start + uvalue;
1629 data = display_block (block_start, uvalue, end);
1632 case DW_FORM_block1:
1633 SAFE_BYTE_GET (uvalue, data, 1, end);
1634 block_start = data + 1;
1636 data = block_start + uvalue;
1638 data = display_block (block_start, uvalue, end);
1641 case DW_FORM_block2:
1642 SAFE_BYTE_GET (uvalue, data, 2, end);
1643 block_start = data + 2;
1645 data = block_start + uvalue;
1647 data = display_block (block_start, uvalue, end);
1650 case DW_FORM_block4:
1651 SAFE_BYTE_GET (uvalue, data, 4, end);
1652 block_start = data + 4;
1654 data = block_start + uvalue;
1656 data = display_block (block_start, uvalue, end);
1661 printf (_(" (indirect string, offset: 0x%s): %s"),
1662 dwarf_vmatoa ("x", uvalue),
1663 fetch_indirect_string (uvalue));
1666 case DW_FORM_GNU_str_index:
1669 const char *suffix = strrchr (section->name, '.');
1670 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1672 printf (_(" (indexed string: 0x%s): %s"),
1673 dwarf_vmatoa ("x", uvalue),
1674 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1678 case DW_FORM_GNU_strp_alt:
1680 printf (_(" (alt indirect string, offset: 0x%s)"),
1681 dwarf_vmatoa ("x", uvalue));
1684 case DW_FORM_indirect:
1685 /* Handled above. */
1688 case DW_FORM_ref_sig8:
1691 dwarf_vma high_bits;
1694 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1695 printf (" signature: 0x%s",
1696 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
1701 case DW_FORM_GNU_addr_index:
1703 printf (_(" (addr_index: 0x%s): %s"),
1704 dwarf_vmatoa ("x", uvalue),
1705 fetch_indexed_value (uvalue * pointer_size, pointer_size));
1709 warn (_("Unrecognized form: %lu\n"), form);
1713 if ((do_loc || do_debug_loc || do_debug_ranges)
1714 && num_debug_info_entries == 0
1715 && debug_info_p != NULL)
1719 case DW_AT_frame_base:
1720 have_frame_base = 1;
1721 case DW_AT_location:
1722 case DW_AT_string_length:
1723 case DW_AT_return_addr:
1724 case DW_AT_data_member_location:
1725 case DW_AT_vtable_elem_location:
1727 case DW_AT_static_link:
1728 case DW_AT_use_location:
1729 case DW_AT_GNU_call_site_value:
1730 case DW_AT_GNU_call_site_data_value:
1731 case DW_AT_GNU_call_site_target:
1732 case DW_AT_GNU_call_site_target_clobbered:
1733 if ((dwarf_version < 4
1734 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1735 || form == DW_FORM_sec_offset)
1737 /* Process location list. */
1738 unsigned int lmax = debug_info_p->max_loc_offsets;
1739 unsigned int num = debug_info_p->num_loc_offsets;
1741 if (lmax == 0 || num >= lmax)
1744 debug_info_p->loc_offsets = (dwarf_vma *)
1745 xcrealloc (debug_info_p->loc_offsets,
1746 lmax, sizeof (*debug_info_p->loc_offsets));
1747 debug_info_p->have_frame_base = (int *)
1748 xcrealloc (debug_info_p->have_frame_base,
1749 lmax, sizeof (*debug_info_p->have_frame_base));
1750 debug_info_p->max_loc_offsets = lmax;
1752 if (this_set != NULL)
1753 uvalue += this_set->section_offsets [DW_SECT_LOC];
1754 debug_info_p->loc_offsets [num] = uvalue;
1755 debug_info_p->have_frame_base [num] = have_frame_base;
1756 debug_info_p->num_loc_offsets++;
1761 if (need_base_address)
1762 debug_info_p->base_address = uvalue;
1765 case DW_AT_GNU_addr_base:
1766 debug_info_p->addr_base = uvalue;
1769 case DW_AT_GNU_ranges_base:
1770 debug_info_p->ranges_base = uvalue;
1774 if ((dwarf_version < 4
1775 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1776 || form == DW_FORM_sec_offset)
1778 /* Process range list. */
1779 unsigned int lmax = debug_info_p->max_range_lists;
1780 unsigned int num = debug_info_p->num_range_lists;
1782 if (lmax == 0 || num >= lmax)
1785 debug_info_p->range_lists = (dwarf_vma *)
1786 xcrealloc (debug_info_p->range_lists,
1787 lmax, sizeof (*debug_info_p->range_lists));
1788 debug_info_p->max_range_lists = lmax;
1790 debug_info_p->range_lists [num] = uvalue;
1791 debug_info_p->num_range_lists++;
1800 if (do_loc || attribute == 0)
1803 /* For some attributes we can display further information. */
1810 case DW_INL_not_inlined:
1811 printf (_("(not inlined)"));
1813 case DW_INL_inlined:
1814 printf (_("(inlined)"));
1816 case DW_INL_declared_not_inlined:
1817 printf (_("(declared as inline but ignored)"));
1819 case DW_INL_declared_inlined:
1820 printf (_("(declared as inline and inlined)"));
1823 printf (_(" (Unknown inline attribute value: %s)"),
1824 dwarf_vmatoa ("x", uvalue));
1829 case DW_AT_language:
1833 /* Ordered by the numeric value of these constants. */
1834 case DW_LANG_C89: printf ("(ANSI C)"); break;
1835 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1836 case DW_LANG_Ada83: printf ("(Ada)"); break;
1837 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1838 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1839 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1840 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1841 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1842 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1843 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1844 /* DWARF 2.1 values. */
1845 case DW_LANG_Java: printf ("(Java)"); break;
1846 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1847 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1848 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1849 /* DWARF 3 values. */
1850 case DW_LANG_PLI: printf ("(PLI)"); break;
1851 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1852 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1853 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1854 case DW_LANG_D: printf ("(D)"); break;
1855 /* DWARF 4 values. */
1856 case DW_LANG_Python: printf ("(Python)"); break;
1857 /* DWARF 5 values. */
1858 case DW_LANG_Go: printf ("(Go)"); break;
1859 /* MIPS extension. */
1860 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1861 /* UPC extension. */
1862 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1864 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1865 printf (_("(implementation defined: %s)"),
1866 dwarf_vmatoa ("x", uvalue));
1868 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
1873 case DW_AT_encoding:
1877 case DW_ATE_void: printf ("(void)"); break;
1878 case DW_ATE_address: printf ("(machine address)"); break;
1879 case DW_ATE_boolean: printf ("(boolean)"); break;
1880 case DW_ATE_complex_float: printf ("(complex float)"); break;
1881 case DW_ATE_float: printf ("(float)"); break;
1882 case DW_ATE_signed: printf ("(signed)"); break;
1883 case DW_ATE_signed_char: printf ("(signed char)"); break;
1884 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1885 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1886 /* DWARF 2.1 values: */
1887 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1888 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1889 /* DWARF 3 values: */
1890 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1891 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1892 case DW_ATE_edited: printf ("(edited)"); break;
1893 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1894 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1895 /* HP extensions: */
1896 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1897 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1898 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1899 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1900 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1901 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1902 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1905 if (uvalue >= DW_ATE_lo_user
1906 && uvalue <= DW_ATE_hi_user)
1907 printf (_("(user defined type)"));
1909 printf (_("(unknown type)"));
1914 case DW_AT_accessibility:
1918 case DW_ACCESS_public: printf ("(public)"); break;
1919 case DW_ACCESS_protected: printf ("(protected)"); break;
1920 case DW_ACCESS_private: printf ("(private)"); break;
1922 printf (_("(unknown accessibility)"));
1927 case DW_AT_visibility:
1931 case DW_VIS_local: printf ("(local)"); break;
1932 case DW_VIS_exported: printf ("(exported)"); break;
1933 case DW_VIS_qualified: printf ("(qualified)"); break;
1934 default: printf (_("(unknown visibility)")); break;
1938 case DW_AT_virtuality:
1942 case DW_VIRTUALITY_none: printf ("(none)"); break;
1943 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1944 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1945 default: printf (_("(unknown virtuality)")); break;
1949 case DW_AT_identifier_case:
1953 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1954 case DW_ID_up_case: printf ("(up_case)"); break;
1955 case DW_ID_down_case: printf ("(down_case)"); break;
1956 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1957 default: printf (_("(unknown case)")); break;
1961 case DW_AT_calling_convention:
1965 case DW_CC_normal: printf ("(normal)"); break;
1966 case DW_CC_program: printf ("(program)"); break;
1967 case DW_CC_nocall: printf ("(nocall)"); break;
1969 if (uvalue >= DW_CC_lo_user
1970 && uvalue <= DW_CC_hi_user)
1971 printf (_("(user defined)"));
1973 printf (_("(unknown convention)"));
1977 case DW_AT_ordering:
1981 case -1: printf (_("(undefined)")); break;
1982 case 0: printf ("(row major)"); break;
1983 case 1: printf ("(column major)"); break;
1987 case DW_AT_frame_base:
1988 have_frame_base = 1;
1989 case DW_AT_location:
1990 case DW_AT_string_length:
1991 case DW_AT_return_addr:
1992 case DW_AT_data_member_location:
1993 case DW_AT_vtable_elem_location:
1995 case DW_AT_static_link:
1996 case DW_AT_use_location:
1997 case DW_AT_GNU_call_site_value:
1998 case DW_AT_GNU_call_site_data_value:
1999 case DW_AT_GNU_call_site_target:
2000 case DW_AT_GNU_call_site_target_clobbered:
2001 if ((dwarf_version < 4
2002 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2003 || form == DW_FORM_sec_offset)
2004 printf (_(" (location list)"));
2006 case DW_AT_allocated:
2007 case DW_AT_associated:
2008 case DW_AT_data_location:
2010 case DW_AT_upper_bound:
2011 case DW_AT_lower_bound:
2014 int need_frame_base;
2017 need_frame_base = decode_location_expression (block_start,
2022 cu_offset, section);
2024 if (need_frame_base && !have_frame_base)
2025 printf (_(" [without DW_AT_frame_base]"));
2031 if (form == DW_FORM_ref_sig8
2032 || form == DW_FORM_GNU_ref_alt)
2035 if (form == DW_FORM_ref1
2036 || form == DW_FORM_ref2
2037 || form == DW_FORM_ref4
2038 || form == DW_FORM_ref_udata)
2039 uvalue += cu_offset;
2041 if (uvalue >= section->size)
2042 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2043 dwarf_vmatoa ("x", uvalue),
2044 (unsigned long) (orig_data - section->start));
2047 unsigned long abbrev_number;
2048 abbrev_entry * entry;
2050 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2052 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2053 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2054 use different abbrev table, and we don't track .debug_info chunks
2056 if (form != DW_FORM_ref_addr)
2058 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2059 if (entry->entry == abbrev_number)
2062 printf (" (%s)", get_TAG_name (entry->tag));
2077 get_AT_name (unsigned long attribute)
2082 return "DW_AT value: 0";
2084 /* One value is shared by the MIPS and HP extensions: */
2085 if (attribute == DW_AT_MIPS_fde)
2086 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2088 name = get_DW_AT_name (attribute);
2092 static char buffer[100];
2094 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2102 static unsigned char *
2103 read_and_display_attr (unsigned long attribute,
2105 unsigned char * data,
2106 unsigned char * end,
2107 dwarf_vma cu_offset,
2108 dwarf_vma pointer_size,
2109 dwarf_vma offset_size,
2111 debug_info * debug_info_p,
2113 struct dwarf_section * section,
2114 struct cu_tu_set * this_set)
2117 printf (" %-18s:", get_AT_name (attribute));
2118 data = read_and_display_attr_value (attribute, form, data, end,
2119 cu_offset, pointer_size, offset_size,
2120 dwarf_version, debug_info_p,
2121 do_loc, section, this_set);
2127 /* Process the contents of a .debug_info section. If do_loc is non-zero
2128 then we are scanning for location lists and we do not want to display
2129 anything to the user. If do_types is non-zero, we are processing
2130 a .debug_types section instead of a .debug_info section. */
2133 process_debug_info (struct dwarf_section *section,
2135 enum dwarf_section_display_enum abbrev_sec,
2139 unsigned char *start = section->start;
2140 unsigned char *end = start + section->size;
2141 unsigned char *section_begin;
2143 unsigned int num_units = 0;
2145 if ((do_loc || do_debug_loc || do_debug_ranges)
2146 && num_debug_info_entries == 0
2151 /* First scan the section to get the number of comp units. */
2152 for (section_begin = start, num_units = 0; section_begin < end;
2155 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2156 will be the length. For a 64-bit DWARF section, it'll be
2157 the escape code 0xffffffff followed by an 8 byte length. */
2158 SAFE_BYTE_GET (length, section_begin, 4, end);
2160 if (length == 0xffffffff)
2162 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2163 section_begin += length + 12;
2165 else if (length >= 0xfffffff0 && length < 0xffffffff)
2167 warn (_("Reserved length value (0x%s) found in section %s\n"),
2168 dwarf_vmatoa ("x", length), section->name);
2172 section_begin += length + 4;
2174 /* Negative values are illegal, they may even cause infinite
2175 looping. This can happen if we can't accurately apply
2176 relocations to an object file. */
2177 if ((signed long) length <= 0)
2179 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2180 dwarf_vmatoa ("x", length), section->name);
2187 error (_("No comp units in %s section ?"), section->name);
2191 /* Then allocate an array to hold the information. */
2192 debug_information = (debug_info *) cmalloc (num_units,
2193 sizeof (* debug_information));
2194 if (debug_information == NULL)
2196 error (_("Not enough memory for a debug info array of %u entries"),
2204 if (dwarf_start_die == 0)
2205 printf (_("Contents of the %s section:\n\n"), section->name);
2207 load_debug_section (str, file);
2208 load_debug_section (str_dwo, file);
2209 load_debug_section (str_index, file);
2210 load_debug_section (str_index_dwo, file);
2211 load_debug_section (debug_addr, file);
2214 load_debug_section (abbrev_sec, file);
2215 if (debug_displays [abbrev_sec].section.start == NULL)
2217 warn (_("Unable to locate %s section!\n"),
2218 debug_displays [abbrev_sec].section.name);
2222 for (section_begin = start, unit = 0; start < end; unit++)
2224 DWARF2_Internal_CompUnit compunit;
2225 unsigned char *hdrptr;
2226 unsigned char *tags;
2227 int level, last_level, saved_level;
2228 dwarf_vma cu_offset;
2229 unsigned int offset_size;
2230 int initial_length_size;
2231 dwarf_vma signature_high = 0;
2232 dwarf_vma signature_low = 0;
2233 dwarf_vma type_offset = 0;
2234 struct cu_tu_set *this_set;
2235 dwarf_vma abbrev_base;
2240 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2242 if (compunit.cu_length == 0xffffffff)
2244 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2246 initial_length_size = 12;
2251 initial_length_size = 4;
2254 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2256 cu_offset = start - section_begin;
2258 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2260 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2262 if (this_set == NULL)
2265 abbrev_size = debug_displays [abbrev_sec].section.size;
2269 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2270 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2273 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2277 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2279 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2282 if ((do_loc || do_debug_loc || do_debug_ranges)
2283 && num_debug_info_entries == 0
2286 debug_information [unit].cu_offset = cu_offset;
2287 debug_information [unit].pointer_size
2288 = compunit.cu_pointer_size;
2289 debug_information [unit].offset_size = offset_size;
2290 debug_information [unit].dwarf_version = compunit.cu_version;
2291 debug_information [unit].base_address = 0;
2292 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2293 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2294 debug_information [unit].loc_offsets = NULL;
2295 debug_information [unit].have_frame_base = NULL;
2296 debug_information [unit].max_loc_offsets = 0;
2297 debug_information [unit].num_loc_offsets = 0;
2298 debug_information [unit].range_lists = NULL;
2299 debug_information [unit].max_range_lists= 0;
2300 debug_information [unit].num_range_lists = 0;
2303 if (!do_loc && dwarf_start_die == 0)
2305 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2306 dwarf_vmatoa ("x", cu_offset));
2307 printf (_(" Length: 0x%s (%s)\n"),
2308 dwarf_vmatoa ("x", compunit.cu_length),
2309 offset_size == 8 ? "64-bit" : "32-bit");
2310 printf (_(" Version: %d\n"), compunit.cu_version);
2311 printf (_(" Abbrev Offset: 0x%s\n"),
2312 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2313 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2318 printf (_(" Signature: 0x%s\n"),
2319 dwarf_vmatoa64 (signature_high, signature_low,
2320 buf, sizeof (buf)));
2321 printf (_(" Type Offset: 0x%s\n"),
2322 dwarf_vmatoa ("x", type_offset));
2324 if (this_set != NULL)
2326 dwarf_vma *offsets = this_set->section_offsets;
2327 size_t *sizes = this_set->section_sizes;
2329 printf (_(" Section contributions:\n"));
2330 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2331 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2332 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2333 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2334 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2335 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2336 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2337 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2338 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2339 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2340 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2341 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2345 if (cu_offset + compunit.cu_length + initial_length_size
2348 warn (_("Debug info is corrupted, length of CU at %s"
2349 " extends beyond end of section (length = %s)\n"),
2350 dwarf_vmatoa ("x", cu_offset),
2351 dwarf_vmatoa ("x", compunit.cu_length));
2355 start += compunit.cu_length + initial_length_size;
2357 if (compunit.cu_version != 2
2358 && compunit.cu_version != 3
2359 && compunit.cu_version != 4)
2361 warn (_("CU at offset %s contains corrupt or "
2362 "unsupported version number: %d.\n"),
2363 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2369 /* Process the abbrevs used by this compilation unit. */
2370 if (compunit.cu_abbrev_offset >= abbrev_size)
2371 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2372 (unsigned long) compunit.cu_abbrev_offset,
2373 (unsigned long) abbrev_size);
2375 process_abbrev_section
2376 (((unsigned char *) debug_displays [abbrev_sec].section.start
2377 + abbrev_base + compunit.cu_abbrev_offset),
2378 ((unsigned char *) debug_displays [abbrev_sec].section.start
2379 + abbrev_base + abbrev_size));
2384 while (tags < start)
2386 unsigned int bytes_read;
2387 unsigned long abbrev_number;
2388 unsigned long die_offset;
2389 abbrev_entry *entry;
2391 int do_printing = 1;
2393 die_offset = tags - section_begin;
2395 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2398 /* A null DIE marks the end of a list of siblings or it may also be
2399 a section padding. */
2400 if (abbrev_number == 0)
2402 /* Check if it can be a section padding for the last CU. */
2403 if (level == 0 && start == end)
2407 for (chk = tags; chk < start; chk++)
2414 if (!do_loc && die_offset >= dwarf_start_die
2415 && (dwarf_cutoff_level == -1
2416 || level < dwarf_cutoff_level))
2417 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2423 static unsigned num_bogus_warns = 0;
2425 if (num_bogus_warns < 3)
2427 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2428 die_offset, section->name);
2430 if (num_bogus_warns == 3)
2431 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2434 if (dwarf_start_die != 0 && level < saved_level)
2441 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2445 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2446 saved_level = level;
2447 do_printing = (dwarf_cutoff_level == -1
2448 || level < dwarf_cutoff_level);
2450 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2451 level, die_offset, abbrev_number);
2452 else if (dwarf_cutoff_level == -1
2453 || last_level < dwarf_cutoff_level)
2454 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2459 /* Scan through the abbreviation list until we reach the
2461 for (entry = first_abbrev;
2462 entry && entry->entry != abbrev_number;
2463 entry = entry->next)
2468 if (!do_loc && do_printing)
2473 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2474 die_offset, abbrev_number);
2478 if (!do_loc && do_printing)
2479 printf (" (%s)\n", get_TAG_name (entry->tag));
2484 need_base_address = 0;
2486 case DW_TAG_compile_unit:
2487 need_base_address = 1;
2489 case DW_TAG_entry_point:
2490 case DW_TAG_subprogram:
2491 need_base_address = 0;
2492 /* Assuming that there is no DW_AT_frame_base. */
2493 have_frame_base = 0;
2497 for (attr = entry->first_attr;
2498 attr && attr->attribute;
2503 if (! do_loc && do_printing)
2504 /* Show the offset from where the tag was extracted. */
2505 printf (" <%lx>", (unsigned long)(tags - section_begin));
2507 arg = debug_information;
2508 if (debug_information)
2511 tags = read_and_display_attr (attr->attribute,
2516 compunit.cu_pointer_size,
2518 compunit.cu_version,
2520 do_loc || ! do_printing,
2525 if (entry->children)
2530 /* Set num_debug_info_entries here so that it can be used to check if
2531 we need to process .debug_loc and .debug_ranges sections. */
2532 if ((do_loc || do_debug_loc || do_debug_ranges)
2533 && num_debug_info_entries == 0
2535 num_debug_info_entries = num_units;
2543 /* Locate and scan the .debug_info section in the file and record the pointer
2544 sizes and offsets for the compilation units in it. Usually an executable
2545 will have just one pointer size, but this is not guaranteed, and so we try
2546 not to make any assumptions. Returns zero upon failure, or the number of
2547 compilation units upon success. */
2550 load_debug_info (void * file)
2552 /* Reset the last pointer size so that we can issue correct error
2553 messages if we are displaying the contents of more than one section. */
2554 last_pointer_size = 0;
2555 warned_about_missing_comp_units = FALSE;
2557 /* If we have already tried and failed to load the .debug_info
2558 section then do not bother to repeat the task. */
2559 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2562 /* If we already have the information there is nothing else to do. */
2563 if (num_debug_info_entries > 0)
2564 return num_debug_info_entries;
2566 /* If this is a DWARF package file, load the CU and TU indexes. */
2567 load_cu_tu_indexes (file);
2569 if (load_debug_section (info, file)
2570 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2571 return num_debug_info_entries;
2572 else if (load_debug_section (info_dwo, file)
2573 && process_debug_info (&debug_displays [info_dwo].section, file,
2575 return num_debug_info_entries;
2577 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2581 /* Read a DWARF .debug_line section header starting at DATA.
2582 Upon success returns an updated DATA pointer and the LINFO
2583 structure and the END_OF_SEQUENCE pointer will be filled in.
2584 Otherwise returns NULL. */
2586 static unsigned char *
2587 read_debug_line_header (struct dwarf_section * section,
2588 unsigned char * data,
2589 unsigned char * end,
2590 DWARF2_Internal_LineInfo * linfo,
2591 unsigned char ** end_of_sequence)
2593 unsigned char *hdrptr;
2594 unsigned int offset_size;
2595 unsigned int initial_length_size;
2597 /* Extract information from the Line Number Program Header.
2598 (section 6.2.4 in the Dwarf3 doc). */
2601 /* Get and check the length of the block. */
2602 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2604 if (linfo->li_length == 0xffffffff)
2606 /* This section is 64-bit DWARF 3. */
2607 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2609 initial_length_size = 12;
2614 initial_length_size = 4;
2617 if (linfo->li_length + initial_length_size > section->size)
2619 /* If the length is just a bias against the initial_length_size then
2620 this means that the field has a relocation against it which has not
2621 been applied. (Ie we are dealing with an object file, not a linked
2622 binary). Do not complain but instead assume that the rest of the
2623 section applies to this particular header. */
2624 if (linfo->li_length == - initial_length_size)
2626 linfo->li_length = section->size - initial_length_size;
2630 warn (_("The line info appears to be corrupt - "
2631 "the section is too small\n"));
2636 /* Get and check the version number. */
2637 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2639 if (linfo->li_version != 2
2640 && linfo->li_version != 3
2641 && linfo->li_version != 4)
2643 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2647 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2648 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2650 if (linfo->li_version >= 4)
2652 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2654 if (linfo->li_max_ops_per_insn == 0)
2656 warn (_("Invalid maximum operations per insn.\n"));
2661 linfo->li_max_ops_per_insn = 1;
2663 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2664 SAFE_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2665 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2666 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2668 /* Sign extend the line base field. */
2669 linfo->li_line_base <<= 24;
2670 linfo->li_line_base >>= 24;
2672 * end_of_sequence = data + linfo->li_length + initial_length_size;
2677 display_debug_lines_raw (struct dwarf_section *section,
2678 unsigned char *data,
2681 unsigned char *start = section->start;
2683 printf (_("Raw dump of debug contents of section %s:\n\n"),
2688 static DWARF2_Internal_LineInfo saved_linfo;
2689 DWARF2_Internal_LineInfo linfo;
2690 unsigned char *standard_opcodes;
2691 unsigned char *end_of_sequence;
2692 unsigned int last_dir_entry = 0;
2695 if (const_strneq (section->name, ".debug_line.")
2696 /* Note: the following does not apply to .debug_line.dwo sections.
2697 These are full debug_line sections. */
2698 && strcmp (section->name, ".debug_line.dwo") != 0)
2700 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2701 section containing just the Line Number Statements. They are
2702 created by the assembler and intended to be used alongside gcc's
2703 -ffunction-sections command line option. When the linker's
2704 garbage collection decides to discard a .text.<foo> section it
2705 can then also discard the line number information in .debug_line.<foo>.
2707 Since the section is a fragment it does not have the details
2708 needed to fill out a LineInfo structure, so instead we use the
2709 details from the last full debug_line section that we processed. */
2710 end_of_sequence = end;
2711 standard_opcodes = NULL;
2712 linfo = saved_linfo;
2713 reset_state_machine (linfo.li_default_is_stmt);
2717 unsigned char * hdrptr;
2719 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2720 & end_of_sequence)) == NULL)
2723 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
2724 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2725 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2726 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2727 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2728 if (linfo.li_version >= 4)
2729 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2730 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2731 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2732 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2733 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2735 reset_state_machine (linfo.li_default_is_stmt);
2737 /* Display the contents of the Opcodes table. */
2738 standard_opcodes = hdrptr;
2740 printf (_("\n Opcodes:\n"));
2742 for (i = 1; i < linfo.li_opcode_base; i++)
2743 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2745 /* Display the contents of the Directory table. */
2746 data = standard_opcodes + linfo.li_opcode_base - 1;
2749 printf (_("\n The Directory Table is empty.\n"));
2752 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2753 (long)(data - start));
2757 printf (" %d\t%s\n", ++last_dir_entry, data);
2759 data += strnlen ((char *) data, end - data) + 1;
2763 /* Skip the NUL at the end of the table. */
2766 /* Display the contents of the File Name table. */
2768 printf (_("\n The File Name Table is empty.\n"));
2771 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2772 (long)(data - start));
2773 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2777 unsigned char *name;
2778 unsigned int bytes_read;
2780 printf (" %d\t", ++state_machine_regs.last_file_entry);
2782 data += strnlen ((char *) data, end - data) + 1;
2785 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2788 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2791 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2793 printf ("%s\n", name);
2797 warn (_("Corrupt file name table entry\n"));
2803 /* Skip the NUL at the end of the table. */
2806 saved_linfo = linfo;
2809 /* Now display the statements. */
2810 if (data >= end_of_sequence)
2811 printf (_(" No Line Number Statements.\n"));
2814 printf (_(" Line Number Statements:\n"));
2816 while (data < end_of_sequence)
2818 unsigned char op_code;
2819 dwarf_signed_vma adv;
2821 unsigned int bytes_read;
2823 printf (" [0x%08lx]", (long)(data - start));
2827 if (op_code >= linfo.li_opcode_base)
2829 op_code -= linfo.li_opcode_base;
2830 uladv = (op_code / linfo.li_line_range);
2831 if (linfo.li_max_ops_per_insn == 1)
2833 uladv *= linfo.li_min_insn_length;
2834 state_machine_regs.address += uladv;
2835 printf (_(" Special opcode %d: "
2836 "advance Address by %s to 0x%s"),
2837 op_code, dwarf_vmatoa ("u", uladv),
2838 dwarf_vmatoa ("x", state_machine_regs.address));
2842 state_machine_regs.address
2843 += ((state_machine_regs.op_index + uladv)
2844 / linfo.li_max_ops_per_insn)
2845 * linfo.li_min_insn_length;
2846 state_machine_regs.op_index
2847 = (state_machine_regs.op_index + uladv)
2848 % linfo.li_max_ops_per_insn;
2849 printf (_(" Special opcode %d: "
2850 "advance Address by %s to 0x%s[%d]"),
2851 op_code, dwarf_vmatoa ("u", uladv),
2852 dwarf_vmatoa ("x", state_machine_regs.address),
2853 state_machine_regs.op_index);
2855 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2856 state_machine_regs.line += adv;
2857 printf (_(" and Line by %s to %d\n"),
2858 dwarf_vmatoa ("d", adv), state_machine_regs.line);
2860 else switch (op_code)
2862 case DW_LNS_extended_op:
2863 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
2867 printf (_(" Copy\n"));
2870 case DW_LNS_advance_pc:
2871 uladv = read_uleb128 (data, & bytes_read, end);
2873 if (linfo.li_max_ops_per_insn == 1)
2875 uladv *= linfo.li_min_insn_length;
2876 state_machine_regs.address += uladv;
2877 printf (_(" Advance PC by %s to 0x%s\n"),
2878 dwarf_vmatoa ("u", uladv),
2879 dwarf_vmatoa ("x", state_machine_regs.address));
2883 state_machine_regs.address
2884 += ((state_machine_regs.op_index + uladv)
2885 / linfo.li_max_ops_per_insn)
2886 * linfo.li_min_insn_length;
2887 state_machine_regs.op_index
2888 = (state_machine_regs.op_index + uladv)
2889 % linfo.li_max_ops_per_insn;
2890 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2891 dwarf_vmatoa ("u", uladv),
2892 dwarf_vmatoa ("x", state_machine_regs.address),
2893 state_machine_regs.op_index);
2897 case DW_LNS_advance_line:
2898 adv = read_sleb128 (data, & bytes_read, end);
2900 state_machine_regs.line += adv;
2901 printf (_(" Advance Line by %s to %d\n"),
2902 dwarf_vmatoa ("d", adv),
2903 state_machine_regs.line);
2906 case DW_LNS_set_file:
2907 adv = read_uleb128 (data, & bytes_read, end);
2909 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2910 dwarf_vmatoa ("d", adv));
2911 state_machine_regs.file = adv;
2914 case DW_LNS_set_column:
2915 uladv = read_uleb128 (data, & bytes_read, end);
2917 printf (_(" Set column to %s\n"),
2918 dwarf_vmatoa ("u", uladv));
2919 state_machine_regs.column = uladv;
2922 case DW_LNS_negate_stmt:
2923 adv = state_machine_regs.is_stmt;
2925 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2926 state_machine_regs.is_stmt = adv;
2929 case DW_LNS_set_basic_block:
2930 printf (_(" Set basic block\n"));
2931 state_machine_regs.basic_block = 1;
2934 case DW_LNS_const_add_pc:
2935 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2936 if (linfo.li_max_ops_per_insn)
2938 uladv *= linfo.li_min_insn_length;
2939 state_machine_regs.address += uladv;
2940 printf (_(" Advance PC by constant %s to 0x%s\n"),
2941 dwarf_vmatoa ("u", uladv),
2942 dwarf_vmatoa ("x", state_machine_regs.address));
2946 state_machine_regs.address
2947 += ((state_machine_regs.op_index + uladv)
2948 / linfo.li_max_ops_per_insn)
2949 * linfo.li_min_insn_length;
2950 state_machine_regs.op_index
2951 = (state_machine_regs.op_index + uladv)
2952 % linfo.li_max_ops_per_insn;
2953 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2954 dwarf_vmatoa ("u", uladv),
2955 dwarf_vmatoa ("x", state_machine_regs.address),
2956 state_machine_regs.op_index);
2960 case DW_LNS_fixed_advance_pc:
2961 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
2962 state_machine_regs.address += uladv;
2963 state_machine_regs.op_index = 0;
2964 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2965 dwarf_vmatoa ("u", uladv),
2966 dwarf_vmatoa ("x", state_machine_regs.address));
2969 case DW_LNS_set_prologue_end:
2970 printf (_(" Set prologue_end to true\n"));
2973 case DW_LNS_set_epilogue_begin:
2974 printf (_(" Set epilogue_begin to true\n"));
2977 case DW_LNS_set_isa:
2978 uladv = read_uleb128 (data, & bytes_read, end);
2980 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2984 printf (_(" Unknown opcode %d with operands: "), op_code);
2986 if (standard_opcodes != NULL)
2987 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2989 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
2991 i == 1 ? "" : ", ");
3007 unsigned char *name;
3008 unsigned int directory_index;
3009 unsigned int modification_date;
3010 unsigned int length;
3013 /* Output a decoded representation of the .debug_line section. */
3016 display_debug_lines_decoded (struct dwarf_section *section,
3017 unsigned char *data,
3020 static DWARF2_Internal_LineInfo saved_linfo;
3022 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3027 /* This loop amounts to one iteration per compilation unit. */
3028 DWARF2_Internal_LineInfo linfo;
3029 unsigned char *standard_opcodes;
3030 unsigned char *end_of_sequence;
3032 File_Entry *file_table = NULL;
3033 unsigned int n_files = 0;
3034 unsigned char **directory_table = NULL;
3035 unsigned int n_directories = 0;
3037 if (const_strneq (section->name, ".debug_line.")
3038 /* Note: the following does not apply to .debug_line.dwo sections.
3039 These are full debug_line sections. */
3040 && strcmp (section->name, ".debug_line.dwo") != 0)
3042 /* See comment in display_debug_lines_raw(). */
3043 end_of_sequence = end;
3044 standard_opcodes = NULL;
3045 linfo = saved_linfo;
3046 reset_state_machine (linfo.li_default_is_stmt);
3050 unsigned char *hdrptr;
3052 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3053 & end_of_sequence)) == NULL)
3056 reset_state_machine (linfo.li_default_is_stmt);
3058 /* Save a pointer to the contents of the Opcodes table. */
3059 standard_opcodes = hdrptr;
3061 /* Traverse the Directory table just to count entries. */
3062 data = standard_opcodes + linfo.li_opcode_base - 1;
3065 unsigned char *ptr_directory_table = data;
3069 data += strnlen ((char *) data, end - data) + 1;
3073 /* Go through the directory table again to save the directories. */
3074 directory_table = (unsigned char **)
3075 xmalloc (n_directories * sizeof (unsigned char *));
3078 while (*ptr_directory_table != 0)
3080 directory_table[i] = ptr_directory_table;
3081 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3082 ptr_directory_table - end) + 1;
3086 /* Skip the NUL at the end of the table. */
3089 /* Traverse the File Name table just to count the entries. */
3092 unsigned char *ptr_file_name_table = data;
3096 unsigned int bytes_read;
3098 /* Skip Name, directory index, last modification time and length
3100 data += strnlen ((char *) data, end - data) + 1;
3101 read_uleb128 (data, & bytes_read, end);
3103 read_uleb128 (data, & bytes_read, end);
3105 read_uleb128 (data, & bytes_read, end);
3111 /* Go through the file table again to save the strings. */
3112 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3115 while (*ptr_file_name_table != 0)
3117 unsigned int bytes_read;
3119 file_table[i].name = ptr_file_name_table;
3120 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3121 end - ptr_file_name_table) + 1;
3123 /* We are not interested in directory, time or size. */
3124 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3126 ptr_file_name_table += bytes_read;
3127 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3129 ptr_file_name_table += bytes_read;
3130 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3131 ptr_file_name_table += bytes_read;
3136 /* Print the Compilation Unit's name and a header. */
3137 if (directory_table == NULL)
3139 printf (_("CU: %s:\n"), file_table[0].name);
3140 printf (_("File name Line number Starting address\n"));
3144 unsigned int ix = file_table[0].directory_index;
3145 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3147 if (do_wide || strlen (directory) < 76)
3148 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3150 printf ("%s:\n", file_table[0].name);
3152 printf (_("File name Line number Starting address\n"));
3156 /* Skip the NUL at the end of the table. */
3159 saved_linfo = linfo;
3162 /* This loop iterates through the Dwarf Line Number Program. */
3163 while (data < end_of_sequence)
3165 unsigned char op_code;
3167 unsigned long int uladv;
3168 unsigned int bytes_read;
3169 int is_special_opcode = 0;
3173 if (op_code >= linfo.li_opcode_base)
3175 op_code -= linfo.li_opcode_base;
3176 uladv = (op_code / linfo.li_line_range);
3177 if (linfo.li_max_ops_per_insn == 1)
3179 uladv *= linfo.li_min_insn_length;
3180 state_machine_regs.address += uladv;
3184 state_machine_regs.address
3185 += ((state_machine_regs.op_index + uladv)
3186 / linfo.li_max_ops_per_insn)
3187 * linfo.li_min_insn_length;
3188 state_machine_regs.op_index
3189 = (state_machine_regs.op_index + uladv)
3190 % linfo.li_max_ops_per_insn;
3193 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3194 state_machine_regs.line += adv;
3195 is_special_opcode = 1;
3197 else switch (op_code)
3199 case DW_LNS_extended_op:
3201 unsigned int ext_op_code_len;
3202 unsigned char ext_op_code;
3203 unsigned char *op_code_data = data;
3205 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3207 op_code_data += bytes_read;
3209 if (ext_op_code_len == 0)
3211 warn (_("badly formed extended line op encountered!\n"));
3214 ext_op_code_len += bytes_read;
3215 ext_op_code = *op_code_data++;
3217 switch (ext_op_code)
3219 case DW_LNE_end_sequence:
3220 reset_state_machine (linfo.li_default_is_stmt);
3222 case DW_LNE_set_address:
3223 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3225 ext_op_code_len - bytes_read - 1,
3227 state_machine_regs.op_index = 0;
3229 case DW_LNE_define_file:
3231 file_table = (File_Entry *) xrealloc
3232 (file_table, (n_files + 1) * sizeof (File_Entry));
3234 ++state_machine_regs.last_file_entry;
3235 /* Source file name. */
3236 file_table[n_files].name = op_code_data;
3237 op_code_data += strlen ((char *) op_code_data) + 1;
3238 /* Directory index. */
3239 file_table[n_files].directory_index =
3240 read_uleb128 (op_code_data, & bytes_read,
3242 op_code_data += bytes_read;
3243 /* Last modification time. */
3244 file_table[n_files].modification_date =
3245 read_uleb128 (op_code_data, & bytes_read,
3247 op_code_data += bytes_read;
3249 file_table[n_files].length =
3250 read_uleb128 (op_code_data, & bytes_read,
3256 case DW_LNE_set_discriminator:
3257 case DW_LNE_HP_set_sequence:
3258 /* Simply ignored. */
3262 printf (_("UNKNOWN (%u): length %d\n"),
3263 ext_op_code, ext_op_code_len - bytes_read);
3266 data += ext_op_code_len;
3272 case DW_LNS_advance_pc:
3273 uladv = read_uleb128 (data, & bytes_read, end);
3275 if (linfo.li_max_ops_per_insn == 1)
3277 uladv *= linfo.li_min_insn_length;
3278 state_machine_regs.address += uladv;
3282 state_machine_regs.address
3283 += ((state_machine_regs.op_index + uladv)
3284 / linfo.li_max_ops_per_insn)
3285 * linfo.li_min_insn_length;
3286 state_machine_regs.op_index
3287 = (state_machine_regs.op_index + uladv)
3288 % linfo.li_max_ops_per_insn;
3292 case DW_LNS_advance_line:
3293 adv = read_sleb128 (data, & bytes_read, end);
3295 state_machine_regs.line += adv;
3298 case DW_LNS_set_file:
3299 adv = read_uleb128 (data, & bytes_read, end);
3301 state_machine_regs.file = adv;
3303 if (file_table == NULL)
3304 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3305 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3306 /* If directory index is 0, that means current directory. */
3307 printf ("\n./%s:[++]\n",
3308 file_table[state_machine_regs.file - 1].name);
3309 else if (directory_table == NULL)
3310 printf (_("\n [Use directory table entry %d]\n"),
3311 file_table[state_machine_regs.file - 1].directory_index - 1);
3313 /* The directory index starts counting at 1. */
3314 printf ("\n%s/%s:\n",
3315 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3316 file_table[state_machine_regs.file - 1].name);
3319 case DW_LNS_set_column:
3320 uladv = read_uleb128 (data, & bytes_read, end);
3322 state_machine_regs.column = uladv;
3325 case DW_LNS_negate_stmt:
3326 adv = state_machine_regs.is_stmt;
3328 state_machine_regs.is_stmt = adv;
3331 case DW_LNS_set_basic_block:
3332 state_machine_regs.basic_block = 1;
3335 case DW_LNS_const_add_pc:
3336 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3337 if (linfo.li_max_ops_per_insn == 1)
3339 uladv *= linfo.li_min_insn_length;
3340 state_machine_regs.address += uladv;
3344 state_machine_regs.address
3345 += ((state_machine_regs.op_index + uladv)
3346 / linfo.li_max_ops_per_insn)
3347 * linfo.li_min_insn_length;
3348 state_machine_regs.op_index
3349 = (state_machine_regs.op_index + uladv)
3350 % linfo.li_max_ops_per_insn;
3354 case DW_LNS_fixed_advance_pc:
3355 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3356 state_machine_regs.address += uladv;
3357 state_machine_regs.op_index = 0;
3360 case DW_LNS_set_prologue_end:
3363 case DW_LNS_set_epilogue_begin:
3366 case DW_LNS_set_isa:
3367 uladv = read_uleb128 (data, & bytes_read, end);
3369 printf (_(" Set ISA to %lu\n"), uladv);
3373 printf (_(" Unknown opcode %d with operands: "), op_code);
3375 if (standard_opcodes != NULL)
3376 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3378 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3380 i == 1 ? "" : ", ");
3387 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3388 to the DWARF address/line matrix. */
3389 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3390 || (op_code == DW_LNS_copy))
3392 const unsigned int MAX_FILENAME_LENGTH = 35;
3394 char *newFileName = NULL;
3395 size_t fileNameLength;
3398 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3400 fileName = "<unknown>";
3402 fileNameLength = strlen (fileName);
3404 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3406 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3407 /* Truncate file name */
3408 strncpy (newFileName,
3409 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3410 MAX_FILENAME_LENGTH + 1);
3414 newFileName = (char *) xmalloc (fileNameLength + 1);
3415 strncpy (newFileName, fileName, fileNameLength + 1);
3418 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3420 if (linfo.li_max_ops_per_insn == 1)
3421 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3422 newFileName, state_machine_regs.line,
3423 state_machine_regs.address);
3425 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3426 newFileName, state_machine_regs.line,
3427 state_machine_regs.address,
3428 state_machine_regs.op_index);
3432 if (linfo.li_max_ops_per_insn == 1)
3433 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3434 newFileName, state_machine_regs.line,
3435 state_machine_regs.address);
3437 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3438 newFileName, state_machine_regs.line,
3439 state_machine_regs.address,
3440 state_machine_regs.op_index);
3443 if (op_code == DW_LNE_end_sequence)
3457 if (directory_table)
3459 free (directory_table);
3460 directory_table = NULL;
3471 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3473 unsigned char *data = section->start;
3474 unsigned char *end = data + section->size;
3476 int retValDecoded = 1;
3478 if (do_debug_lines == 0)
3479 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3481 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3482 retValRaw = display_debug_lines_raw (section, data, end);
3484 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3485 retValDecoded = display_debug_lines_decoded (section, data, end);
3487 if (!retValRaw || !retValDecoded)
3494 find_debug_info_for_offset (unsigned long offset)
3498 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3501 for (i = 0; i < num_debug_info_entries; i++)
3502 if (debug_information[i].cu_offset == offset)
3503 return debug_information + i;
3509 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3511 /* See gdb/gdb-index.h. */
3512 static const char * const kinds[] =
3524 return _ (kinds[kind]);
3528 display_debug_pubnames_worker (struct dwarf_section *section,
3529 void *file ATTRIBUTE_UNUSED,
3532 DWARF2_Internal_PubNames names;
3533 unsigned char *start = section->start;
3534 unsigned char *end = start + section->size;
3536 /* It does not matter if this load fails,
3537 we test for that later on. */
3538 load_debug_info (file);
3540 printf (_("Contents of the %s section:\n\n"), section->name);
3544 unsigned char *data;
3545 unsigned long offset;
3546 unsigned int offset_size, initial_length_size;
3550 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3551 if (names.pn_length == 0xffffffff)
3553 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3555 initial_length_size = 12;
3560 initial_length_size = 4;
3563 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3564 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3566 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3567 && num_debug_info_entries > 0
3568 && find_debug_info_for_offset (names.pn_offset) == NULL)
3569 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3570 (unsigned long) names.pn_offset, section->name);
3572 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3574 start += names.pn_length + initial_length_size;
3576 if (names.pn_version != 2 && names.pn_version != 3)
3578 static int warned = 0;
3582 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3589 printf (_(" Length: %ld\n"),
3590 (long) names.pn_length);
3591 printf (_(" Version: %d\n"),
3593 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3594 (unsigned long) names.pn_offset);
3595 printf (_(" Size of area in .debug_info section: %ld\n"),
3596 (long) names.pn_size);
3599 printf (_("\n Offset Kind Name\n"));
3601 printf (_("\n Offset\tName\n"));
3605 SAFE_BYTE_GET (offset, data, offset_size, end);
3609 data += offset_size;
3612 unsigned int kind_data;
3613 gdb_index_symbol_kind kind;
3614 const char *kind_name;
3617 SAFE_BYTE_GET (kind_data, data, 1, end);
3619 /* GCC computes the kind as the upper byte in the CU index
3620 word, and then right shifts it by the CU index size.
3621 Left shift KIND to where the gdb-index.h accessor macros
3623 kind_data <<= GDB_INDEX_CU_BITSIZE;
3624 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3625 kind_name = get_gdb_index_symbol_kind_name (kind);
3626 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3627 printf (" %-6lx %s,%-10s %s\n",
3628 offset, is_static ? _("s") : _("g"),
3632 printf (" %-6lx\t%s\n", offset, data);
3633 data += strnlen ((char *) data, end - data) + 1;
3636 while (offset != 0);
3644 display_debug_pubnames (struct dwarf_section *section, void *file)
3646 return display_debug_pubnames_worker (section, file, 0);
3650 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3652 return display_debug_pubnames_worker (section, file, 1);
3656 display_debug_macinfo (struct dwarf_section *section,
3657 void *file ATTRIBUTE_UNUSED)
3659 unsigned char *start = section->start;
3660 unsigned char *end = start + section->size;
3661 unsigned char *curr = start;
3662 unsigned int bytes_read;
3663 enum dwarf_macinfo_record_type op;
3665 printf (_("Contents of the %s section:\n\n"), section->name);
3669 unsigned int lineno;
3670 const unsigned char *string;
3672 op = (enum dwarf_macinfo_record_type) *curr;
3677 case DW_MACINFO_start_file:
3679 unsigned int filenum;
3681 lineno = read_uleb128 (curr, & bytes_read, end);
3683 filenum = read_uleb128 (curr, & bytes_read, end);
3686 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3691 case DW_MACINFO_end_file:
3692 printf (_(" DW_MACINFO_end_file\n"));
3695 case DW_MACINFO_define:
3696 lineno = read_uleb128 (curr, & bytes_read, end);
3699 curr += strnlen ((char *) string, end - string) + 1;
3700 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3704 case DW_MACINFO_undef:
3705 lineno = read_uleb128 (curr, & bytes_read, end);
3708 curr += strnlen ((char *) string, end - string) + 1;
3709 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3713 case DW_MACINFO_vendor_ext:
3715 unsigned int constant;
3717 constant = read_uleb128 (curr, & bytes_read, end);
3720 curr += strnlen ((char *) string, end - string) + 1;
3721 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3731 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3732 filename and dirname corresponding to file name table entry with index
3733 FILEIDX. Return NULL on failure. */
3735 static unsigned char *
3736 get_line_filename_and_dirname (dwarf_vma line_offset,
3738 unsigned char **dir_name)
3740 struct dwarf_section *section = &debug_displays [line].section;
3741 unsigned char *hdrptr, *dirtable, *file_name;
3742 unsigned int offset_size, initial_length_size;
3743 unsigned int version, opcode_base, bytes_read;
3744 dwarf_vma length, diridx;
3745 const unsigned char * end;
3748 if (section->start == NULL
3749 || line_offset >= section->size
3753 hdrptr = section->start + line_offset;
3754 end = section->start + section->size;
3756 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3757 if (length == 0xffffffff)
3759 /* This section is 64-bit DWARF 3. */
3760 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3762 initial_length_size = 12;
3767 initial_length_size = 4;
3769 if (length + initial_length_size > section->size)
3772 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3773 if (version != 2 && version != 3 && version != 4)
3775 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3777 hdrptr++; /* Skip max_ops_per_insn. */
3778 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3780 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3781 if (opcode_base == 0)
3784 hdrptr += opcode_base - 1;
3786 /* Skip over dirname table. */
3787 while (*hdrptr != '\0')
3788 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3789 hdrptr++; /* Skip the NUL at the end of the table. */
3790 /* Now skip over preceding filename table entries. */
3791 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3793 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3794 read_uleb128 (hdrptr, &bytes_read, end);
3795 hdrptr += bytes_read;
3796 read_uleb128 (hdrptr, &bytes_read, end);
3797 hdrptr += bytes_read;
3798 read_uleb128 (hdrptr, &bytes_read, end);
3799 hdrptr += bytes_read;
3801 if (hdrptr == end || *hdrptr == '\0')
3804 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3805 diridx = read_uleb128 (hdrptr, &bytes_read, end);
3808 for (; *dirtable != '\0' && diridx > 1; diridx--)
3809 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
3810 if (*dirtable == '\0')
3812 *dir_name = dirtable;
3817 display_debug_macro (struct dwarf_section *section,
3820 unsigned char *start = section->start;
3821 unsigned char *end = start + section->size;
3822 unsigned char *curr = start;
3823 unsigned char *extended_op_buf[256];
3824 unsigned int bytes_read;
3826 load_debug_section (str, file);
3827 load_debug_section (line, file);
3829 printf (_("Contents of the %s section:\n\n"), section->name);
3833 unsigned int lineno, version, flags;
3834 unsigned int offset_size = 4;
3835 const unsigned char *string;
3836 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
3837 unsigned char **extended_ops = NULL;
3839 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
3842 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3847 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
3850 printf (_(" Offset: 0x%lx\n"),
3851 (unsigned long) sec_offset);
3852 printf (_(" Version: %d\n"), version);
3853 printf (_(" Offset size: %d\n"), offset_size);
3856 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
3857 printf (_(" Offset into .debug_line: 0x%lx\n"),
3858 (unsigned long) line_offset);
3862 unsigned int i, count, op;
3865 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
3867 memset (extended_op_buf, 0, sizeof (extended_op_buf));
3868 extended_ops = extended_op_buf;
3871 printf (_(" Extension opcode arguments:\n"));
3872 for (i = 0; i < count; i++)
3874 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
3875 extended_ops[op] = curr;
3876 nargs = read_uleb128 (curr, &bytes_read, end);
3879 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
3882 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
3883 for (n = 0; n < nargs; n++)
3887 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
3888 printf ("%s%s", get_FORM_name (form),
3889 n == nargs - 1 ? "\n" : ", ");
3899 case DW_FORM_block1:
3900 case DW_FORM_block2:
3901 case DW_FORM_block4:
3903 case DW_FORM_string:
3905 case DW_FORM_sec_offset:
3908 error (_("Invalid extension opcode form %s\n"),
3909 get_FORM_name (form));
3925 error (_(".debug_macro section not zero terminated\n"));
3929 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
3935 case DW_MACRO_GNU_start_file:
3937 unsigned int filenum;
3938 unsigned char *file_name = NULL, *dir_name = NULL;
3940 lineno = read_uleb128 (curr, &bytes_read, end);
3942 filenum = read_uleb128 (curr, &bytes_read, end);
3945 if ((flags & 2) == 0)
3946 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3949 = get_line_filename_and_dirname (line_offset, filenum,
3951 if (file_name == NULL)
3952 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3955 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3957 dir_name != NULL ? (const char *) dir_name : "",
3958 dir_name != NULL ? "/" : "", file_name);
3962 case DW_MACRO_GNU_end_file:
3963 printf (_(" DW_MACRO_GNU_end_file\n"));
3966 case DW_MACRO_GNU_define:
3967 lineno = read_uleb128 (curr, &bytes_read, end);
3970 curr += strnlen ((char *) string, end - string) + 1;
3971 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3975 case DW_MACRO_GNU_undef:
3976 lineno = read_uleb128 (curr, &bytes_read, end);
3979 curr += strnlen ((char *) string, end - string) + 1;
3980 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3984 case DW_MACRO_GNU_define_indirect:
3985 lineno = read_uleb128 (curr, &bytes_read, end);
3987 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
3988 string = fetch_indirect_string (offset);
3989 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3993 case DW_MACRO_GNU_undef_indirect:
3994 lineno = read_uleb128 (curr, &bytes_read, end);
3996 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
3997 string = fetch_indirect_string (offset);
3998 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4002 case DW_MACRO_GNU_transparent_include:
4003 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4004 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4005 (unsigned long) offset);
4008 case DW_MACRO_GNU_define_indirect_alt:
4009 lineno = read_uleb128 (curr, &bytes_read, end);
4011 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4012 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4013 lineno, (unsigned long) offset);
4016 case DW_MACRO_GNU_undef_indirect_alt:
4017 lineno = read_uleb128 (curr, &bytes_read, end);
4019 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4020 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4021 lineno, (unsigned long) offset);
4024 case DW_MACRO_GNU_transparent_include_alt:
4025 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4026 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4027 (unsigned long) offset);
4031 if (extended_ops == NULL || extended_ops[op] == NULL)
4033 error (_(" Unknown macro opcode %02x seen\n"), op);
4038 /* Skip over unhandled opcodes. */
4040 unsigned char *desc = extended_ops[op];
4041 nargs = read_uleb128 (desc, &bytes_read, end);
4045 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4048 printf (_(" DW_MACRO_GNU_%02x -"), op);
4049 for (n = 0; n < nargs; n++)
4053 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4055 = read_and_display_attr_value (0, val,
4056 curr, end, 0, 0, offset_size,
4057 version, NULL, 0, NULL,
4075 display_debug_abbrev (struct dwarf_section *section,
4076 void *file ATTRIBUTE_UNUSED)
4078 abbrev_entry *entry;
4079 unsigned char *start = section->start;
4080 unsigned char *end = start + section->size;
4082 printf (_("Contents of the %s section:\n\n"), section->name);
4086 unsigned char *last;
4091 start = process_abbrev_section (start, end);
4093 if (first_abbrev == NULL)
4096 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
4098 for (entry = first_abbrev; entry; entry = entry->next)
4102 printf (" %ld %s [%s]\n",
4104 get_TAG_name (entry->tag),
4105 entry->children ? _("has children") : _("no children"));
4107 for (attr = entry->first_attr; attr; attr = attr->next)
4108 printf (" %-18s %s\n",
4109 get_AT_name (attr->attribute),
4110 get_FORM_name (attr->form));
4120 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4123 display_loc_list (struct dwarf_section *section,
4124 unsigned char **start_ptr,
4125 int debug_info_entry,
4126 unsigned long offset,
4127 unsigned long base_address,
4130 unsigned char *start = *start_ptr;
4131 unsigned char *section_end = section->start + section->size;
4132 unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
4133 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
4134 unsigned int offset_size = debug_information [debug_info_entry].offset_size;
4135 int dwarf_version = debug_information [debug_info_entry].dwarf_version;
4139 unsigned short length;
4140 int need_frame_base;
4144 if (start + 2 * pointer_size > section_end)
4146 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4151 printf (" %8.8lx ", offset + (start - *start_ptr));
4153 /* Note: we use sign extension here in order to be sure that we can detect
4154 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4155 address will not affect the values that we display since we always show
4156 hex values, and always the bottom 32-bits. */
4157 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4158 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4160 if (begin == 0 && end == 0)
4162 printf (_("<End of list>\n"));
4166 /* Check base address specifiers. */
4167 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4170 print_dwarf_vma (begin, pointer_size);
4171 print_dwarf_vma (end, pointer_size);
4172 printf (_("(base address)\n"));
4176 if (start + 2 > section_end)
4178 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4183 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4185 if (start + length > section_end)
4187 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4192 print_dwarf_vma (begin + base_address, pointer_size);
4193 print_dwarf_vma (end + base_address, pointer_size);
4196 need_frame_base = decode_location_expression (start,
4201 cu_offset, section);
4204 if (need_frame_base && !has_frame_base)
4205 printf (_(" [without DW_AT_frame_base]"));
4208 fputs (_(" (start == end)"), stdout);
4209 else if (begin > end)
4210 fputs (_(" (start > end)"), stdout);
4220 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4221 right-adjusted in a field of length LEN, and followed by a space. */
4224 print_addr_index (unsigned int idx, unsigned int len)
4226 static char buf[15];
4227 snprintf (buf, sizeof (buf), "[%d]", idx);
4228 printf ("%*s ", len, buf);
4231 /* Display a location list from a .dwo section. It uses address indexes rather
4232 than embedded addresses. This code closely follows display_loc_list, but the
4233 two are sufficiently different that combining things is very ugly. */
4236 display_loc_list_dwo (struct dwarf_section *section,
4237 unsigned char **start_ptr,
4238 int debug_info_entry,
4239 unsigned long offset,
4242 unsigned char *start = *start_ptr;
4243 unsigned char *section_end = section->start + section->size;
4244 unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
4245 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
4246 unsigned int offset_size = debug_information [debug_info_entry].offset_size;
4247 int dwarf_version = debug_information [debug_info_entry].dwarf_version;
4249 unsigned short length;
4250 int need_frame_base;
4252 unsigned int bytes_read;
4256 printf (" %8.8lx ", offset + (start - *start_ptr));
4258 if (start >= section_end)
4260 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4265 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4268 case 0: /* A terminating entry. */
4270 printf (_("<End of list>\n"));
4272 case 1: /* A base-address entry. */
4273 idx = read_uleb128 (start, &bytes_read, section_end);
4274 start += bytes_read;
4275 print_addr_index (idx, 8);
4277 printf (_("(base address selection entry)\n"));
4279 case 2: /* A start/end entry. */
4280 idx = read_uleb128 (start, &bytes_read, section_end);
4281 start += bytes_read;
4282 print_addr_index (idx, 8);
4283 idx = read_uleb128 (start, &bytes_read, section_end);
4284 start += bytes_read;
4285 print_addr_index (idx, 8);
4287 case 3: /* A start/length entry. */
4288 idx = read_uleb128 (start, &bytes_read, section_end);
4289 start += bytes_read;
4290 print_addr_index (idx, 8);
4291 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4292 printf ("%08x ", idx);
4294 case 4: /* An offset pair entry. */
4295 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4296 printf ("%08x ", idx);
4297 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4298 printf ("%08x ", idx);
4301 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4306 if (start + 2 > section_end)
4308 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4313 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4314 if (start + length > section_end)
4316 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4322 need_frame_base = decode_location_expression (start,
4327 cu_offset, section);
4330 if (need_frame_base && !has_frame_base)
4331 printf (_(" [without DW_AT_frame_base]"));
4341 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4343 static dwarf_vma *loc_offsets;
4346 loc_offsets_compar (const void *ap, const void *bp)
4348 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4349 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4351 return (a > b) - (b > a);
4355 display_debug_loc (struct dwarf_section *section, void *file)
4357 unsigned char *start = section->start;
4358 unsigned long bytes;
4359 unsigned char *section_begin = start;
4360 unsigned int num_loc_list = 0;
4361 unsigned long last_offset = 0;
4362 unsigned int first = 0;
4366 int seen_first_offset = 0;
4367 int locs_sorted = 1;
4368 unsigned char *next;
4369 unsigned int *array = NULL;
4370 const char *suffix = strrchr (section->name, '.');
4373 if (suffix && strcmp (suffix, ".dwo") == 0)
4376 bytes = section->size;
4380 printf (_("\nThe %s section is empty.\n"), section->name);
4384 if (load_debug_info (file) == 0)
4386 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4391 /* Check the order of location list in .debug_info section. If
4392 offsets of location lists are in the ascending order, we can
4393 use `debug_information' directly. */
4394 for (i = 0; i < num_debug_info_entries; i++)
4398 num = debug_information [i].num_loc_offsets;
4399 if (num > num_loc_list)
4402 /* Check if we can use `debug_information' directly. */
4403 if (locs_sorted && num != 0)
4405 if (!seen_first_offset)
4407 /* This is the first location list. */
4408 last_offset = debug_information [i].loc_offsets [0];
4410 seen_first_offset = 1;
4416 for (; j < num; j++)
4419 debug_information [i].loc_offsets [j])
4424 last_offset = debug_information [i].loc_offsets [j];
4429 if (!seen_first_offset)
4430 error (_("No location lists in .debug_info section!\n"));
4432 if (debug_information [first].num_loc_offsets > 0
4433 && debug_information [first].loc_offsets [0] != 0)
4434 warn (_("Location lists in %s section start at 0x%s\n"),
4436 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4439 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4440 printf (_("Contents of the %s section:\n\n"), section->name);
4441 printf (_(" Offset Begin End Expression\n"));
4443 seen_first_offset = 0;
4444 for (i = first; i < num_debug_info_entries; i++)
4446 unsigned long offset;
4447 unsigned long base_address;
4452 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4454 loc_offsets = debug_information [i].loc_offsets;
4455 qsort (array, debug_information [i].num_loc_offsets,
4456 sizeof (*array), loc_offsets_compar);
4459 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4461 j = locs_sorted ? k : array[k];
4463 && debug_information [i].loc_offsets [locs_sorted
4464 ? k - 1 : array [k - 1]]
4465 == debug_information [i].loc_offsets [j])
4467 has_frame_base = debug_information [i].have_frame_base [j];
4468 offset = debug_information [i].loc_offsets [j];
4469 next = section_begin + offset;
4470 base_address = debug_information [i].base_address;
4472 if (!seen_first_offset)
4473 seen_first_offset = 1;
4477 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4478 (unsigned long) (start - section_begin),
4479 (unsigned long) (next - section_begin));
4480 else if (start > next)
4481 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4482 (unsigned long) (start - section_begin),
4483 (unsigned long) (next - section_begin));
4487 if (offset >= bytes)
4489 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4495 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4497 display_loc_list (section, &start, i, offset, base_address,
4502 if (start < section->start + section->size)
4503 warn (_("There are %ld unused bytes at the end of section %s\n"),
4504 (long) (section->start + section->size - start), section->name);
4511 display_debug_str (struct dwarf_section *section,
4512 void *file ATTRIBUTE_UNUSED)
4514 unsigned char *start = section->start;
4515 unsigned long bytes = section->size;
4516 dwarf_vma addr = section->address;
4520 printf (_("\nThe %s section is empty.\n"), section->name);
4524 printf (_("Contents of the %s section:\n\n"), section->name);
4532 lbytes = (bytes > 16 ? 16 : bytes);
4534 printf (" 0x%8.8lx ", (unsigned long) addr);
4536 for (j = 0; j < 16; j++)
4539 printf ("%2.2x", start[j]);
4547 for (j = 0; j < lbytes; j++)
4550 if (k >= ' ' && k < 0x80)
4569 display_debug_info (struct dwarf_section *section, void *file)
4571 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4575 display_debug_types (struct dwarf_section *section, void *file)
4577 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4581 display_trace_info (struct dwarf_section *section, void *file)
4583 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4587 display_debug_aranges (struct dwarf_section *section,
4588 void *file ATTRIBUTE_UNUSED)
4590 unsigned char *start = section->start;
4591 unsigned char *end = start + section->size;
4593 printf (_("Contents of the %s section:\n\n"), section->name);
4595 /* It does not matter if this load fails,
4596 we test for that later on. */
4597 load_debug_info (file);
4601 unsigned char *hdrptr;
4602 DWARF2_Internal_ARange arange;
4603 unsigned char *addr_ranges;
4606 unsigned char address_size;
4608 unsigned int offset_size;
4609 unsigned int initial_length_size;
4613 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4614 if (arange.ar_length == 0xffffffff)
4616 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4618 initial_length_size = 12;
4623 initial_length_size = 4;
4626 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4627 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4629 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4630 && num_debug_info_entries > 0
4631 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4632 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4633 (unsigned long) arange.ar_info_offset, section->name);
4635 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4636 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4638 if (arange.ar_version != 2 && arange.ar_version != 3)
4640 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4644 printf (_(" Length: %ld\n"),
4645 (long) arange.ar_length);
4646 printf (_(" Version: %d\n"), arange.ar_version);
4647 printf (_(" Offset into .debug_info: 0x%lx\n"),
4648 (unsigned long) arange.ar_info_offset);
4649 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4650 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4652 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4654 if (address_size == 0)
4656 error (_("Invalid address size in %s section!\n"),
4661 /* The DWARF spec does not require that the address size be a power
4662 of two, but we do. This will have to change if we ever encounter
4663 an uneven architecture. */
4664 if ((address_size & (address_size - 1)) != 0)
4666 warn (_("Pointer size + Segment size is not a power of two.\n"));
4670 if (address_size > 4)
4671 printf (_("\n Address Length\n"));
4673 printf (_("\n Address Length\n"));
4675 addr_ranges = hdrptr;
4677 /* Must pad to an alignment boundary that is twice the address size. */
4678 excess = (hdrptr - start) % (2 * address_size);
4680 addr_ranges += (2 * address_size) - excess;
4682 start += arange.ar_length + initial_length_size;
4684 while (addr_ranges + 2 * address_size <= start)
4686 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4687 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4690 print_dwarf_vma (address, address_size);
4691 print_dwarf_vma (length, address_size);
4701 /* Comparison function for qsort. */
4703 comp_addr_base (const void * v0, const void * v1)
4705 debug_info * info0 = (debug_info *) v0;
4706 debug_info * info1 = (debug_info *) v1;
4707 return info0->addr_base - info1->addr_base;
4710 /* Display the debug_addr section. */
4712 display_debug_addr (struct dwarf_section *section,
4715 debug_info **debug_addr_info;
4716 unsigned char *entry;
4721 if (section->size == 0)
4723 printf (_("\nThe %s section is empty.\n"), section->name);
4727 if (load_debug_info (file) == 0)
4729 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4734 printf (_("Contents of the %s section:\n\n"), section->name);
4736 debug_addr_info = (debug_info **) xmalloc ((num_debug_info_entries + 1)
4737 * sizeof (debug_info *));
4740 for (i = 0; i < num_debug_info_entries; i++)
4742 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4743 debug_addr_info [count++] = &debug_information [i];
4746 /* Add a sentinel to make iteration convenient. */
4747 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
4748 debug_addr_info [count]->addr_base = section->size;
4750 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
4751 for (i = 0; i < count; i++)
4754 unsigned int address_size = debug_addr_info [i]->pointer_size;
4756 printf (_(" For compilation unit at offset 0x%s:\n"),
4757 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
4759 printf (_("\tIndex\tAddress\n"));
4760 entry = section->start + debug_addr_info [i]->addr_base;
4761 end = section->start + debug_addr_info [i + 1]->addr_base;
4765 dwarf_vma base = byte_get (entry, address_size);
4766 printf (_("\t%d:\t"), idx);
4767 print_dwarf_vma (base, address_size);
4769 entry += address_size;
4775 free (debug_addr_info);
4779 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4781 display_debug_str_offsets (struct dwarf_section *section,
4782 void *file ATTRIBUTE_UNUSED)
4784 if (section->size == 0)
4786 printf (_("\nThe %s section is empty.\n"), section->name);
4789 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4790 what the offset size is for this section. */
4794 /* Each debug_information[x].range_lists[y] gets this representation for
4795 sorting purposes. */
4799 /* The debug_information[x].range_lists[y] value. */
4800 unsigned long ranges_offset;
4802 /* Original debug_information to find parameters of the data. */
4803 debug_info *debug_info_p;
4806 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4809 range_entry_compar (const void *ap, const void *bp)
4811 const struct range_entry *a_re = (const struct range_entry *) ap;
4812 const struct range_entry *b_re = (const struct range_entry *) bp;
4813 const unsigned long a = a_re->ranges_offset;
4814 const unsigned long b = b_re->ranges_offset;
4816 return (a > b) - (b > a);
4820 display_debug_ranges (struct dwarf_section *section,
4821 void *file ATTRIBUTE_UNUSED)
4823 unsigned char *start = section->start;
4824 unsigned char *last_start = start;
4825 unsigned long bytes = section->size;
4826 unsigned char *section_begin = start;
4827 unsigned char *finish = start + bytes;
4828 unsigned int num_range_list, i;
4829 struct range_entry *range_entries, *range_entry_fill;
4833 printf (_("\nThe %s section is empty.\n"), section->name);
4837 if (load_debug_info (file) == 0)
4839 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4845 for (i = 0; i < num_debug_info_entries; i++)
4846 num_range_list += debug_information [i].num_range_lists;
4848 if (num_range_list == 0)
4850 /* This can happen when the file was compiled with -gsplit-debug
4851 which removes references to range lists from the primary .o file. */
4852 printf (_("No range lists in .debug_info section.\n"));
4856 range_entries = (struct range_entry *)
4857 xmalloc (sizeof (*range_entries) * num_range_list);
4858 range_entry_fill = range_entries;
4860 for (i = 0; i < num_debug_info_entries; i++)
4862 debug_info *debug_info_p = &debug_information[i];
4865 for (j = 0; j < debug_info_p->num_range_lists; j++)
4867 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
4868 range_entry_fill->debug_info_p = debug_info_p;
4873 qsort (range_entries, num_range_list, sizeof (*range_entries),
4874 range_entry_compar);
4876 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
4877 warn (_("Range lists in %s section start at 0x%lx\n"),
4878 section->name, range_entries[0].ranges_offset);
4880 printf (_("Contents of the %s section:\n\n"), section->name);
4881 printf (_(" Offset Begin End\n"));
4883 for (i = 0; i < num_range_list; i++)
4885 struct range_entry *range_entry = &range_entries[i];
4886 debug_info *debug_info_p = range_entry->debug_info_p;
4887 unsigned int pointer_size;
4888 unsigned long offset;
4889 unsigned char *next;
4890 unsigned long base_address;
4892 pointer_size = debug_info_p->pointer_size;
4894 offset = range_entry->ranges_offset;
4895 next = section_begin + offset;
4896 base_address = debug_info_p->base_address;
4898 if (dwarf_check != 0 && i > 0)
4901 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4902 (unsigned long) (start - section_begin),
4903 (unsigned long) (next - section_begin), section->name);
4904 else if (start > next)
4906 if (next == last_start)
4908 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4909 (unsigned long) (start - section_begin),
4910 (unsigned long) (next - section_begin), section->name);
4916 while (start < finish)
4921 /* Note: we use sign extension here in order to be sure that
4922 we can detect the -1 escape value. Sign extension into the
4923 top 32 bits of a 32-bit address will not affect the values
4924 that we display since we always show hex values, and always
4925 the bottom 32-bits. */
4926 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
4927 if (start >= finish)
4929 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
4931 printf (" %8.8lx ", offset);
4933 if (begin == 0 && end == 0)
4935 printf (_("<End of list>\n"));
4939 /* Check base address specifiers. */
4940 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4943 print_dwarf_vma (begin, pointer_size);
4944 print_dwarf_vma (end, pointer_size);
4945 printf ("(base address)\n");
4949 print_dwarf_vma (begin + base_address, pointer_size);
4950 print_dwarf_vma (end + base_address, pointer_size);
4953 fputs (_("(start == end)"), stdout);
4954 else if (begin > end)
4955 fputs (_("(start > end)"), stdout);
4962 free (range_entries);
4967 typedef struct Frame_Chunk
4969 struct Frame_Chunk *next;
4970 unsigned char *chunk_start;
4972 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4973 short int *col_type;
4976 unsigned int code_factor;
4983 unsigned char fde_encoding;
4984 unsigned char cfa_exp;
4985 unsigned char ptr_size;
4986 unsigned char segment_size;
4990 static const char *const *dwarf_regnames;
4991 static unsigned int dwarf_regnames_count;
4993 /* A marker for a col_type that means this column was never referenced
4994 in the frame info. */
4995 #define DW_CFA_unreferenced (-1)
4997 /* Return 0 if not more space is needed, 1 if more space is needed,
4998 -1 for invalid reg. */
5001 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5003 int prev = fc->ncols;
5005 if (reg < (unsigned int) fc->ncols)
5008 if (dwarf_regnames_count
5009 && reg > dwarf_regnames_count)
5012 fc->ncols = reg + 1;
5013 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5014 sizeof (short int));
5015 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5017 while (prev < fc->ncols)
5019 fc->col_type[prev] = DW_CFA_unreferenced;
5020 fc->col_offset[prev] = 0;
5026 static const char *const dwarf_regnames_i386[] =
5028 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5029 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5030 "eip", "eflags", NULL, /* 8 - 10 */
5031 "st0", "st1", "st2", "st3", /* 11 - 14 */
5032 "st4", "st5", "st6", "st7", /* 15 - 18 */
5033 NULL, NULL, /* 19 - 20 */
5034 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5035 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5036 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5037 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5038 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5039 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5040 "tr", "ldtr", /* 48 - 49 */
5041 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5042 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5043 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5044 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5045 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5046 NULL, NULL, NULL, /* 90 - 92 */
5047 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5051 init_dwarf_regnames_i386 (void)
5053 dwarf_regnames = dwarf_regnames_i386;
5054 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5057 static const char *const dwarf_regnames_x86_64[] =
5059 "rax", "rdx", "rcx", "rbx",
5060 "rsi", "rdi", "rbp", "rsp",
5061 "r8", "r9", "r10", "r11",
5062 "r12", "r13", "r14", "r15",
5064 "xmm0", "xmm1", "xmm2", "xmm3",
5065 "xmm4", "xmm5", "xmm6", "xmm7",
5066 "xmm8", "xmm9", "xmm10", "xmm11",
5067 "xmm12", "xmm13", "xmm14", "xmm15",
5068 "st0", "st1", "st2", "st3",
5069 "st4", "st5", "st6", "st7",
5070 "mm0", "mm1", "mm2", "mm3",
5071 "mm4", "mm5", "mm6", "mm7",
5073 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5074 "fs.base", "gs.base", NULL, NULL,
5076 "mxcsr", "fcw", "fsw",
5077 "xmm16", "xmm17", "xmm18", "xmm19",
5078 "xmm20", "xmm21", "xmm22", "xmm23",
5079 "xmm24", "xmm25", "xmm26", "xmm27",
5080 "xmm28", "xmm29", "xmm30", "xmm31",
5081 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5082 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5083 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5084 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5085 NULL, NULL, NULL, /* 115 - 117 */
5086 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5090 init_dwarf_regnames_x86_64 (void)
5092 dwarf_regnames = dwarf_regnames_x86_64;
5093 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5097 init_dwarf_regnames (unsigned int e_machine)
5103 init_dwarf_regnames_i386 ();
5109 init_dwarf_regnames_x86_64 ();
5118 regname (unsigned int regno, int row)
5120 static char reg[64];
5122 && regno < dwarf_regnames_count
5123 && dwarf_regnames [regno] != NULL)
5126 return dwarf_regnames [regno];
5127 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5128 dwarf_regnames [regno]);
5131 snprintf (reg, sizeof (reg), "r%d", regno);
5136 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
5141 if (*max_regs < fc->ncols)
5142 *max_regs = fc->ncols;
5144 if (*need_col_headers)
5146 static const char *sloc = " LOC";
5148 *need_col_headers = 0;
5150 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5152 for (r = 0; r < *max_regs; r++)
5153 if (fc->col_type[r] != DW_CFA_unreferenced)
5158 printf ("%-5s ", regname (r, 1));
5164 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5166 strcpy (tmp, "exp");
5168 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5169 printf ("%-8s ", tmp);
5171 for (r = 0; r < fc->ncols; r++)
5173 if (fc->col_type[r] != DW_CFA_unreferenced)
5175 switch (fc->col_type[r])
5177 case DW_CFA_undefined:
5180 case DW_CFA_same_value:
5184 sprintf (tmp, "c%+d", fc->col_offset[r]);
5186 case DW_CFA_val_offset:
5187 sprintf (tmp, "v%+d", fc->col_offset[r]);
5189 case DW_CFA_register:
5190 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5192 case DW_CFA_expression:
5193 strcpy (tmp, "exp");
5195 case DW_CFA_val_expression:
5196 strcpy (tmp, "vexp");
5199 strcpy (tmp, "n/a");
5202 printf ("%-5s ", tmp);
5208 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end);
5209 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5210 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5213 display_debug_frames (struct dwarf_section *section,
5214 void *file ATTRIBUTE_UNUSED)
5216 unsigned char *start = section->start;
5217 unsigned char *end = start + section->size;
5218 unsigned char *section_start = start;
5219 Frame_Chunk *chunks = 0;
5220 Frame_Chunk *remembered_state = 0;
5222 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5223 unsigned int length_return;
5225 const char *bad_reg = _("bad register: ");
5226 int saved_eh_addr_size = eh_addr_size;
5228 printf (_("Contents of the %s section:\n"), section->name);
5232 unsigned char *saved_start;
5233 unsigned char *block_end;
5238 int need_col_headers = 1;
5239 unsigned char *augmentation_data = NULL;
5240 unsigned long augmentation_data_len = 0;
5241 unsigned int encoded_ptr_size = saved_eh_addr_size;
5242 unsigned int offset_size;
5243 unsigned int initial_length_size;
5245 saved_start = start;
5247 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5250 printf ("\n%08lx ZERO terminator\n\n",
5251 (unsigned long)(saved_start - section_start));
5255 if (length == 0xffffffff)
5257 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5259 initial_length_size = 12;
5264 initial_length_size = 4;
5267 block_end = saved_start + length + initial_length_size;
5268 if (block_end > end)
5270 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5271 dwarf_vmatoa_1 (NULL, length, offset_size),
5272 (unsigned long) (saved_start - section_start));
5276 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5278 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5279 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5283 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5284 memset (fc, 0, sizeof (Frame_Chunk));
5288 fc->chunk_start = saved_start;
5290 fc->col_type = (short int *) xmalloc (sizeof (short int));
5291 fc->col_offset = (int *) xmalloc (sizeof (int));
5292 frame_need_space (fc, max_regs - 1);
5296 fc->augmentation = (char *) start;
5297 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
5299 if (strcmp (fc->augmentation, "eh") == 0)
5300 start += eh_addr_size;
5304 GET (fc->ptr_size, 1);
5305 GET (fc->segment_size, 1);
5306 eh_addr_size = fc->ptr_size;
5310 fc->ptr_size = eh_addr_size;
5311 fc->segment_size = 0;
5313 fc->code_factor = LEB ();
5314 fc->data_factor = SLEB ();
5324 if (fc->augmentation[0] == 'z')
5326 augmentation_data_len = LEB ();
5327 augmentation_data = start;
5328 start += augmentation_data_len;
5332 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5333 print_dwarf_vma (length, fc->ptr_size);
5334 print_dwarf_vma (cie_id, offset_size);
5336 if (do_debug_frames_interp)
5338 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5339 fc->code_factor, fc->data_factor, fc->ra);
5344 printf (" Version: %d\n", version);
5345 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5348 printf (" Pointer Size: %u\n", fc->ptr_size);
5349 printf (" Segment Size: %u\n", fc->segment_size);
5351 printf (" Code alignment factor: %u\n", fc->code_factor);
5352 printf (" Data alignment factor: %d\n", fc->data_factor);
5353 printf (" Return address column: %d\n", fc->ra);
5355 if (augmentation_data_len)
5358 printf (" Augmentation data: ");
5359 for (i = 0; i < augmentation_data_len; ++i)
5360 printf (" %02x", augmentation_data[i]);
5366 if (augmentation_data_len)
5368 unsigned char *p, *q;
5369 p = (unsigned char *) fc->augmentation + 1;
5370 q = augmentation_data;
5377 q += 1 + size_of_encoded_value (*q);
5379 fc->fde_encoding = *q++;
5387 if (fc->fde_encoding)
5388 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5391 frame_need_space (fc, fc->ra);
5395 unsigned char *look_for;
5396 static Frame_Chunk fde_fc;
5397 unsigned long segment_selector;
5400 memset (fc, 0, sizeof (Frame_Chunk));
5402 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
5404 for (cie = chunks; cie ; cie = cie->next)
5405 if (cie->chunk_start == look_for)
5410 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5411 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5412 (unsigned long) (saved_start - section_start));
5414 fc->col_type = (short int *) xmalloc (sizeof (short int));
5415 fc->col_offset = (int *) xmalloc (sizeof (int));
5416 frame_need_space (fc, max_regs - 1);
5418 fc->augmentation = "";
5419 fc->fde_encoding = 0;
5420 fc->ptr_size = eh_addr_size;
5421 fc->segment_size = 0;
5425 fc->ncols = cie->ncols;
5426 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5427 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
5428 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5429 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5430 fc->augmentation = cie->augmentation;
5431 fc->ptr_size = cie->ptr_size;
5432 eh_addr_size = cie->ptr_size;
5433 fc->segment_size = cie->segment_size;
5434 fc->code_factor = cie->code_factor;
5435 fc->data_factor = cie->data_factor;
5436 fc->cfa_reg = cie->cfa_reg;
5437 fc->cfa_offset = cie->cfa_offset;
5439 frame_need_space (fc, max_regs - 1);
5440 fc->fde_encoding = cie->fde_encoding;
5443 if (fc->fde_encoding)
5444 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5446 segment_selector = 0;
5447 if (fc->segment_size)
5449 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5451 fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
5452 start += encoded_ptr_size;
5454 /* FIXME: It appears that sometimes the final pc_range value is
5455 encoded in less than encoded_ptr_size bytes. See the x86_64
5456 run of the "objcopy on compressed debug sections" test for an
5458 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5460 if (cie->augmentation[0] == 'z')
5462 augmentation_data_len = LEB ();
5463 augmentation_data = start;
5464 start += augmentation_data_len;
5467 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5468 (unsigned long)(saved_start - section_start),
5469 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5470 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5471 (unsigned long)(cie->chunk_start - section_start));
5473 if (fc->segment_size)
5474 printf ("%04lx:", segment_selector);
5477 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5478 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5480 if (! do_debug_frames_interp && augmentation_data_len)
5484 printf (" Augmentation data: ");
5485 for (i = 0; i < augmentation_data_len; ++i)
5486 printf (" %02x", augmentation_data[i]);
5492 /* At this point, fc is the current chunk, cie (if any) is set, and
5493 we're about to interpret instructions for the chunk. */
5494 /* ??? At present we need to do this always, since this sizes the
5495 fc->col_type and fc->col_offset arrays, which we write into always.
5496 We should probably split the interpreted and non-interpreted bits
5497 into two different routines, since there's so much that doesn't
5498 really overlap between them. */
5499 if (1 || do_debug_frames_interp)
5501 /* Start by making a pass over the chunk, allocating storage
5502 and taking note of what registers are used. */
5503 unsigned char *tmp = start;
5505 while (start < block_end)
5508 unsigned long reg, temp;
5515 /* Warning: if you add any more cases to this switch, be
5516 sure to add them to the corresponding switch below. */
5519 case DW_CFA_advance_loc:
5523 if (frame_need_space (fc, opa) >= 0)
5524 fc->col_type[opa] = DW_CFA_undefined;
5526 case DW_CFA_restore:
5527 if (frame_need_space (fc, opa) >= 0)
5528 fc->col_type[opa] = DW_CFA_undefined;
5530 case DW_CFA_set_loc:
5531 start += encoded_ptr_size;
5533 case DW_CFA_advance_loc1:
5536 case DW_CFA_advance_loc2:
5539 case DW_CFA_advance_loc4:
5542 case DW_CFA_offset_extended:
5543 case DW_CFA_val_offset:
5544 reg = LEB (); LEB ();
5545 if (frame_need_space (fc, reg) >= 0)
5546 fc->col_type[reg] = DW_CFA_undefined;
5548 case DW_CFA_restore_extended:
5550 frame_need_space (fc, reg);
5551 if (frame_need_space (fc, reg) >= 0)
5552 fc->col_type[reg] = DW_CFA_undefined;
5554 case DW_CFA_undefined:
5556 if (frame_need_space (fc, reg) >= 0)
5557 fc->col_type[reg] = DW_CFA_undefined;
5559 case DW_CFA_same_value:
5561 if (frame_need_space (fc, reg) >= 0)
5562 fc->col_type[reg] = DW_CFA_undefined;
5564 case DW_CFA_register:
5565 reg = LEB (); LEB ();
5566 if (frame_need_space (fc, reg) >= 0)
5567 fc->col_type[reg] = DW_CFA_undefined;
5569 case DW_CFA_def_cfa:
5572 case DW_CFA_def_cfa_register:
5575 case DW_CFA_def_cfa_offset:
5578 case DW_CFA_def_cfa_expression:
5582 case DW_CFA_expression:
5583 case DW_CFA_val_expression:
5587 if (frame_need_space (fc, reg) >= 0)
5588 fc->col_type[reg] = DW_CFA_undefined;
5590 case DW_CFA_offset_extended_sf:
5591 case DW_CFA_val_offset_sf:
5592 reg = LEB (); SLEB ();
5593 if (frame_need_space (fc, reg) >= 0)
5594 fc->col_type[reg] = DW_CFA_undefined;
5596 case DW_CFA_def_cfa_sf:
5599 case DW_CFA_def_cfa_offset_sf:
5602 case DW_CFA_MIPS_advance_loc8:
5605 case DW_CFA_GNU_args_size:
5608 case DW_CFA_GNU_negative_offset_extended:
5609 reg = LEB (); LEB ();
5610 if (frame_need_space (fc, reg) >= 0)
5611 fc->col_type[reg] = DW_CFA_undefined;
5620 /* Now we know what registers are used, make a second pass over
5621 the chunk, this time actually printing out the info. */
5623 while (start < block_end)
5626 unsigned long ul, reg, roffs;
5630 const char *reg_prefix = "";
5637 /* Warning: if you add any more cases to this switch, be
5638 sure to add them to the corresponding switch above. */
5641 case DW_CFA_advance_loc:
5642 if (do_debug_frames_interp)
5643 frame_display_row (fc, &need_col_headers, &max_regs);
5645 printf (" DW_CFA_advance_loc: %d to %s\n",
5646 opa * fc->code_factor,
5647 dwarf_vmatoa_1 (NULL,
5648 fc->pc_begin + opa * fc->code_factor,
5650 fc->pc_begin += opa * fc->code_factor;
5655 if (opa >= (unsigned int) fc->ncols)
5656 reg_prefix = bad_reg;
5657 if (! do_debug_frames_interp || *reg_prefix != '\0')
5658 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5659 reg_prefix, regname (opa, 0),
5660 roffs * fc->data_factor);
5661 if (*reg_prefix == '\0')
5663 fc->col_type[opa] = DW_CFA_offset;
5664 fc->col_offset[opa] = roffs * fc->data_factor;
5668 case DW_CFA_restore:
5669 if (opa >= (unsigned int) cie->ncols
5670 || opa >= (unsigned int) fc->ncols)
5671 reg_prefix = bad_reg;
5672 if (! do_debug_frames_interp || *reg_prefix != '\0')
5673 printf (" DW_CFA_restore: %s%s\n",
5674 reg_prefix, regname (opa, 0));
5675 if (*reg_prefix == '\0')
5677 fc->col_type[opa] = cie->col_type[opa];
5678 fc->col_offset[opa] = cie->col_offset[opa];
5679 if (do_debug_frames_interp
5680 && fc->col_type[opa] == DW_CFA_unreferenced)
5681 fc->col_type[opa] = DW_CFA_undefined;
5685 case DW_CFA_set_loc:
5686 vma = get_encoded_value (start, fc->fde_encoding, section);
5687 start += encoded_ptr_size;
5688 if (do_debug_frames_interp)
5689 frame_display_row (fc, &need_col_headers, &max_regs);
5691 printf (" DW_CFA_set_loc: %s\n",
5692 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
5696 case DW_CFA_advance_loc1:
5697 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
5698 if (do_debug_frames_interp)
5699 frame_display_row (fc, &need_col_headers, &max_regs);
5701 printf (" DW_CFA_advance_loc1: %ld to %s\n",
5702 (unsigned long) (ofs * fc->code_factor),
5703 dwarf_vmatoa_1 (NULL,
5704 fc->pc_begin + ofs * fc->code_factor,
5706 fc->pc_begin += ofs * fc->code_factor;
5709 case DW_CFA_advance_loc2:
5710 SAFE_BYTE_GET_AND_INC (ofs, start, 2, end);
5711 if (do_debug_frames_interp)
5712 frame_display_row (fc, &need_col_headers, &max_regs);
5714 printf (" DW_CFA_advance_loc2: %ld to %s\n",
5715 (unsigned long) (ofs * fc->code_factor),
5716 dwarf_vmatoa_1 (NULL,
5717 fc->pc_begin + ofs * fc->code_factor,
5719 fc->pc_begin += ofs * fc->code_factor;
5722 case DW_CFA_advance_loc4:
5723 SAFE_BYTE_GET_AND_INC (ofs, start, 4, end);
5724 if (do_debug_frames_interp)
5725 frame_display_row (fc, &need_col_headers, &max_regs);
5727 printf (" DW_CFA_advance_loc4: %ld to %s\n",
5728 (unsigned long) (ofs * fc->code_factor),
5729 dwarf_vmatoa_1 (NULL,
5730 fc->pc_begin + ofs * fc->code_factor,
5732 fc->pc_begin += ofs * fc->code_factor;
5735 case DW_CFA_offset_extended:
5738 if (reg >= (unsigned int) fc->ncols)
5739 reg_prefix = bad_reg;
5740 if (! do_debug_frames_interp || *reg_prefix != '\0')
5741 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5742 reg_prefix, regname (reg, 0),
5743 roffs * fc->data_factor);
5744 if (*reg_prefix == '\0')
5746 fc->col_type[reg] = DW_CFA_offset;
5747 fc->col_offset[reg] = roffs * fc->data_factor;
5751 case DW_CFA_val_offset:
5754 if (reg >= (unsigned int) fc->ncols)
5755 reg_prefix = bad_reg;
5756 if (! do_debug_frames_interp || *reg_prefix != '\0')
5757 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5758 reg_prefix, regname (reg, 0),
5759 roffs * fc->data_factor);
5760 if (*reg_prefix == '\0')
5762 fc->col_type[reg] = DW_CFA_val_offset;
5763 fc->col_offset[reg] = roffs * fc->data_factor;
5767 case DW_CFA_restore_extended:
5769 if (reg >= (unsigned int) cie->ncols
5770 || reg >= (unsigned int) fc->ncols)
5771 reg_prefix = bad_reg;
5772 if (! do_debug_frames_interp || *reg_prefix != '\0')
5773 printf (" DW_CFA_restore_extended: %s%s\n",
5774 reg_prefix, regname (reg, 0));
5775 if (*reg_prefix == '\0')
5777 fc->col_type[reg] = cie->col_type[reg];
5778 fc->col_offset[reg] = cie->col_offset[reg];
5782 case DW_CFA_undefined:
5784 if (reg >= (unsigned int) fc->ncols)
5785 reg_prefix = bad_reg;
5786 if (! do_debug_frames_interp || *reg_prefix != '\0')
5787 printf (" DW_CFA_undefined: %s%s\n",
5788 reg_prefix, regname (reg, 0));
5789 if (*reg_prefix == '\0')
5791 fc->col_type[reg] = DW_CFA_undefined;
5792 fc->col_offset[reg] = 0;
5796 case DW_CFA_same_value:
5798 if (reg >= (unsigned int) fc->ncols)
5799 reg_prefix = bad_reg;
5800 if (! do_debug_frames_interp || *reg_prefix != '\0')
5801 printf (" DW_CFA_same_value: %s%s\n",
5802 reg_prefix, regname (reg, 0));
5803 if (*reg_prefix == '\0')
5805 fc->col_type[reg] = DW_CFA_same_value;
5806 fc->col_offset[reg] = 0;
5810 case DW_CFA_register:
5813 if (reg >= (unsigned int) fc->ncols)
5814 reg_prefix = bad_reg;
5815 if (! do_debug_frames_interp || *reg_prefix != '\0')
5817 printf (" DW_CFA_register: %s%s in ",
5818 reg_prefix, regname (reg, 0));
5819 puts (regname (roffs, 0));
5821 if (*reg_prefix == '\0')
5823 fc->col_type[reg] = DW_CFA_register;
5824 fc->col_offset[reg] = roffs;
5828 case DW_CFA_remember_state:
5829 if (! do_debug_frames_interp)
5830 printf (" DW_CFA_remember_state\n");
5831 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5832 rs->ncols = fc->ncols;
5833 rs->col_type = (short int *) xcmalloc (rs->ncols,
5834 sizeof (short int));
5835 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
5836 memcpy (rs->col_type, fc->col_type, rs->ncols);
5837 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
5838 rs->next = remembered_state;
5839 remembered_state = rs;
5842 case DW_CFA_restore_state:
5843 if (! do_debug_frames_interp)
5844 printf (" DW_CFA_restore_state\n");
5845 rs = remembered_state;
5848 remembered_state = rs->next;
5849 frame_need_space (fc, rs->ncols - 1);
5850 memcpy (fc->col_type, rs->col_type, rs->ncols);
5851 memcpy (fc->col_offset, rs->col_offset,
5852 rs->ncols * sizeof (int));
5853 free (rs->col_type);
5854 free (rs->col_offset);
5857 else if (do_debug_frames_interp)
5858 printf ("Mismatched DW_CFA_restore_state\n");
5861 case DW_CFA_def_cfa:
5862 fc->cfa_reg = LEB ();
5863 fc->cfa_offset = LEB ();
5865 if (! do_debug_frames_interp)
5866 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5867 regname (fc->cfa_reg, 0), fc->cfa_offset);
5870 case DW_CFA_def_cfa_register:
5871 fc->cfa_reg = LEB ();
5873 if (! do_debug_frames_interp)
5874 printf (" DW_CFA_def_cfa_register: %s\n",
5875 regname (fc->cfa_reg, 0));
5878 case DW_CFA_def_cfa_offset:
5879 fc->cfa_offset = LEB ();
5880 if (! do_debug_frames_interp)
5881 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
5885 if (! do_debug_frames_interp)
5886 printf (" DW_CFA_nop\n");
5889 case DW_CFA_def_cfa_expression:
5891 if (! do_debug_frames_interp)
5893 printf (" DW_CFA_def_cfa_expression (");
5894 decode_location_expression (start, eh_addr_size, 0, -1,
5902 case DW_CFA_expression:
5905 if (reg >= (unsigned int) fc->ncols)
5906 reg_prefix = bad_reg;
5907 if (! do_debug_frames_interp || *reg_prefix != '\0')
5909 printf (" DW_CFA_expression: %s%s (",
5910 reg_prefix, regname (reg, 0));
5911 decode_location_expression (start, eh_addr_size, 0, -1,
5915 if (*reg_prefix == '\0')
5916 fc->col_type[reg] = DW_CFA_expression;
5920 case DW_CFA_val_expression:
5923 if (reg >= (unsigned int) fc->ncols)
5924 reg_prefix = bad_reg;
5925 if (! do_debug_frames_interp || *reg_prefix != '\0')
5927 printf (" DW_CFA_val_expression: %s%s (",
5928 reg_prefix, regname (reg, 0));
5929 decode_location_expression (start, eh_addr_size, 0, -1,
5933 if (*reg_prefix == '\0')
5934 fc->col_type[reg] = DW_CFA_val_expression;
5938 case DW_CFA_offset_extended_sf:
5941 if (frame_need_space (fc, reg) < 0)
5942 reg_prefix = bad_reg;
5943 if (! do_debug_frames_interp || *reg_prefix != '\0')
5944 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5945 reg_prefix, regname (reg, 0),
5946 l * fc->data_factor);
5947 if (*reg_prefix == '\0')
5949 fc->col_type[reg] = DW_CFA_offset;
5950 fc->col_offset[reg] = l * fc->data_factor;
5954 case DW_CFA_val_offset_sf:
5957 if (frame_need_space (fc, reg) < 0)
5958 reg_prefix = bad_reg;
5959 if (! do_debug_frames_interp || *reg_prefix != '\0')
5960 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5961 reg_prefix, regname (reg, 0),
5962 l * fc->data_factor);
5963 if (*reg_prefix == '\0')
5965 fc->col_type[reg] = DW_CFA_val_offset;
5966 fc->col_offset[reg] = l * fc->data_factor;
5970 case DW_CFA_def_cfa_sf:
5971 fc->cfa_reg = LEB ();
5972 fc->cfa_offset = SLEB ();
5973 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5975 if (! do_debug_frames_interp)
5976 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5977 regname (fc->cfa_reg, 0), fc->cfa_offset);
5980 case DW_CFA_def_cfa_offset_sf:
5981 fc->cfa_offset = SLEB ();
5982 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5983 if (! do_debug_frames_interp)
5984 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5987 case DW_CFA_MIPS_advance_loc8:
5988 SAFE_BYTE_GET_AND_INC (ofs, start, 8, end);
5989 if (do_debug_frames_interp)
5990 frame_display_row (fc, &need_col_headers, &max_regs);
5992 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
5993 (unsigned long) (ofs * fc->code_factor),
5994 dwarf_vmatoa_1 (NULL,
5995 fc->pc_begin + ofs * fc->code_factor,
5997 fc->pc_begin += ofs * fc->code_factor;
6000 case DW_CFA_GNU_window_save:
6001 if (! do_debug_frames_interp)
6002 printf (" DW_CFA_GNU_window_save\n");
6005 case DW_CFA_GNU_args_size:
6007 if (! do_debug_frames_interp)
6008 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6011 case DW_CFA_GNU_negative_offset_extended:
6014 if (frame_need_space (fc, reg) < 0)
6015 reg_prefix = bad_reg;
6016 if (! do_debug_frames_interp || *reg_prefix != '\0')
6017 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6018 reg_prefix, regname (reg, 0),
6019 l * fc->data_factor);
6020 if (*reg_prefix == '\0')
6022 fc->col_type[reg] = DW_CFA_offset;
6023 fc->col_offset[reg] = l * fc->data_factor;
6028 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6029 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6031 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6036 if (do_debug_frames_interp)
6037 frame_display_row (fc, &need_col_headers, &max_regs);
6040 eh_addr_size = saved_eh_addr_size;
6053 display_gdb_index (struct dwarf_section *section,
6054 void *file ATTRIBUTE_UNUSED)
6056 unsigned char *start = section->start;
6058 uint32_t cu_list_offset, tu_list_offset;
6059 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6060 unsigned int cu_list_elements, tu_list_elements;
6061 unsigned int address_table_size, symbol_table_slots;
6062 unsigned char *cu_list, *tu_list;
6063 unsigned char *address_table, *symbol_table, *constant_pool;
6066 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6068 printf (_("Contents of the %s section:\n"), section->name);
6070 if (section->size < 6 * sizeof (uint32_t))
6072 warn (_("Truncated header in the %s section.\n"), section->name);
6076 version = byte_get_little_endian (start, 4);
6077 printf (_("Version %ld\n"), (long) version);
6079 /* Prior versions are obsolete, and future versions may not be
6080 backwards compatible. */
6081 if (version < 3 || version > 8)
6083 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6087 warn (_("The address table data in version 3 may be wrong.\n"));
6089 warn (_("Version 4 does not support case insensitive lookups.\n"));
6091 warn (_("Version 5 does not include inlined functions.\n"));
6093 warn (_("Version 6 does not include symbol attributes.\n"));
6094 /* Version 7 indices generated by Gold have bad type unit references,
6095 PR binutils/15021. But we don't know if the index was generated by
6096 Gold or not, so to avoid worrying users with gdb-generated indices
6097 we say nothing for version 7 here. */
6099 cu_list_offset = byte_get_little_endian (start + 4, 4);
6100 tu_list_offset = byte_get_little_endian (start + 8, 4);
6101 address_table_offset = byte_get_little_endian (start + 12, 4);
6102 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6103 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6105 if (cu_list_offset > section->size
6106 || tu_list_offset > section->size
6107 || address_table_offset > section->size
6108 || symbol_table_offset > section->size
6109 || constant_pool_offset > section->size)
6111 warn (_("Corrupt header in the %s section.\n"), section->name);
6115 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6116 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6117 address_table_size = symbol_table_offset - address_table_offset;
6118 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6120 cu_list = start + cu_list_offset;
6121 tu_list = start + tu_list_offset;
6122 address_table = start + address_table_offset;
6123 symbol_table = start + symbol_table_offset;
6124 constant_pool = start + constant_pool_offset;
6126 printf (_("\nCU table:\n"));
6127 for (i = 0; i < cu_list_elements; i += 2)
6129 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6130 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6132 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6133 (unsigned long) cu_offset,
6134 (unsigned long) (cu_offset + cu_length - 1));
6137 printf (_("\nTU table:\n"));
6138 for (i = 0; i < tu_list_elements; i += 3)
6140 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6141 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6142 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6144 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6145 (unsigned long) tu_offset,
6146 (unsigned long) type_offset);
6147 print_dwarf_vma (signature, 8);
6151 printf (_("\nAddress table:\n"));
6152 for (i = 0; i < address_table_size; i += 2 * 8 + 4)
6154 uint64_t low = byte_get_little_endian (address_table + i, 8);
6155 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6156 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6158 print_dwarf_vma (low, 8);
6159 print_dwarf_vma (high, 8);
6160 printf (_("%lu\n"), (unsigned long) cu_index);
6163 printf (_("\nSymbol table:\n"));
6164 for (i = 0; i < symbol_table_slots; ++i)
6166 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6167 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6168 uint32_t num_cus, cu;
6170 if (name_offset != 0
6171 || cu_vector_offset != 0)
6175 printf ("[%3u] %s:", i, constant_pool + name_offset);
6176 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
6179 for (j = 0; j < num_cus; ++j)
6182 gdb_index_symbol_kind kind;
6184 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6185 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6186 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6187 cu = GDB_INDEX_CU_VALUE (cu);
6188 /* Convert to TU number if it's for a type unit. */
6189 if (cu >= cu_list_elements / 2)
6190 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6191 (unsigned long) (cu - cu_list_elements / 2));
6193 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6195 printf (" [%s, %s]",
6196 is_static ? _("static") : _("global"),
6197 get_gdb_index_symbol_kind_name (kind));
6209 /* Pre-allocate enough space for the CU/TU sets needed. */
6212 prealloc_cu_tu_list (unsigned int nshndx)
6214 if (shndx_pool == NULL)
6216 shndx_pool_size = nshndx;
6217 shndx_pool_used = 0;
6218 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6219 sizeof (unsigned int));
6223 shndx_pool_size = shndx_pool_used + nshndx;
6224 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6225 sizeof (unsigned int));
6230 add_shndx_to_cu_tu_entry (unsigned int shndx)
6232 if (shndx_pool_used >= shndx_pool_size)
6234 error (_("Internal error: out of space in the shndx pool.\n"));
6237 shndx_pool [shndx_pool_used++] = shndx;
6241 end_cu_tu_entry (void)
6243 if (shndx_pool_used >= shndx_pool_size)
6245 error (_("Internal error: out of space in the shndx pool.\n"));
6248 shndx_pool [shndx_pool_used++] = 0;
6251 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6254 get_DW_SECT_short_name (unsigned int dw_sect)
6256 static char buf[16];
6264 case DW_SECT_ABBREV:
6270 case DW_SECT_STR_OFFSETS:
6272 case DW_SECT_MACINFO:
6280 snprintf (buf, sizeof (buf), "%d", dw_sect);
6284 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6285 These sections are extensions for Fission.
6286 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6289 process_cu_tu_index (struct dwarf_section *section, int do_display)
6291 unsigned char *phdr = section->start;
6292 unsigned char *limit = phdr + section->size;
6293 unsigned char *phash;
6294 unsigned char *pindex;
6295 unsigned char *ppool;
6296 unsigned int version;
6297 unsigned int ncols = 0;
6299 unsigned int nslots;
6302 dwarf_vma signature_high;
6303 dwarf_vma signature_low;
6306 version = byte_get (phdr, 4);
6308 ncols = byte_get (phdr + 4, 4);
6309 nused = byte_get (phdr + 8, 4);
6310 nslots = byte_get (phdr + 12, 4);
6312 pindex = phash + nslots * 8;
6313 ppool = pindex + nslots * 4;
6317 printf (_("Contents of the %s section:\n\n"), section->name);
6318 printf (_(" Version: %d\n"), version);
6320 printf (_(" Number of columns: %d\n"), ncols);
6321 printf (_(" Number of used entries: %d\n"), nused);
6322 printf (_(" Number of slots: %d\n\n"), nslots);
6327 warn (_("Section %s too small for %d hash table entries\n"),
6328 section->name, nslots);
6335 prealloc_cu_tu_list ((limit - ppool) / 4);
6336 for (i = 0; i < nslots; i++)
6338 unsigned char *shndx_list;
6341 byte_get_64 (phash, &signature_high, &signature_low);
6342 if (signature_high != 0 || signature_low != 0)
6344 j = byte_get (pindex, 4);
6345 shndx_list = ppool + j * 4;
6347 printf (_(" [%3d] Signature: 0x%s Sections: "),
6348 i, dwarf_vmatoa64 (signature_high, signature_low,
6349 buf, sizeof (buf)));
6352 if (shndx_list >= limit)
6354 warn (_("Section %s too small for shndx pool\n"),
6358 shndx = byte_get (shndx_list, 4);
6362 printf (" %d", shndx);
6364 add_shndx_to_cu_tu_entry (shndx);
6376 else if (version == 2)
6379 unsigned int dw_sect;
6380 unsigned char *ph = phash;
6381 unsigned char *pi = pindex;
6382 unsigned char *poffsets = ppool + ncols * 4;
6383 unsigned char *psizes = poffsets + nused * ncols * 4;
6384 unsigned char *pend = psizes + nused * ncols * 4;
6385 bfd_boolean is_tu_index;
6386 struct cu_tu_set *this_set = NULL;
6388 unsigned char *prow;
6390 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
6394 warn (_("Section %s too small for offset and size tables\n"),
6401 printf (_(" Offset table\n"));
6402 printf (" slot %-16s ",
6403 is_tu_index ? _("signature") : _("dwo_id"));
6410 tu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
6416 cu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
6422 for (j = 0; j < ncols; j++)
6424 dw_sect = byte_get (ppool + j * 4, 4);
6425 printf (" %8s", get_DW_SECT_short_name (dw_sect));
6429 for (i = 0; i < nslots; i++)
6431 byte_get_64 (ph, &signature_high, &signature_low);
6432 row = byte_get (pi, 4);
6436 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
6437 prow = poffsets + (row - 1) * ncols * 4;
6439 printf (_(" [%3d] 0x%s"),
6440 i, dwarf_vmatoa64 (signature_high, signature_low,
6441 buf, sizeof (buf)));
6442 for (j = 0; j < ncols; j++)
6444 val = byte_get (prow + j * 4, 4);
6446 printf (" %8d", val);
6449 dw_sect = byte_get (ppool + j * 4, 4);
6450 this_set [row - 1].section_offsets [dw_sect] = val;
6465 printf (_(" Size table\n"));
6466 printf (" slot %-16s ",
6467 is_tu_index ? _("signature") : _("dwo_id"));
6469 for (j = 0; j < ncols; j++)
6471 val = byte_get (ppool + j * 4, 4);
6473 printf (" %8s", get_DW_SECT_short_name (val));
6477 for (i = 0; i < nslots; i++)
6479 byte_get_64 (ph, &signature_high, &signature_low);
6480 row = byte_get (pi, 4);
6483 prow = psizes + (row - 1) * ncols * 4;
6485 printf (_(" [%3d] 0x%s"),
6486 i, dwarf_vmatoa64 (signature_high, signature_low,
6487 buf, sizeof (buf)));
6488 for (j = 0; j < ncols; j++)
6490 val = byte_get (prow + j * 4, 4);
6492 printf (" %8d", val);
6495 dw_sect = byte_get (ppool + j * 4, 4);
6496 this_set [row - 1].section_sizes [dw_sect] = val;
6506 else if (do_display)
6507 printf (_(" Unsupported version\n"));
6515 /* Load the CU and TU indexes if present. This will build a list of
6516 section sets that we can use to associate a .debug_info.dwo section
6517 with its associated .debug_abbrev.dwo section in a .dwp file. */
6520 load_cu_tu_indexes (void *file)
6522 /* If we have already loaded (or tried to load) the CU and TU indexes
6523 then do not bother to repeat the task. */
6524 if (cu_tu_indexes_read)
6527 if (load_debug_section (dwp_cu_index, file))
6528 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
6530 if (load_debug_section (dwp_tu_index, file))
6531 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
6533 cu_tu_indexes_read = 1;
6536 /* Find the set of sections that includes section SHNDX. */
6539 find_cu_tu_set (void *file, unsigned int shndx)
6543 load_cu_tu_indexes (file);
6545 /* Find SHNDX in the shndx pool. */
6546 for (i = 0; i < shndx_pool_used; i++)
6547 if (shndx_pool [i] == shndx)
6550 if (i >= shndx_pool_used)
6553 /* Now backup to find the first entry in the set. */
6554 while (i > 0 && shndx_pool [i - 1] != 0)
6557 return shndx_pool + i;
6560 /* Display a .debug_cu_index or .debug_tu_index section. */
6563 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
6565 return process_cu_tu_index (section, 1);
6569 display_debug_not_supported (struct dwarf_section *section,
6570 void *file ATTRIBUTE_UNUSED)
6572 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6579 cmalloc (size_t nmemb, size_t size)
6581 /* Check for overflow. */
6582 if (nmemb >= ~(size_t) 0 / size)
6585 return malloc (nmemb * size);
6589 xcmalloc (size_t nmemb, size_t size)
6591 /* Check for overflow. */
6592 if (nmemb >= ~(size_t) 0 / size)
6595 return xmalloc (nmemb * size);
6599 xcrealloc (void *ptr, size_t nmemb, size_t size)
6601 /* Check for overflow. */
6602 if (nmemb >= ~(size_t) 0 / size)
6605 return xrealloc (ptr, nmemb * size);
6609 free_debug_memory (void)
6615 for (i = 0; i < max; i++)
6616 free_debug_section ((enum dwarf_section_display_enum) i);
6618 if (debug_information != NULL)
6620 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
6622 for (i = 0; i < num_debug_info_entries; i++)
6624 if (!debug_information [i].max_loc_offsets)
6626 free (debug_information [i].loc_offsets);
6627 free (debug_information [i].have_frame_base);
6629 if (!debug_information [i].max_range_lists)
6630 free (debug_information [i].range_lists);
6634 free (debug_information);
6635 debug_information = NULL;
6636 num_debug_info_entries = 0;
6641 dwarf_select_sections_by_names (const char *names)
6645 const char * option;
6649 debug_dump_long_opts;
6651 static const debug_dump_long_opts opts_table [] =
6653 /* Please keep this table alpha- sorted. */
6654 { "Ranges", & do_debug_ranges, 1 },
6655 { "abbrev", & do_debug_abbrevs, 1 },
6656 { "addr", & do_debug_addr, 1 },
6657 { "aranges", & do_debug_aranges, 1 },
6658 { "cu_index", & do_debug_cu_index, 1 },
6659 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
6660 { "frames", & do_debug_frames, 1 },
6661 { "frames-interp", & do_debug_frames_interp, 1 },
6662 /* The special .gdb_index section. */
6663 { "gdb_index", & do_gdb_index, 1 },
6664 { "info", & do_debug_info, 1 },
6665 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
6666 { "loc", & do_debug_loc, 1 },
6667 { "macro", & do_debug_macinfo, 1 },
6668 { "pubnames", & do_debug_pubnames, 1 },
6669 { "pubtypes", & do_debug_pubtypes, 1 },
6670 /* This entry is for compatability
6671 with earlier versions of readelf. */
6672 { "ranges", & do_debug_aranges, 1 },
6673 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
6674 { "str", & do_debug_str, 1 },
6675 /* These trace_* sections are used by Itanium VMS. */
6676 { "trace_abbrev", & do_trace_abbrevs, 1 },
6677 { "trace_aranges", & do_trace_aranges, 1 },
6678 { "trace_info", & do_trace_info, 1 },
6687 const debug_dump_long_opts * entry;
6689 for (entry = opts_table; entry->option; entry++)
6691 size_t len = strlen (entry->option);
6693 if (strncmp (p, entry->option, len) == 0
6694 && (p[len] == ',' || p[len] == '\0'))
6696 * entry->variable |= entry->val;
6698 /* The --debug-dump=frames-interp option also
6699 enables the --debug-dump=frames option. */
6700 if (do_debug_frames_interp)
6701 do_debug_frames = 1;
6708 if (entry->option == NULL)
6710 warn (_("Unrecognized debug option '%s'\n"), p);
6711 p = strchr (p, ',');
6722 dwarf_select_sections_by_letters (const char *letters)
6724 unsigned int lindex = 0;
6726 while (letters[lindex])
6727 switch (letters[lindex++])
6734 do_debug_abbrevs = 1;
6738 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
6742 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
6746 do_debug_pubnames = 1;
6750 do_debug_pubtypes = 1;
6754 do_debug_aranges = 1;
6758 do_debug_ranges = 1;
6762 do_debug_frames_interp = 1;
6764 do_debug_frames = 1;
6768 do_debug_macinfo = 1;
6780 warn (_("Unrecognized debug option '%s'\n"), optarg);
6786 dwarf_select_sections_all (void)
6789 do_debug_abbrevs = 1;
6790 do_debug_lines = FLAG_DEBUG_LINES_RAW;
6791 do_debug_pubnames = 1;
6792 do_debug_pubtypes = 1;
6793 do_debug_aranges = 1;
6794 do_debug_ranges = 1;
6795 do_debug_frames = 1;
6796 do_debug_macinfo = 1;
6801 do_trace_abbrevs = 1;
6802 do_trace_aranges = 1;
6804 do_debug_cu_index = 1;
6807 struct dwarf_section_display debug_displays[] =
6809 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0 },
6810 display_debug_abbrev, &do_debug_abbrevs, 0 },
6811 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0 },
6812 display_debug_aranges, &do_debug_aranges, 1 },
6813 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0 },
6814 display_debug_frames, &do_debug_frames, 1 },
6815 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev },
6816 display_debug_info, &do_debug_info, 1 },
6817 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0 },
6818 display_debug_lines, &do_debug_lines, 1 },
6819 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0 },
6820 display_debug_pubnames, &do_debug_pubnames, 0 },
6821 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0 },
6822 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
6823 { { ".eh_frame", "", NULL, NULL, 0, 0, 0 },
6824 display_debug_frames, &do_debug_frames, 1 },
6825 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0 },
6826 display_debug_macinfo, &do_debug_macinfo, 0 },
6827 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0 },
6828 display_debug_macro, &do_debug_macinfo, 1 },
6829 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0 },
6830 display_debug_str, &do_debug_str, 0 },
6831 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0 },
6832 display_debug_loc, &do_debug_loc, 1 },
6833 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0 },
6834 display_debug_pubnames, &do_debug_pubtypes, 0 },
6835 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0 },
6836 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
6837 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0 },
6838 display_debug_ranges, &do_debug_ranges, 1 },
6839 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0 },
6840 display_debug_not_supported, NULL, 0 },
6841 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0 },
6842 display_debug_not_supported, NULL, 0 },
6843 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev },
6844 display_debug_types, &do_debug_info, 1 },
6845 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0 },
6846 display_debug_not_supported, NULL, 0 },
6847 { { ".gdb_index", "", NULL, NULL, 0, 0, 0 },
6848 display_gdb_index, &do_gdb_index, 0 },
6849 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev },
6850 display_trace_info, &do_trace_info, 1 },
6851 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0 },
6852 display_debug_abbrev, &do_trace_abbrevs, 0 },
6853 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0 },
6854 display_debug_aranges, &do_trace_aranges, 0 },
6855 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo },
6856 display_debug_info, &do_debug_info, 1 },
6857 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0 },
6858 display_debug_abbrev, &do_debug_abbrevs, 0 },
6859 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo },
6860 display_debug_types, &do_debug_info, 1 },
6861 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0 },
6862 display_debug_lines, &do_debug_lines, 1 },
6863 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0 },
6864 display_debug_loc, &do_debug_loc, 1 },
6865 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0 },
6866 display_debug_macro, &do_debug_macinfo, 1 },
6867 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0 },
6868 display_debug_macinfo, &do_debug_macinfo, 0 },
6869 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0 },
6870 display_debug_str, &do_debug_str, 1 },
6871 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0 },
6872 display_debug_str_offsets, NULL, 0 },
6873 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0 },
6874 display_debug_str_offsets, NULL, 0 },
6875 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0 },
6876 display_debug_addr, &do_debug_addr, 1 },
6877 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0 },
6878 display_cu_index, &do_debug_cu_index, 0 },
6879 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0 },
6880 display_cu_index, &do_debug_cu_index, 0 },