1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2015 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 unsigned int alloc_num_debug_info_entries = 0;
42 static debug_info *debug_information = NULL;
43 /* Special value for num_debug_info_entries to indicate
44 that the .debug_info section could not be loaded/parsed. */
45 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
52 int do_debug_pubnames;
53 int do_debug_pubtypes;
57 int do_debug_frames_interp;
66 int do_debug_cu_index;
69 int dwarf_cutoff_level = -1;
70 unsigned long dwarf_start_die;
74 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
75 sections. For version 1 package files, each set is stored in SHNDX_POOL
76 as a zero-terminated list of section indexes comprising one set of debug
77 sections from a .dwo file. */
79 static int cu_tu_indexes_read = 0;
80 static unsigned int *shndx_pool = NULL;
81 static unsigned int shndx_pool_size = 0;
82 static unsigned int shndx_pool_used = 0;
84 /* For version 2 package files, each set contains an array of section offsets
85 and an array of section sizes, giving the offset and size of the
86 contribution from a CU or TU within one of the debug sections.
87 When displaying debug info from a package file, we need to use these
88 tables to locate the corresponding contributions to each section. */
93 dwarf_vma section_offsets[DW_SECT_MAX];
94 size_t section_sizes[DW_SECT_MAX];
97 static int cu_count = 0;
98 static int tu_count = 0;
99 static struct cu_tu_set *cu_sets = NULL;
100 static struct cu_tu_set *tu_sets = NULL;
102 static void load_cu_tu_indexes (void *file);
104 /* Values for do_debug_lines. */
105 #define FLAG_DEBUG_LINES_RAW 1
106 #define FLAG_DEBUG_LINES_DECODED 2
109 size_of_encoded_value (int encoding)
111 switch (encoding & 0x7)
114 case 0: return eh_addr_size;
122 get_encoded_value (unsigned char **pdata,
124 struct dwarf_section *section,
127 unsigned char * data = * pdata;
128 unsigned int size = size_of_encoded_value (encoding);
131 if (data + size >= end)
133 warn (_("Encoded value extends past end of section\n"));
138 /* PR 17512: file: 002-829853-0.004. */
141 warn (_("Encoded size of %d is too large to read\n"), size);
146 /* PR 17512: file: 1085-5603-0.004. */
149 warn (_("Encoded size of 0 is too small to read\n"));
154 if (encoding & DW_EH_PE_signed)
155 val = byte_get_signed (data, size);
157 val = byte_get (data, size);
159 if ((encoding & 0x70) == DW_EH_PE_pcrel)
160 val += section->address + (data - section->start);
162 * pdata = data + size;
166 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
168 # define DWARF_VMA_FMT "ll"
169 # define DWARF_VMA_FMT_LONG "%16.16llx"
171 # define DWARF_VMA_FMT "I64"
172 # define DWARF_VMA_FMT_LONG "%016I64x"
175 # define DWARF_VMA_FMT "l"
176 # define DWARF_VMA_FMT_LONG "%16.16lx"
179 /* Convert a dwarf vma value into a string. Returns a pointer to a static
180 buffer containing the converted VALUE. The value is converted according
181 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
182 it specifies the maximum number of bytes to be displayed in the converted
183 value and FMTCH is ignored - hex is always used. */
186 dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)
188 /* As dwarf_vmatoa is used more then once in a printf call
189 for output, we are cycling through an fixed array of pointers
190 for return address. */
191 static int buf_pos = 0;
192 static struct dwarf_vmatoa_buf
198 ret = buf[buf_pos++].place;
199 buf_pos %= ARRAY_SIZE (buf);
203 /* Printf does not have a way of specifiying a maximum field width for an
204 integer value, so we print the full value into a buffer and then select
205 the precision we need. */
206 snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);
209 return ret + (16 - 2 * num_bytes);
215 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
216 snprintf (ret, sizeof (buf[0].place), fmt, value);
221 static inline const char *
222 dwarf_vmatoa (const char * fmtch, dwarf_vma value)
224 return dwarf_vmatoa_1 (fmtch, value, 0);
227 /* Print a dwarf_vma value (typically an address, offset or length) in
228 hexadecimal format, followed by a space. The length of the VALUE (and
229 hence the precision displayed) is determined by the NUM_BYTES parameter. */
232 print_dwarf_vma (dwarf_vma value, unsigned num_bytes)
234 printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));
237 /* Format a 64-bit value, given as two 32-bit values, in hex.
238 For reentrancy, this uses a buffer provided by the caller. */
241 dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
242 unsigned int buf_len)
247 snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
250 len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
251 snprintf (buf + len, buf_len - len,
252 "%08" DWARF_VMA_FMT "x", lvalue);
258 /* Read in a LEB128 encoded value starting at address DATA.
259 If SIGN is true, return a signed LEB128 value.
260 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
261 No bytes will be read at address END or beyond. */
264 read_leb128 (unsigned char *data,
265 unsigned int *length_return,
267 const unsigned char * const end)
269 dwarf_vma result = 0;
270 unsigned int num_read = 0;
271 unsigned int shift = 0;
272 unsigned char byte = 0;
279 result |= ((dwarf_vma) (byte & 0x7f)) << shift;
282 if ((byte & 0x80) == 0)
286 if (length_return != NULL)
287 *length_return = num_read;
289 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
290 result |= (dwarf_vma) -1 << shift;
295 /* Create a signed version to avoid painful typecasts. */
296 static inline dwarf_signed_vma
297 read_sleb128 (unsigned char * data,
298 unsigned int * length_return,
299 const unsigned char * const end)
301 return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
304 static inline dwarf_vma
305 read_uleb128 (unsigned char * data,
306 unsigned int * length_return,
307 const unsigned char * const end)
309 return read_leb128 (data, length_return, FALSE, end);
312 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
315 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
316 unsigned int amount = (AMOUNT); \
317 if (((PTR) + amount) >= (END)) \
320 amount = (END) - (PTR); \
324 if (amount == 0 || amount > 8) \
327 VAL = byte_get ((PTR), amount); \
331 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
334 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
339 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
342 unsigned int amount = (AMOUNT); \
343 if (((PTR) + amount) >= (END)) \
346 amount = (END) - (PTR); \
351 VAL = byte_get_signed ((PTR), amount); \
357 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
360 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
365 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
368 if (((PTR) + 8) <= (END)) \
370 byte_get_64 ((PTR), (HIGH), (LOW)); \
374 * (LOW) = * (HIGH) = 0; \
379 typedef struct State_Machine_Registers
387 unsigned char op_index;
388 unsigned char end_sequence;
389 /* This variable hold the number of the last entry seen
390 in the File Table. */
391 unsigned int last_file_entry;
394 static SMR state_machine_regs;
397 reset_state_machine (int is_stmt)
399 state_machine_regs.address = 0;
400 state_machine_regs.op_index = 0;
401 state_machine_regs.file = 1;
402 state_machine_regs.line = 1;
403 state_machine_regs.column = 0;
404 state_machine_regs.is_stmt = is_stmt;
405 state_machine_regs.basic_block = 0;
406 state_machine_regs.end_sequence = 0;
407 state_machine_regs.last_file_entry = 0;
410 /* Handled an extend line op.
411 Returns the number of bytes read. */
414 process_extended_line_op (unsigned char * data,
418 unsigned char op_code;
419 unsigned int bytes_read;
422 unsigned char *orig_data = data;
425 len = read_uleb128 (data, & bytes_read, end);
428 if (len == 0 || data == end || len > (uintptr_t) (end - data))
430 warn (_("Badly formed extended line op encountered!\n"));
437 printf (_(" Extended opcode %d: "), op_code);
441 case DW_LNE_end_sequence:
442 printf (_("End of Sequence\n\n"));
443 reset_state_machine (is_stmt);
446 case DW_LNE_set_address:
447 /* PR 17512: file: 002-100480-0.004. */
448 if (len - bytes_read - 1 > 8)
449 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
450 len - bytes_read - 1);
451 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
452 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
453 state_machine_regs.address = adr;
454 state_machine_regs.op_index = 0;
457 case DW_LNE_define_file:
458 printf (_("define new File Table entry\n"));
459 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
460 printf (" %d\t", ++state_machine_regs.last_file_entry);
463 data += strnlen ((char *) data, end - data) + 1;
464 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
466 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
468 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
470 printf ("%s\n\n", name);
472 if (((unsigned int) (data - orig_data) != len) || data == end)
473 warn (_("DW_LNE_define_file: Bad opcode length\n"));
476 case DW_LNE_set_discriminator:
477 printf (_("set Discriminator to %s\n"),
478 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
482 case DW_LNE_HP_negate_is_UV_update:
483 printf ("DW_LNE_HP_negate_is_UV_update\n");
485 case DW_LNE_HP_push_context:
486 printf ("DW_LNE_HP_push_context\n");
488 case DW_LNE_HP_pop_context:
489 printf ("DW_LNE_HP_pop_context\n");
491 case DW_LNE_HP_set_file_line_column:
492 printf ("DW_LNE_HP_set_file_line_column\n");
494 case DW_LNE_HP_set_routine_name:
495 printf ("DW_LNE_HP_set_routine_name\n");
497 case DW_LNE_HP_set_sequence:
498 printf ("DW_LNE_HP_set_sequence\n");
500 case DW_LNE_HP_negate_post_semantics:
501 printf ("DW_LNE_HP_negate_post_semantics\n");
503 case DW_LNE_HP_negate_function_exit:
504 printf ("DW_LNE_HP_negate_function_exit\n");
506 case DW_LNE_HP_negate_front_end_logical:
507 printf ("DW_LNE_HP_negate_front_end_logical\n");
509 case DW_LNE_HP_define_proc:
510 printf ("DW_LNE_HP_define_proc\n");
512 case DW_LNE_HP_source_file_correlation:
514 unsigned char *edata = data + len - bytes_read - 1;
516 printf ("DW_LNE_HP_source_file_correlation\n");
522 opc = read_uleb128 (data, & bytes_read, edata);
527 case DW_LNE_HP_SFC_formfeed:
528 printf (" DW_LNE_HP_SFC_formfeed\n");
530 case DW_LNE_HP_SFC_set_listing_line:
531 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
533 read_uleb128 (data, & bytes_read, edata)));
536 case DW_LNE_HP_SFC_associate:
537 printf (" DW_LNE_HP_SFC_associate ");
540 read_uleb128 (data, & bytes_read, edata)));
544 read_uleb128 (data, & bytes_read, edata)));
548 read_uleb128 (data, & bytes_read, edata)));
552 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
562 unsigned int rlen = len - bytes_read - 1;
564 if (op_code >= DW_LNE_lo_user
565 /* The test against DW_LNW_hi_user is redundant due to
566 the limited range of the unsigned char data type used
568 /*&& op_code <= DW_LNE_hi_user*/)
569 printf (_("user defined: "));
571 printf (_("UNKNOWN: "));
572 printf (_("length %d ["), rlen);
574 printf (" %02x", *data++);
583 static const unsigned char *
584 fetch_indirect_string (dwarf_vma offset)
586 struct dwarf_section *section = &debug_displays [str].section;
588 if (section->start == NULL)
589 return (const unsigned char *) _("<no .debug_str section>");
591 if (offset > section->size)
593 warn (_("DW_FORM_strp offset too big: %s\n"),
594 dwarf_vmatoa ("x", offset));
595 return (const unsigned char *) _("<offset is too big>");
598 return (const unsigned char *) section->start + offset;
602 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
603 dwarf_vma offset_size, int dwo)
605 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
606 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
607 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
608 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
609 dwarf_vma index_offset = idx * offset_size;
610 dwarf_vma str_offset;
612 if (index_section->start == NULL)
613 return (dwo ? _("<no .debug_str_offsets.dwo section>")
614 : _("<no .debug_str_offsets section>"));
616 if (this_set != NULL)
617 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
618 if (index_offset > index_section->size)
620 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
621 dwarf_vmatoa ("x", index_offset));
622 return _("<index offset is too big>");
625 if (str_section->start == NULL)
626 return (dwo ? _("<no .debug_str.dwo section>")
627 : _("<no .debug_str section>"));
629 str_offset = byte_get (index_section->start + index_offset, offset_size);
630 str_offset -= str_section->address;
631 if (str_offset > str_section->size)
633 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
634 dwarf_vmatoa ("x", str_offset));
635 return _("<indirect index offset is too big>");
638 return (const char *) str_section->start + str_offset;
642 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
644 struct dwarf_section *section = &debug_displays [debug_addr].section;
646 if (section->start == NULL)
647 return (_("<no .debug_addr section>"));
649 if (offset + bytes > section->size)
651 warn (_("Offset into section %s too big: %s\n"),
652 section->name, dwarf_vmatoa ("x", offset));
653 return "<offset too big>";
656 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
660 /* FIXME: There are better and more efficient ways to handle
661 these structures. For now though, I just want something that
662 is simple to implement. */
663 typedef struct abbrev_attr
665 unsigned long attribute;
667 struct abbrev_attr *next;
671 typedef struct abbrev_entry
676 struct abbrev_attr *first_attr;
677 struct abbrev_attr *last_attr;
678 struct abbrev_entry *next;
682 static abbrev_entry *first_abbrev = NULL;
683 static abbrev_entry *last_abbrev = NULL;
690 for (abbrv = first_abbrev; abbrv;)
692 abbrev_entry *next_abbrev = abbrv->next;
695 for (attr = abbrv->first_attr; attr;)
697 abbrev_attr *next_attr = attr->next;
707 last_abbrev = first_abbrev = NULL;
711 add_abbrev (unsigned long number, unsigned long tag, int children)
715 entry = (abbrev_entry *) malloc (sizeof (*entry));
720 entry->entry = number;
722 entry->children = children;
723 entry->first_attr = NULL;
724 entry->last_attr = NULL;
727 if (first_abbrev == NULL)
728 first_abbrev = entry;
730 last_abbrev->next = entry;
736 add_abbrev_attr (unsigned long attribute, unsigned long form)
740 attr = (abbrev_attr *) malloc (sizeof (*attr));
745 attr->attribute = attribute;
749 if (last_abbrev->first_attr == NULL)
750 last_abbrev->first_attr = attr;
752 last_abbrev->last_attr->next = attr;
754 last_abbrev->last_attr = attr;
757 /* Processes the (partial) contents of a .debug_abbrev section.
758 Returns NULL if the end of the section was encountered.
759 Returns the address after the last byte read if the end of
760 an abbreviation set was found. */
762 static unsigned char *
763 process_abbrev_section (unsigned char *start, unsigned char *end)
765 if (first_abbrev != NULL)
770 unsigned int bytes_read;
773 unsigned long attribute;
776 entry = read_uleb128 (start, & bytes_read, end);
779 /* A single zero is supposed to end the section according
780 to the standard. If there's more, then signal that to
787 tag = read_uleb128 (start, & bytes_read, end);
794 add_abbrev (entry, tag, children);
800 attribute = read_uleb128 (start, & bytes_read, end);
805 form = read_uleb128 (start, & bytes_read, end);
810 add_abbrev_attr (attribute, form);
812 while (attribute != 0);
815 /* Report the missing single zero which ends the section. */
816 error (_(".debug_abbrev section not zero terminated\n"));
822 get_TAG_name (unsigned long tag)
824 const char *name = get_DW_TAG_name ((unsigned int)tag);
828 static char buffer[100];
830 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
838 get_FORM_name (unsigned long form)
843 return "DW_FORM value: 0";
845 name = get_DW_FORM_name (form);
848 static char buffer[100];
850 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
857 static unsigned char *
858 display_block (unsigned char *data,
860 const unsigned char * const end)
864 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
866 return (unsigned char *) end;
868 maxlen = (dwarf_vma) (end - data);
869 length = length > maxlen ? maxlen : length;
872 printf ("%lx ", (unsigned long) byte_get (data++, 1));
878 decode_location_expression (unsigned char * data,
879 unsigned int pointer_size,
880 unsigned int offset_size,
884 struct dwarf_section * section)
887 unsigned int bytes_read;
889 dwarf_signed_vma svalue;
890 unsigned char *end = data + length;
891 int need_frame_base = 0;
900 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
901 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
904 printf ("DW_OP_deref");
907 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
908 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
911 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
912 printf ("DW_OP_const1s: %ld", (long) svalue);
915 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
916 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
919 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
920 printf ("DW_OP_const2s: %ld", (long) svalue);
923 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
924 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
927 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
928 printf ("DW_OP_const4s: %ld", (long) svalue);
931 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
932 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
933 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
934 printf ("%lu", (unsigned long) uvalue);
937 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
938 printf ("DW_OP_const8s: %ld ", (long) svalue);
939 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
940 printf ("%ld", (long) svalue);
943 printf ("DW_OP_constu: %s",
944 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
948 printf ("DW_OP_consts: %s",
949 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
953 printf ("DW_OP_dup");
956 printf ("DW_OP_drop");
959 printf ("DW_OP_over");
962 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
963 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
966 printf ("DW_OP_swap");
969 printf ("DW_OP_rot");
972 printf ("DW_OP_xderef");
975 printf ("DW_OP_abs");
978 printf ("DW_OP_and");
981 printf ("DW_OP_div");
984 printf ("DW_OP_minus");
987 printf ("DW_OP_mod");
990 printf ("DW_OP_mul");
993 printf ("DW_OP_neg");
996 printf ("DW_OP_not");
1002 printf ("DW_OP_plus");
1004 case DW_OP_plus_uconst:
1005 printf ("DW_OP_plus_uconst: %s",
1006 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1010 printf ("DW_OP_shl");
1013 printf ("DW_OP_shr");
1016 printf ("DW_OP_shra");
1019 printf ("DW_OP_xor");
1022 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1023 printf ("DW_OP_bra: %ld", (long) svalue);
1026 printf ("DW_OP_eq");
1029 printf ("DW_OP_ge");
1032 printf ("DW_OP_gt");
1035 printf ("DW_OP_le");
1038 printf ("DW_OP_lt");
1041 printf ("DW_OP_ne");
1044 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1045 printf ("DW_OP_skip: %ld", (long) svalue);
1080 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1115 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1116 regname (op - DW_OP_reg0, 1));
1151 printf ("DW_OP_breg%d (%s): %s",
1153 regname (op - DW_OP_breg0, 1),
1154 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1159 uvalue = read_uleb128 (data, &bytes_read, end);
1161 printf ("DW_OP_regx: %s (%s)",
1162 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1165 need_frame_base = 1;
1166 printf ("DW_OP_fbreg: %s",
1167 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1171 uvalue = read_uleb128 (data, &bytes_read, end);
1173 printf ("DW_OP_bregx: %s (%s) %s",
1174 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1175 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1179 printf ("DW_OP_piece: %s",
1180 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1183 case DW_OP_deref_size:
1184 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1185 printf ("DW_OP_deref_size: %ld", (long) uvalue);
1187 case DW_OP_xderef_size:
1188 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1189 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1192 printf ("DW_OP_nop");
1195 /* DWARF 3 extensions. */
1196 case DW_OP_push_object_address:
1197 printf ("DW_OP_push_object_address");
1200 /* XXX: Strictly speaking for 64-bit DWARF3 files
1201 this ought to be an 8-byte wide computation. */
1202 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1203 printf ("DW_OP_call2: <0x%s>",
1204 dwarf_vmatoa ("x", svalue + cu_offset));
1207 /* XXX: Strictly speaking for 64-bit DWARF3 files
1208 this ought to be an 8-byte wide computation. */
1209 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1210 printf ("DW_OP_call4: <0x%s>",
1211 dwarf_vmatoa ("x", svalue + cu_offset));
1213 case DW_OP_call_ref:
1214 /* XXX: Strictly speaking for 64-bit DWARF3 files
1215 this ought to be an 8-byte wide computation. */
1216 if (dwarf_version == -1)
1218 printf (_("(DW_OP_call_ref in frame info)"));
1219 /* No way to tell where the next op is, so just bail. */
1220 return need_frame_base;
1222 if (dwarf_version == 2)
1224 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1228 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1230 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1232 case DW_OP_form_tls_address:
1233 printf ("DW_OP_form_tls_address");
1235 case DW_OP_call_frame_cfa:
1236 printf ("DW_OP_call_frame_cfa");
1238 case DW_OP_bit_piece:
1239 printf ("DW_OP_bit_piece: ");
1240 printf (_("size: %s "),
1241 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1243 printf (_("offset: %s "),
1244 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1248 /* DWARF 4 extensions. */
1249 case DW_OP_stack_value:
1250 printf ("DW_OP_stack_value");
1253 case DW_OP_implicit_value:
1254 printf ("DW_OP_implicit_value");
1255 uvalue = read_uleb128 (data, &bytes_read, end);
1257 data = display_block (data, uvalue, end);
1260 /* GNU extensions. */
1261 case DW_OP_GNU_push_tls_address:
1262 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1264 case DW_OP_GNU_uninit:
1265 printf ("DW_OP_GNU_uninit");
1266 /* FIXME: Is there data associated with this OP ? */
1268 case DW_OP_GNU_encoded_addr:
1275 addr = get_encoded_value (&data, encoding, section, end);
1277 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1278 print_dwarf_vma (addr, pointer_size);
1281 case DW_OP_GNU_implicit_pointer:
1282 /* XXX: Strictly speaking for 64-bit DWARF3 files
1283 this ought to be an 8-byte wide computation. */
1284 if (dwarf_version == -1)
1286 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1287 /* No way to tell where the next op is, so just bail. */
1288 return need_frame_base;
1290 if (dwarf_version == 2)
1292 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1296 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1298 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1299 dwarf_vmatoa ("x", uvalue),
1300 dwarf_vmatoa ("d", read_sleb128 (data,
1301 &bytes_read, end)));
1304 case DW_OP_GNU_entry_value:
1305 uvalue = read_uleb128 (data, &bytes_read, end);
1307 /* PR 17531: file: 0cc9cd00. */
1308 if (uvalue > (dwarf_vma) (end - data))
1309 uvalue = end - data;
1310 printf ("DW_OP_GNU_entry_value: (");
1311 if (decode_location_expression (data, pointer_size, offset_size,
1312 dwarf_version, uvalue,
1313 cu_offset, section))
1314 need_frame_base = 1;
1320 case DW_OP_GNU_const_type:
1321 uvalue = read_uleb128 (data, &bytes_read, end);
1323 printf ("DW_OP_GNU_const_type: <0x%s> ",
1324 dwarf_vmatoa ("x", cu_offset + uvalue));
1325 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1326 data = display_block (data, uvalue, end);
1328 case DW_OP_GNU_regval_type:
1329 uvalue = read_uleb128 (data, &bytes_read, end);
1331 printf ("DW_OP_GNU_regval_type: %s (%s)",
1332 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1333 uvalue = read_uleb128 (data, &bytes_read, end);
1335 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1337 case DW_OP_GNU_deref_type:
1338 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1339 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue);
1340 uvalue = read_uleb128 (data, &bytes_read, end);
1342 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1344 case DW_OP_GNU_convert:
1345 uvalue = read_uleb128 (data, &bytes_read, end);
1347 printf ("DW_OP_GNU_convert <0x%s>",
1348 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1350 case DW_OP_GNU_reinterpret:
1351 uvalue = read_uleb128 (data, &bytes_read, end);
1353 printf ("DW_OP_GNU_reinterpret <0x%s>",
1354 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1356 case DW_OP_GNU_parameter_ref:
1357 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1358 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1359 dwarf_vmatoa ("x", cu_offset + uvalue));
1361 case DW_OP_GNU_addr_index:
1362 uvalue = read_uleb128 (data, &bytes_read, end);
1364 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1366 case DW_OP_GNU_const_index:
1367 uvalue = read_uleb128 (data, &bytes_read, end);
1369 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1372 /* HP extensions. */
1373 case DW_OP_HP_is_value:
1374 printf ("DW_OP_HP_is_value");
1375 /* FIXME: Is there data associated with this OP ? */
1377 case DW_OP_HP_fltconst4:
1378 printf ("DW_OP_HP_fltconst4");
1379 /* FIXME: Is there data associated with this OP ? */
1381 case DW_OP_HP_fltconst8:
1382 printf ("DW_OP_HP_fltconst8");
1383 /* FIXME: Is there data associated with this OP ? */
1385 case DW_OP_HP_mod_range:
1386 printf ("DW_OP_HP_mod_range");
1387 /* FIXME: Is there data associated with this OP ? */
1389 case DW_OP_HP_unmod_range:
1390 printf ("DW_OP_HP_unmod_range");
1391 /* FIXME: Is there data associated with this OP ? */
1394 printf ("DW_OP_HP_tls");
1395 /* FIXME: Is there data associated with this OP ? */
1398 /* PGI (STMicroelectronics) extensions. */
1399 case DW_OP_PGI_omp_thread_num:
1400 /* Pushes the thread number for the current thread as it would be
1401 returned by the standard OpenMP library function:
1402 omp_get_thread_num(). The "current thread" is the thread for
1403 which the expression is being evaluated. */
1404 printf ("DW_OP_PGI_omp_thread_num");
1408 if (op >= DW_OP_lo_user
1409 && op <= DW_OP_hi_user)
1410 printf (_("(User defined location op)"));
1412 printf (_("(Unknown location op)"));
1413 /* No way to tell where the next op is, so just bail. */
1414 return need_frame_base;
1417 /* Separate the ops. */
1422 return need_frame_base;
1425 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1426 This is used for DWARF package files. */
1428 static struct cu_tu_set *
1429 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1431 struct cu_tu_set *p;
1433 unsigned int dw_sect;
1439 dw_sect = DW_SECT_TYPES;
1445 dw_sect = DW_SECT_INFO;
1449 if (p->section_offsets [dw_sect] == cu_offset)
1457 /* Add INC to HIGH_BITS:LOW_BITS. */
1459 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1461 dwarf_vma tmp = * low_bits;
1465 /* FIXME: There is probably a better way of handling this:
1467 We need to cope with dwarf_vma being a 32-bit or 64-bit
1468 type. Plus regardless of its size LOW_BITS is meant to
1469 only hold 32-bits, so if there is overflow or wrap around
1470 we must propagate into HIGH_BITS. */
1471 if (tmp < * low_bits)
1475 else if (sizeof (tmp) > 8
1485 static unsigned char *
1486 read_and_display_attr_value (unsigned long attribute,
1488 unsigned char * data,
1489 unsigned char * end,
1490 dwarf_vma cu_offset,
1491 dwarf_vma pointer_size,
1492 dwarf_vma offset_size,
1494 debug_info * debug_info_p,
1496 struct dwarf_section * section,
1497 struct cu_tu_set * this_set)
1499 dwarf_vma uvalue = 0;
1500 unsigned char *block_start = NULL;
1501 unsigned char * orig_data = data;
1502 unsigned int bytes_read;
1504 if (data > end || (data == end && form != DW_FORM_flag_present))
1506 warn (_("Corrupt attribute\n"));
1515 case DW_FORM_ref_addr:
1516 if (dwarf_version == 2)
1517 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1518 else if (dwarf_version == 3 || dwarf_version == 4)
1519 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1521 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1526 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1530 case DW_FORM_sec_offset:
1531 case DW_FORM_GNU_ref_alt:
1532 case DW_FORM_GNU_strp_alt:
1533 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1536 case DW_FORM_flag_present:
1543 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1548 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1553 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1557 uvalue = read_sleb128 (data, & bytes_read, end);
1561 case DW_FORM_GNU_str_index:
1562 uvalue = read_uleb128 (data, & bytes_read, end);
1566 case DW_FORM_ref_udata:
1568 uvalue = read_uleb128 (data, & bytes_read, end);
1572 case DW_FORM_indirect:
1573 form = read_uleb128 (data, & bytes_read, end);
1576 printf (" %s", get_FORM_name (form));
1577 return read_and_display_attr_value (attribute, form, data, end,
1578 cu_offset, pointer_size,
1579 offset_size, dwarf_version,
1580 debug_info_p, do_loc,
1582 case DW_FORM_GNU_addr_index:
1583 uvalue = read_uleb128 (data, & bytes_read, end);
1590 case DW_FORM_ref_addr:
1592 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1595 case DW_FORM_GNU_ref_alt:
1597 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue));
1603 case DW_FORM_ref_udata:
1605 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1610 case DW_FORM_sec_offset:
1612 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1615 case DW_FORM_flag_present:
1622 printf (" %s", dwarf_vmatoa ("d", uvalue));
1629 dwarf_vma high_bits;
1633 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1635 if (form == DW_FORM_ref8)
1636 add64 (& high_bits, & utmp, cu_offset);
1638 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1641 if ((do_loc || do_debug_loc || do_debug_ranges)
1642 && num_debug_info_entries == 0)
1644 if (sizeof (uvalue) == 8)
1645 SAFE_BYTE_GET (uvalue, data, 8, end);
1647 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1653 case DW_FORM_string:
1655 printf (" %.*s", (int) (end - data), data);
1656 data += strnlen ((char *) data, end - data) + 1;
1660 case DW_FORM_exprloc:
1661 uvalue = read_uleb128 (data, & bytes_read, end);
1662 block_start = data + bytes_read;
1663 if (block_start >= end)
1665 warn (_("Block ends prematurely\n"));
1669 /* PR 17512: file: 008-103549-0.001:0.1. */
1670 if (block_start + uvalue > end)
1672 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1673 uvalue = end - block_start;
1676 data = block_start + uvalue;
1678 data = display_block (block_start, uvalue, end);
1681 case DW_FORM_block1:
1682 SAFE_BYTE_GET (uvalue, data, 1, end);
1683 block_start = data + 1;
1684 if (block_start >= end)
1686 warn (_("Block ends prematurely\n"));
1690 if (block_start + uvalue > end)
1692 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1693 uvalue = end - block_start;
1696 data = block_start + uvalue;
1698 data = display_block (block_start, uvalue, end);
1701 case DW_FORM_block2:
1702 SAFE_BYTE_GET (uvalue, data, 2, end);
1703 block_start = data + 2;
1704 if (block_start >= end)
1706 warn (_("Block ends prematurely\n"));
1710 if (block_start + uvalue > end)
1712 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1713 uvalue = end - block_start;
1716 data = block_start + uvalue;
1718 data = display_block (block_start, uvalue, end);
1721 case DW_FORM_block4:
1722 SAFE_BYTE_GET (uvalue, data, 4, end);
1723 block_start = data + 4;
1724 /* PR 17512: file: 3371-3907-0.004. */
1725 if (block_start >= end)
1727 warn (_("Block ends prematurely\n"));
1731 if (block_start + uvalue > end)
1733 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1734 uvalue = end - block_start;
1737 data = block_start + uvalue;
1739 data = display_block (block_start, uvalue, end);
1744 printf (_(" (indirect string, offset: 0x%s): %s"),
1745 dwarf_vmatoa ("x", uvalue),
1746 fetch_indirect_string (uvalue));
1749 case DW_FORM_GNU_str_index:
1752 const char *suffix = strrchr (section->name, '.');
1753 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1755 printf (_(" (indexed string: 0x%s): %s"),
1756 dwarf_vmatoa ("x", uvalue),
1757 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1761 case DW_FORM_GNU_strp_alt:
1763 printf (_(" (alt indirect string, offset: 0x%s)"),
1764 dwarf_vmatoa ("x", uvalue));
1767 case DW_FORM_indirect:
1768 /* Handled above. */
1771 case DW_FORM_ref_sig8:
1774 dwarf_vma high_bits;
1777 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1778 printf (" signature: 0x%s",
1779 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
1784 case DW_FORM_GNU_addr_index:
1786 printf (_(" (addr_index: 0x%s): %s"),
1787 dwarf_vmatoa ("x", uvalue),
1788 fetch_indexed_value (uvalue * pointer_size, pointer_size));
1792 warn (_("Unrecognized form: %lu\n"), form);
1796 if ((do_loc || do_debug_loc || do_debug_ranges)
1797 && num_debug_info_entries == 0
1798 && debug_info_p != NULL)
1802 case DW_AT_frame_base:
1803 have_frame_base = 1;
1804 case DW_AT_location:
1805 case DW_AT_string_length:
1806 case DW_AT_return_addr:
1807 case DW_AT_data_member_location:
1808 case DW_AT_vtable_elem_location:
1810 case DW_AT_static_link:
1811 case DW_AT_use_location:
1812 case DW_AT_GNU_call_site_value:
1813 case DW_AT_GNU_call_site_data_value:
1814 case DW_AT_GNU_call_site_target:
1815 case DW_AT_GNU_call_site_target_clobbered:
1816 if ((dwarf_version < 4
1817 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1818 || form == DW_FORM_sec_offset)
1820 /* Process location list. */
1821 unsigned int lmax = debug_info_p->max_loc_offsets;
1822 unsigned int num = debug_info_p->num_loc_offsets;
1824 if (lmax == 0 || num >= lmax)
1827 debug_info_p->loc_offsets = (dwarf_vma *)
1828 xcrealloc (debug_info_p->loc_offsets,
1829 lmax, sizeof (*debug_info_p->loc_offsets));
1830 debug_info_p->have_frame_base = (int *)
1831 xcrealloc (debug_info_p->have_frame_base,
1832 lmax, sizeof (*debug_info_p->have_frame_base));
1833 debug_info_p->max_loc_offsets = lmax;
1835 if (this_set != NULL)
1836 uvalue += this_set->section_offsets [DW_SECT_LOC];
1837 debug_info_p->loc_offsets [num] = uvalue;
1838 debug_info_p->have_frame_base [num] = have_frame_base;
1839 debug_info_p->num_loc_offsets++;
1844 if (need_base_address)
1845 debug_info_p->base_address = uvalue;
1848 case DW_AT_GNU_addr_base:
1849 debug_info_p->addr_base = uvalue;
1852 case DW_AT_GNU_ranges_base:
1853 debug_info_p->ranges_base = uvalue;
1857 if ((dwarf_version < 4
1858 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1859 || form == DW_FORM_sec_offset)
1861 /* Process range list. */
1862 unsigned int lmax = debug_info_p->max_range_lists;
1863 unsigned int num = debug_info_p->num_range_lists;
1865 if (lmax == 0 || num >= lmax)
1868 debug_info_p->range_lists = (dwarf_vma *)
1869 xcrealloc (debug_info_p->range_lists,
1870 lmax, sizeof (*debug_info_p->range_lists));
1871 debug_info_p->max_range_lists = lmax;
1873 debug_info_p->range_lists [num] = uvalue;
1874 debug_info_p->num_range_lists++;
1883 if (do_loc || attribute == 0)
1886 /* For some attributes we can display further information. */
1893 case DW_INL_not_inlined:
1894 printf (_("(not inlined)"));
1896 case DW_INL_inlined:
1897 printf (_("(inlined)"));
1899 case DW_INL_declared_not_inlined:
1900 printf (_("(declared as inline but ignored)"));
1902 case DW_INL_declared_inlined:
1903 printf (_("(declared as inline and inlined)"));
1906 printf (_(" (Unknown inline attribute value: %s)"),
1907 dwarf_vmatoa ("x", uvalue));
1912 case DW_AT_language:
1916 /* Ordered by the numeric value of these constants. */
1917 case DW_LANG_C89: printf ("(ANSI C)"); break;
1918 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1919 case DW_LANG_Ada83: printf ("(Ada)"); break;
1920 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1921 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1922 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1923 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1924 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1925 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1926 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1927 /* DWARF 2.1 values. */
1928 case DW_LANG_Java: printf ("(Java)"); break;
1929 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1930 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1931 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1932 /* DWARF 3 values. */
1933 case DW_LANG_PLI: printf ("(PLI)"); break;
1934 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1935 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1936 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1937 case DW_LANG_D: printf ("(D)"); break;
1938 /* DWARF 4 values. */
1939 case DW_LANG_Python: printf ("(Python)"); break;
1940 /* DWARF 5 values. */
1941 case DW_LANG_Go: printf ("(Go)"); break;
1942 case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break;
1943 case DW_LANG_C11: printf ("(C11)"); break;
1944 case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break;
1945 /* MIPS extension. */
1946 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1947 /* UPC extension. */
1948 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1950 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1951 printf (_("(implementation defined: %s)"),
1952 dwarf_vmatoa ("x", uvalue));
1954 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
1959 case DW_AT_encoding:
1963 case DW_ATE_void: printf ("(void)"); break;
1964 case DW_ATE_address: printf ("(machine address)"); break;
1965 case DW_ATE_boolean: printf ("(boolean)"); break;
1966 case DW_ATE_complex_float: printf ("(complex float)"); break;
1967 case DW_ATE_float: printf ("(float)"); break;
1968 case DW_ATE_signed: printf ("(signed)"); break;
1969 case DW_ATE_signed_char: printf ("(signed char)"); break;
1970 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1971 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1972 /* DWARF 2.1 values: */
1973 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1974 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1975 /* DWARF 3 values: */
1976 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1977 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1978 case DW_ATE_edited: printf ("(edited)"); break;
1979 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1980 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1981 /* HP extensions: */
1982 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1983 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1984 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1985 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1986 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1987 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1988 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1991 if (uvalue >= DW_ATE_lo_user
1992 && uvalue <= DW_ATE_hi_user)
1993 printf (_("(user defined type)"));
1995 printf (_("(unknown type)"));
2000 case DW_AT_accessibility:
2004 case DW_ACCESS_public: printf ("(public)"); break;
2005 case DW_ACCESS_protected: printf ("(protected)"); break;
2006 case DW_ACCESS_private: printf ("(private)"); break;
2008 printf (_("(unknown accessibility)"));
2013 case DW_AT_visibility:
2017 case DW_VIS_local: printf ("(local)"); break;
2018 case DW_VIS_exported: printf ("(exported)"); break;
2019 case DW_VIS_qualified: printf ("(qualified)"); break;
2020 default: printf (_("(unknown visibility)")); break;
2024 case DW_AT_virtuality:
2028 case DW_VIRTUALITY_none: printf ("(none)"); break;
2029 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2030 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2031 default: printf (_("(unknown virtuality)")); break;
2035 case DW_AT_identifier_case:
2039 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2040 case DW_ID_up_case: printf ("(up_case)"); break;
2041 case DW_ID_down_case: printf ("(down_case)"); break;
2042 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
2043 default: printf (_("(unknown case)")); break;
2047 case DW_AT_calling_convention:
2051 case DW_CC_normal: printf ("(normal)"); break;
2052 case DW_CC_program: printf ("(program)"); break;
2053 case DW_CC_nocall: printf ("(nocall)"); break;
2055 if (uvalue >= DW_CC_lo_user
2056 && uvalue <= DW_CC_hi_user)
2057 printf (_("(user defined)"));
2059 printf (_("(unknown convention)"));
2063 case DW_AT_ordering:
2067 case -1: printf (_("(undefined)")); break;
2068 case 0: printf ("(row major)"); break;
2069 case 1: printf ("(column major)"); break;
2073 case DW_AT_frame_base:
2074 have_frame_base = 1;
2075 case DW_AT_location:
2076 case DW_AT_string_length:
2077 case DW_AT_return_addr:
2078 case DW_AT_data_member_location:
2079 case DW_AT_vtable_elem_location:
2081 case DW_AT_static_link:
2082 case DW_AT_use_location:
2083 case DW_AT_GNU_call_site_value:
2084 case DW_AT_GNU_call_site_data_value:
2085 case DW_AT_GNU_call_site_target:
2086 case DW_AT_GNU_call_site_target_clobbered:
2087 if ((dwarf_version < 4
2088 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2089 || form == DW_FORM_sec_offset)
2090 printf (_(" (location list)"));
2092 case DW_AT_allocated:
2093 case DW_AT_associated:
2094 case DW_AT_data_location:
2096 case DW_AT_upper_bound:
2097 case DW_AT_lower_bound:
2100 int need_frame_base;
2103 need_frame_base = decode_location_expression (block_start,
2108 cu_offset, section);
2110 if (need_frame_base && !have_frame_base)
2111 printf (_(" [without DW_AT_frame_base]"));
2117 if (form == DW_FORM_ref_sig8
2118 || form == DW_FORM_GNU_ref_alt)
2121 if (form == DW_FORM_ref1
2122 || form == DW_FORM_ref2
2123 || form == DW_FORM_ref4
2124 || form == DW_FORM_ref_udata)
2125 uvalue += cu_offset;
2127 if (uvalue >= section->size)
2128 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2129 dwarf_vmatoa ("x", uvalue),
2130 (unsigned long) (orig_data - section->start));
2133 unsigned long abbrev_number;
2134 abbrev_entry * entry;
2136 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2138 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2139 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2140 use different abbrev table, and we don't track .debug_info chunks
2142 if (form != DW_FORM_ref_addr)
2144 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2145 if (entry->entry == abbrev_number)
2148 printf (" (%s)", get_TAG_name (entry->tag));
2163 get_AT_name (unsigned long attribute)
2168 return "DW_AT value: 0";
2170 /* One value is shared by the MIPS and HP extensions: */
2171 if (attribute == DW_AT_MIPS_fde)
2172 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2174 name = get_DW_AT_name (attribute);
2178 static char buffer[100];
2180 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2188 static unsigned char *
2189 read_and_display_attr (unsigned long attribute,
2191 unsigned char * data,
2192 unsigned char * end,
2193 dwarf_vma cu_offset,
2194 dwarf_vma pointer_size,
2195 dwarf_vma offset_size,
2197 debug_info * debug_info_p,
2199 struct dwarf_section * section,
2200 struct cu_tu_set * this_set)
2203 printf (" %-18s:", get_AT_name (attribute));
2204 data = read_and_display_attr_value (attribute, form, data, end,
2205 cu_offset, pointer_size, offset_size,
2206 dwarf_version, debug_info_p,
2207 do_loc, section, this_set);
2213 /* Process the contents of a .debug_info section. If do_loc is non-zero
2214 then we are scanning for location lists and we do not want to display
2215 anything to the user. If do_types is non-zero, we are processing
2216 a .debug_types section instead of a .debug_info section. */
2219 process_debug_info (struct dwarf_section *section,
2221 enum dwarf_section_display_enum abbrev_sec,
2225 unsigned char *start = section->start;
2226 unsigned char *end = start + section->size;
2227 unsigned char *section_begin;
2229 unsigned int num_units = 0;
2231 if ((do_loc || do_debug_loc || do_debug_ranges)
2232 && num_debug_info_entries == 0
2237 /* First scan the section to get the number of comp units. */
2238 for (section_begin = start, num_units = 0; section_begin < end;
2241 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2242 will be the length. For a 64-bit DWARF section, it'll be
2243 the escape code 0xffffffff followed by an 8 byte length. */
2244 SAFE_BYTE_GET (length, section_begin, 4, end);
2246 if (length == 0xffffffff)
2248 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2249 section_begin += length + 12;
2251 else if (length >= 0xfffffff0 && length < 0xffffffff)
2253 warn (_("Reserved length value (0x%s) found in section %s\n"),
2254 dwarf_vmatoa ("x", length), section->name);
2258 section_begin += length + 4;
2260 /* Negative values are illegal, they may even cause infinite
2261 looping. This can happen if we can't accurately apply
2262 relocations to an object file. */
2263 if ((signed long) length <= 0)
2265 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2266 dwarf_vmatoa ("x", length), section->name);
2273 error (_("No comp units in %s section ?\n"), section->name);
2277 /* Then allocate an array to hold the information. */
2278 debug_information = (debug_info *) cmalloc (num_units,
2279 sizeof (* debug_information));
2280 if (debug_information == NULL)
2282 error (_("Not enough memory for a debug info array of %u entries\n"),
2284 alloc_num_debug_info_entries = num_debug_info_entries = 0;
2287 alloc_num_debug_info_entries = num_units;
2292 if (dwarf_start_die == 0)
2293 printf (_("Contents of the %s section:\n\n"), section->name);
2295 load_debug_section (str, file);
2296 load_debug_section (str_dwo, file);
2297 load_debug_section (str_index, file);
2298 load_debug_section (str_index_dwo, file);
2299 load_debug_section (debug_addr, file);
2302 load_debug_section (abbrev_sec, file);
2303 if (debug_displays [abbrev_sec].section.start == NULL)
2305 warn (_("Unable to locate %s section!\n"),
2306 debug_displays [abbrev_sec].section.name);
2310 for (section_begin = start, unit = 0; start < end; unit++)
2312 DWARF2_Internal_CompUnit compunit;
2313 unsigned char *hdrptr;
2314 unsigned char *tags;
2315 int level, last_level, saved_level;
2316 dwarf_vma cu_offset;
2317 unsigned int offset_size;
2318 int initial_length_size;
2319 dwarf_vma signature_high = 0;
2320 dwarf_vma signature_low = 0;
2321 dwarf_vma type_offset = 0;
2322 struct cu_tu_set *this_set;
2323 dwarf_vma abbrev_base;
2328 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2330 if (compunit.cu_length == 0xffffffff)
2332 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2334 initial_length_size = 12;
2339 initial_length_size = 4;
2342 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2344 cu_offset = start - section_begin;
2346 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2348 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2350 if (this_set == NULL)
2353 abbrev_size = debug_displays [abbrev_sec].section.size;
2357 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2358 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2361 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2362 /* PR 17512: file: 001-108546-0.001:0.1. */
2363 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2365 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2366 compunit.cu_pointer_size, offset_size);
2367 compunit.cu_pointer_size = offset_size;
2372 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2374 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2377 if ((do_loc || do_debug_loc || do_debug_ranges)
2378 && num_debug_info_entries == 0
2381 debug_information [unit].cu_offset = cu_offset;
2382 debug_information [unit].pointer_size
2383 = compunit.cu_pointer_size;
2384 debug_information [unit].offset_size = offset_size;
2385 debug_information [unit].dwarf_version = compunit.cu_version;
2386 debug_information [unit].base_address = 0;
2387 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2388 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2389 debug_information [unit].loc_offsets = NULL;
2390 debug_information [unit].have_frame_base = NULL;
2391 debug_information [unit].max_loc_offsets = 0;
2392 debug_information [unit].num_loc_offsets = 0;
2393 debug_information [unit].range_lists = NULL;
2394 debug_information [unit].max_range_lists= 0;
2395 debug_information [unit].num_range_lists = 0;
2398 if (!do_loc && dwarf_start_die == 0)
2400 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2401 dwarf_vmatoa ("x", cu_offset));
2402 printf (_(" Length: 0x%s (%s)\n"),
2403 dwarf_vmatoa ("x", compunit.cu_length),
2404 offset_size == 8 ? "64-bit" : "32-bit");
2405 printf (_(" Version: %d\n"), compunit.cu_version);
2406 printf (_(" Abbrev Offset: 0x%s\n"),
2407 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2408 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2413 printf (_(" Signature: 0x%s\n"),
2414 dwarf_vmatoa64 (signature_high, signature_low,
2415 buf, sizeof (buf)));
2416 printf (_(" Type Offset: 0x%s\n"),
2417 dwarf_vmatoa ("x", type_offset));
2419 if (this_set != NULL)
2421 dwarf_vma *offsets = this_set->section_offsets;
2422 size_t *sizes = this_set->section_sizes;
2424 printf (_(" Section contributions:\n"));
2425 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2426 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2427 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2428 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2429 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2430 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2431 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2432 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2433 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2434 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2435 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2436 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2440 if (cu_offset + compunit.cu_length + initial_length_size
2443 warn (_("Debug info is corrupted, length of CU at %s"
2444 " extends beyond end of section (length = %s)\n"),
2445 dwarf_vmatoa ("x", cu_offset),
2446 dwarf_vmatoa ("x", compunit.cu_length));
2451 start += compunit.cu_length + initial_length_size;
2455 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2456 dwarf_vmatoa ("x", cu_offset));
2460 if (compunit.cu_version != 2
2461 && compunit.cu_version != 3
2462 && compunit.cu_version != 4)
2464 warn (_("CU at offset %s contains corrupt or "
2465 "unsupported version number: %d.\n"),
2466 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2472 /* Process the abbrevs used by this compilation unit. */
2473 if (compunit.cu_abbrev_offset >= abbrev_size)
2474 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2475 (unsigned long) compunit.cu_abbrev_offset,
2476 (unsigned long) abbrev_size);
2477 /* PR 17531: file:4bcd9ce9. */
2478 else if ((abbrev_base + abbrev_size)
2479 > debug_displays [abbrev_sec].section.size)
2480 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2481 (unsigned long) abbrev_base + abbrev_size,
2482 (unsigned long) debug_displays [abbrev_sec].section.size);
2484 process_abbrev_section
2485 (((unsigned char *) debug_displays [abbrev_sec].section.start
2486 + abbrev_base + compunit.cu_abbrev_offset),
2487 ((unsigned char *) debug_displays [abbrev_sec].section.start
2488 + abbrev_base + abbrev_size));
2493 while (tags < start)
2495 unsigned int bytes_read;
2496 unsigned long abbrev_number;
2497 unsigned long die_offset;
2498 abbrev_entry *entry;
2500 int do_printing = 1;
2502 die_offset = tags - section_begin;
2504 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2507 /* A null DIE marks the end of a list of siblings or it may also be
2508 a section padding. */
2509 if (abbrev_number == 0)
2511 /* Check if it can be a section padding for the last CU. */
2512 if (level == 0 && start == end)
2516 for (chk = tags; chk < start; chk++)
2523 if (!do_loc && die_offset >= dwarf_start_die
2524 && (dwarf_cutoff_level == -1
2525 || level < dwarf_cutoff_level))
2526 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2532 static unsigned num_bogus_warns = 0;
2534 if (num_bogus_warns < 3)
2536 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2537 die_offset, section->name);
2539 if (num_bogus_warns == 3)
2540 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2543 if (dwarf_start_die != 0 && level < saved_level)
2550 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2554 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2555 saved_level = level;
2556 do_printing = (dwarf_cutoff_level == -1
2557 || level < dwarf_cutoff_level);
2559 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2560 level, die_offset, abbrev_number);
2561 else if (dwarf_cutoff_level == -1
2562 || last_level < dwarf_cutoff_level)
2563 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2568 /* Scan through the abbreviation list until we reach the
2570 for (entry = first_abbrev;
2571 entry && entry->entry != abbrev_number;
2572 entry = entry->next)
2577 if (!do_loc && do_printing)
2582 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2583 die_offset, abbrev_number);
2587 if (!do_loc && do_printing)
2588 printf (" (%s)\n", get_TAG_name (entry->tag));
2593 need_base_address = 0;
2595 case DW_TAG_compile_unit:
2596 need_base_address = 1;
2598 case DW_TAG_entry_point:
2599 case DW_TAG_subprogram:
2600 need_base_address = 0;
2601 /* Assuming that there is no DW_AT_frame_base. */
2602 have_frame_base = 0;
2606 for (attr = entry->first_attr;
2607 attr && attr->attribute;
2612 if (! do_loc && do_printing)
2613 /* Show the offset from where the tag was extracted. */
2614 printf (" <%lx>", (unsigned long)(tags - section_begin));
2616 if (debug_information && unit < alloc_num_debug_info_entries)
2617 arg = debug_information + unit;
2621 tags = read_and_display_attr (attr->attribute,
2626 compunit.cu_pointer_size,
2628 compunit.cu_version,
2630 do_loc || ! do_printing,
2635 if (entry->children)
2640 /* Set num_debug_info_entries here so that it can be used to check if
2641 we need to process .debug_loc and .debug_ranges sections. */
2642 if ((do_loc || do_debug_loc || do_debug_ranges)
2643 && num_debug_info_entries == 0
2646 if (num_units > alloc_num_debug_info_entries)
2647 num_debug_info_entries = alloc_num_debug_info_entries;
2649 num_debug_info_entries = num_units;
2658 /* Locate and scan the .debug_info section in the file and record the pointer
2659 sizes and offsets for the compilation units in it. Usually an executable
2660 will have just one pointer size, but this is not guaranteed, and so we try
2661 not to make any assumptions. Returns zero upon failure, or the number of
2662 compilation units upon success. */
2665 load_debug_info (void * file)
2667 /* Reset the last pointer size so that we can issue correct error
2668 messages if we are displaying the contents of more than one section. */
2669 last_pointer_size = 0;
2670 warned_about_missing_comp_units = FALSE;
2672 /* If we have already tried and failed to load the .debug_info
2673 section then do not bother to repeat the task. */
2674 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2677 /* If we already have the information there is nothing else to do. */
2678 if (num_debug_info_entries > 0)
2679 return num_debug_info_entries;
2681 /* If this is a DWARF package file, load the CU and TU indexes. */
2682 load_cu_tu_indexes (file);
2684 if (load_debug_section (info, file)
2685 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2686 return num_debug_info_entries;
2688 if (load_debug_section (info_dwo, file)
2689 && process_debug_info (&debug_displays [info_dwo].section, file,
2691 return num_debug_info_entries;
2693 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2697 /* Read a DWARF .debug_line section header starting at DATA.
2698 Upon success returns an updated DATA pointer and the LINFO
2699 structure and the END_OF_SEQUENCE pointer will be filled in.
2700 Otherwise returns NULL. */
2702 static unsigned char *
2703 read_debug_line_header (struct dwarf_section * section,
2704 unsigned char * data,
2705 unsigned char * end,
2706 DWARF2_Internal_LineInfo * linfo,
2707 unsigned char ** end_of_sequence)
2709 unsigned char *hdrptr;
2710 unsigned int offset_size;
2711 unsigned int initial_length_size;
2713 /* Extract information from the Line Number Program Header.
2714 (section 6.2.4 in the Dwarf3 doc). */
2717 /* Get and check the length of the block. */
2718 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2720 if (linfo->li_length == 0xffffffff)
2722 /* This section is 64-bit DWARF 3. */
2723 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2725 initial_length_size = 12;
2730 initial_length_size = 4;
2733 if (linfo->li_length + initial_length_size > section->size)
2735 /* If the length is just a bias against the initial_length_size then
2736 this means that the field has a relocation against it which has not
2737 been applied. (Ie we are dealing with an object file, not a linked
2738 binary). Do not complain but instead assume that the rest of the
2739 section applies to this particular header. */
2740 if (linfo->li_length == - initial_length_size)
2742 linfo->li_length = section->size - initial_length_size;
2746 warn (_("The line info appears to be corrupt - the section is too small\n"));
2751 /* Get and check the version number. */
2752 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2754 if (linfo->li_version != 2
2755 && linfo->li_version != 3
2756 && linfo->li_version != 4)
2758 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2762 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2763 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2765 if (linfo->li_version >= 4)
2767 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2769 if (linfo->li_max_ops_per_insn == 0)
2771 warn (_("Invalid maximum operations per insn.\n"));
2776 linfo->li_max_ops_per_insn = 1;
2778 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2779 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2780 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2781 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2783 * end_of_sequence = data + linfo->li_length + initial_length_size;
2784 /* PR 17512: file:002-117414-0.004. */
2785 if (* end_of_sequence > end)
2787 warn (_("Line length %s extends beyond end of section\n"),
2788 dwarf_vmatoa ("u", linfo->li_length));
2789 * end_of_sequence = end;
2797 display_debug_lines_raw (struct dwarf_section *section,
2798 unsigned char *data,
2801 unsigned char *start = section->start;
2803 printf (_("Raw dump of debug contents of section %s:\n\n"),
2808 static DWARF2_Internal_LineInfo saved_linfo;
2809 DWARF2_Internal_LineInfo linfo;
2810 unsigned char *standard_opcodes;
2811 unsigned char *end_of_sequence;
2812 unsigned int last_dir_entry = 0;
2815 if (const_strneq (section->name, ".debug_line.")
2816 /* Note: the following does not apply to .debug_line.dwo sections.
2817 These are full debug_line sections. */
2818 && strcmp (section->name, ".debug_line.dwo") != 0)
2820 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2821 section containing just the Line Number Statements. They are
2822 created by the assembler and intended to be used alongside gcc's
2823 -ffunction-sections command line option. When the linker's
2824 garbage collection decides to discard a .text.<foo> section it
2825 can then also discard the line number information in .debug_line.<foo>.
2827 Since the section is a fragment it does not have the details
2828 needed to fill out a LineInfo structure, so instead we use the
2829 details from the last full debug_line section that we processed. */
2830 end_of_sequence = end;
2831 standard_opcodes = NULL;
2832 linfo = saved_linfo;
2833 /* PR 17531: file: 0522b371. */
2834 if (linfo.li_line_range == 0)
2836 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2839 reset_state_machine (linfo.li_default_is_stmt);
2843 unsigned char * hdrptr;
2845 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2846 & end_of_sequence)) == NULL)
2849 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
2850 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2851 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2852 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2853 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2854 if (linfo.li_version >= 4)
2855 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2856 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2857 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2858 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2859 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2861 /* PR 17512: file: 1665-6428-0.004. */
2862 if (linfo.li_line_range == 0)
2864 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2865 linfo.li_line_range = 1;
2868 reset_state_machine (linfo.li_default_is_stmt);
2870 /* Display the contents of the Opcodes table. */
2871 standard_opcodes = hdrptr;
2873 /* PR 17512: file: 002-417945-0.004. */
2874 if (standard_opcodes + linfo.li_opcode_base >= end)
2876 warn (_("Line Base extends beyond end of section\n"));
2880 printf (_("\n Opcodes:\n"));
2882 for (i = 1; i < linfo.li_opcode_base; i++)
2883 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2885 /* Display the contents of the Directory table. */
2886 data = standard_opcodes + linfo.li_opcode_base - 1;
2889 printf (_("\n The Directory Table is empty.\n"));
2892 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2893 (long)(data - start));
2895 while (data < end && *data != 0)
2897 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2899 data += strnlen ((char *) data, end - data) + 1;
2902 /* PR 17512: file: 002-132094-0.004. */
2903 if (data >= end - 1)
2907 /* Skip the NUL at the end of the table. */
2910 /* Display the contents of the File Name table. */
2912 printf (_("\n The File Name Table is empty.\n"));
2915 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2916 (long)(data - start));
2917 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2919 while (data < end && *data != 0)
2921 unsigned char *name;
2922 unsigned int bytes_read;
2924 printf (" %d\t", ++state_machine_regs.last_file_entry);
2926 data += strnlen ((char *) data, end - data) + 1;
2929 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2932 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2935 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2937 printf ("%.*s\n", (int)(end - name), name);
2941 warn (_("Corrupt file name table entry\n"));
2947 /* Skip the NUL at the end of the table. */
2950 saved_linfo = linfo;
2953 /* Now display the statements. */
2954 if (data >= end_of_sequence)
2955 printf (_(" No Line Number Statements.\n"));
2958 printf (_(" Line Number Statements:\n"));
2960 while (data < end_of_sequence)
2962 unsigned char op_code;
2963 dwarf_signed_vma adv;
2965 unsigned int bytes_read;
2967 printf (" [0x%08lx]", (long)(data - start));
2971 if (op_code >= linfo.li_opcode_base)
2973 op_code -= linfo.li_opcode_base;
2974 uladv = (op_code / linfo.li_line_range);
2975 if (linfo.li_max_ops_per_insn == 1)
2977 uladv *= linfo.li_min_insn_length;
2978 state_machine_regs.address += uladv;
2979 printf (_(" Special opcode %d: "
2980 "advance Address by %s to 0x%s"),
2981 op_code, dwarf_vmatoa ("u", uladv),
2982 dwarf_vmatoa ("x", state_machine_regs.address));
2986 state_machine_regs.address
2987 += ((state_machine_regs.op_index + uladv)
2988 / linfo.li_max_ops_per_insn)
2989 * linfo.li_min_insn_length;
2990 state_machine_regs.op_index
2991 = (state_machine_regs.op_index + uladv)
2992 % linfo.li_max_ops_per_insn;
2993 printf (_(" Special opcode %d: "
2994 "advance Address by %s to 0x%s[%d]"),
2995 op_code, dwarf_vmatoa ("u", uladv),
2996 dwarf_vmatoa ("x", state_machine_regs.address),
2997 state_machine_regs.op_index);
2999 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3000 state_machine_regs.line += adv;
3001 printf (_(" and Line by %s to %d\n"),
3002 dwarf_vmatoa ("d", adv), state_machine_regs.line);
3004 else switch (op_code)
3006 case DW_LNS_extended_op:
3007 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3011 printf (_(" Copy\n"));
3014 case DW_LNS_advance_pc:
3015 uladv = read_uleb128 (data, & bytes_read, end);
3017 if (linfo.li_max_ops_per_insn == 1)
3019 uladv *= linfo.li_min_insn_length;
3020 state_machine_regs.address += uladv;
3021 printf (_(" Advance PC by %s to 0x%s\n"),
3022 dwarf_vmatoa ("u", uladv),
3023 dwarf_vmatoa ("x", state_machine_regs.address));
3027 state_machine_regs.address
3028 += ((state_machine_regs.op_index + uladv)
3029 / linfo.li_max_ops_per_insn)
3030 * linfo.li_min_insn_length;
3031 state_machine_regs.op_index
3032 = (state_machine_regs.op_index + uladv)
3033 % linfo.li_max_ops_per_insn;
3034 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3035 dwarf_vmatoa ("u", uladv),
3036 dwarf_vmatoa ("x", state_machine_regs.address),
3037 state_machine_regs.op_index);
3041 case DW_LNS_advance_line:
3042 adv = read_sleb128 (data, & bytes_read, end);
3044 state_machine_regs.line += adv;
3045 printf (_(" Advance Line by %s to %d\n"),
3046 dwarf_vmatoa ("d", adv),
3047 state_machine_regs.line);
3050 case DW_LNS_set_file:
3051 adv = read_uleb128 (data, & bytes_read, end);
3053 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3054 dwarf_vmatoa ("d", adv));
3055 state_machine_regs.file = adv;
3058 case DW_LNS_set_column:
3059 uladv = read_uleb128 (data, & bytes_read, end);
3061 printf (_(" Set column to %s\n"),
3062 dwarf_vmatoa ("u", uladv));
3063 state_machine_regs.column = uladv;
3066 case DW_LNS_negate_stmt:
3067 adv = state_machine_regs.is_stmt;
3069 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3070 state_machine_regs.is_stmt = adv;
3073 case DW_LNS_set_basic_block:
3074 printf (_(" Set basic block\n"));
3075 state_machine_regs.basic_block = 1;
3078 case DW_LNS_const_add_pc:
3079 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3080 if (linfo.li_max_ops_per_insn)
3082 uladv *= linfo.li_min_insn_length;
3083 state_machine_regs.address += uladv;
3084 printf (_(" Advance PC by constant %s to 0x%s\n"),
3085 dwarf_vmatoa ("u", uladv),
3086 dwarf_vmatoa ("x", state_machine_regs.address));
3090 state_machine_regs.address
3091 += ((state_machine_regs.op_index + uladv)
3092 / linfo.li_max_ops_per_insn)
3093 * linfo.li_min_insn_length;
3094 state_machine_regs.op_index
3095 = (state_machine_regs.op_index + uladv)
3096 % linfo.li_max_ops_per_insn;
3097 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3098 dwarf_vmatoa ("u", uladv),
3099 dwarf_vmatoa ("x", state_machine_regs.address),
3100 state_machine_regs.op_index);
3104 case DW_LNS_fixed_advance_pc:
3105 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3106 state_machine_regs.address += uladv;
3107 state_machine_regs.op_index = 0;
3108 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3109 dwarf_vmatoa ("u", uladv),
3110 dwarf_vmatoa ("x", state_machine_regs.address));
3113 case DW_LNS_set_prologue_end:
3114 printf (_(" Set prologue_end to true\n"));
3117 case DW_LNS_set_epilogue_begin:
3118 printf (_(" Set epilogue_begin to true\n"));
3121 case DW_LNS_set_isa:
3122 uladv = read_uleb128 (data, & bytes_read, end);
3124 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3128 printf (_(" Unknown opcode %d with operands: "), op_code);
3130 if (standard_opcodes != NULL)
3131 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3133 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3135 i == 1 ? "" : ", ");
3151 unsigned char *name;
3152 unsigned int directory_index;
3153 unsigned int modification_date;
3154 unsigned int length;
3157 /* Output a decoded representation of the .debug_line section. */
3160 display_debug_lines_decoded (struct dwarf_section *section,
3161 unsigned char *data,
3164 static DWARF2_Internal_LineInfo saved_linfo;
3166 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3171 /* This loop amounts to one iteration per compilation unit. */
3172 DWARF2_Internal_LineInfo linfo;
3173 unsigned char *standard_opcodes;
3174 unsigned char *end_of_sequence;
3176 File_Entry *file_table = NULL;
3177 unsigned int n_files = 0;
3178 unsigned char **directory_table = NULL;
3179 unsigned int n_directories = 0;
3181 if (const_strneq (section->name, ".debug_line.")
3182 /* Note: the following does not apply to .debug_line.dwo sections.
3183 These are full debug_line sections. */
3184 && strcmp (section->name, ".debug_line.dwo") != 0)
3186 /* See comment in display_debug_lines_raw(). */
3187 end_of_sequence = end;
3188 standard_opcodes = NULL;
3189 linfo = saved_linfo;
3190 /* PR 17531: file: 0522b371. */
3191 if (linfo.li_line_range == 0)
3193 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3196 reset_state_machine (linfo.li_default_is_stmt);
3200 unsigned char *hdrptr;
3202 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3203 & end_of_sequence)) == NULL)
3206 /* PR 17531: file: 0522b371. */
3207 if (linfo.li_line_range == 0)
3209 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3210 linfo.li_line_range = 1;
3212 reset_state_machine (linfo.li_default_is_stmt);
3214 /* Save a pointer to the contents of the Opcodes table. */
3215 standard_opcodes = hdrptr;
3217 /* Traverse the Directory table just to count entries. */
3218 data = standard_opcodes + linfo.li_opcode_base - 1;
3221 unsigned char *ptr_directory_table = data;
3225 data += strnlen ((char *) data, end - data) + 1;
3229 /* Go through the directory table again to save the directories. */
3230 directory_table = (unsigned char **)
3231 xmalloc (n_directories * sizeof (unsigned char *));
3234 while (*ptr_directory_table != 0)
3236 directory_table[i] = ptr_directory_table;
3237 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3238 ptr_directory_table - end) + 1;
3242 /* Skip the NUL at the end of the table. */
3245 /* Traverse the File Name table just to count the entries. */
3248 unsigned char *ptr_file_name_table = data;
3252 unsigned int bytes_read;
3254 /* Skip Name, directory index, last modification time and length
3256 data += strnlen ((char *) data, end - data) + 1;
3257 read_uleb128 (data, & bytes_read, end);
3259 read_uleb128 (data, & bytes_read, end);
3261 read_uleb128 (data, & bytes_read, end);
3267 /* Go through the file table again to save the strings. */
3268 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3271 while (*ptr_file_name_table != 0)
3273 unsigned int bytes_read;
3275 file_table[i].name = ptr_file_name_table;
3276 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3277 end - ptr_file_name_table) + 1;
3279 /* We are not interested in directory, time or size. */
3280 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3282 ptr_file_name_table += bytes_read;
3283 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3285 ptr_file_name_table += bytes_read;
3286 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3287 ptr_file_name_table += bytes_read;
3292 /* Print the Compilation Unit's name and a header. */
3293 if (directory_table == NULL)
3295 printf (_("CU: %s:\n"), file_table[0].name);
3296 printf (_("File name Line number Starting address\n"));
3300 unsigned int ix = file_table[0].directory_index;
3301 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3303 if (do_wide || strlen (directory) < 76)
3304 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3306 printf ("%s:\n", file_table[0].name);
3308 printf (_("File name Line number Starting address\n"));
3312 /* Skip the NUL at the end of the table. */
3315 saved_linfo = linfo;
3318 /* This loop iterates through the Dwarf Line Number Program. */
3319 while (data < end_of_sequence)
3321 unsigned char op_code;
3323 unsigned long int uladv;
3324 unsigned int bytes_read;
3325 int is_special_opcode = 0;
3329 if (op_code >= linfo.li_opcode_base)
3331 op_code -= linfo.li_opcode_base;
3332 uladv = (op_code / linfo.li_line_range);
3333 if (linfo.li_max_ops_per_insn == 1)
3335 uladv *= linfo.li_min_insn_length;
3336 state_machine_regs.address += uladv;
3340 state_machine_regs.address
3341 += ((state_machine_regs.op_index + uladv)
3342 / linfo.li_max_ops_per_insn)
3343 * linfo.li_min_insn_length;
3344 state_machine_regs.op_index
3345 = (state_machine_regs.op_index + uladv)
3346 % linfo.li_max_ops_per_insn;
3349 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3350 state_machine_regs.line += adv;
3351 is_special_opcode = 1;
3353 else switch (op_code)
3355 case DW_LNS_extended_op:
3357 unsigned int ext_op_code_len;
3358 unsigned char ext_op_code;
3359 unsigned char *op_code_data = data;
3361 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3363 op_code_data += bytes_read;
3365 if (ext_op_code_len == 0)
3367 warn (_("Badly formed extended line op encountered!\n"));
3370 ext_op_code_len += bytes_read;
3371 ext_op_code = *op_code_data++;
3373 switch (ext_op_code)
3375 case DW_LNE_end_sequence:
3376 reset_state_machine (linfo.li_default_is_stmt);
3378 case DW_LNE_set_address:
3379 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3381 ext_op_code_len - bytes_read - 1,
3383 state_machine_regs.op_index = 0;
3385 case DW_LNE_define_file:
3387 file_table = (File_Entry *) xrealloc
3388 (file_table, (n_files + 1) * sizeof (File_Entry));
3390 ++state_machine_regs.last_file_entry;
3391 /* Source file name. */
3392 file_table[n_files].name = op_code_data;
3393 op_code_data += strlen ((char *) op_code_data) + 1;
3394 /* Directory index. */
3395 file_table[n_files].directory_index =
3396 read_uleb128 (op_code_data, & bytes_read,
3398 op_code_data += bytes_read;
3399 /* Last modification time. */
3400 file_table[n_files].modification_date =
3401 read_uleb128 (op_code_data, & bytes_read,
3403 op_code_data += bytes_read;
3405 file_table[n_files].length =
3406 read_uleb128 (op_code_data, & bytes_read,
3412 case DW_LNE_set_discriminator:
3413 case DW_LNE_HP_set_sequence:
3414 /* Simply ignored. */
3418 printf (_("UNKNOWN (%u): length %d\n"),
3419 ext_op_code, ext_op_code_len - bytes_read);
3422 data += ext_op_code_len;
3428 case DW_LNS_advance_pc:
3429 uladv = read_uleb128 (data, & bytes_read, end);
3431 if (linfo.li_max_ops_per_insn == 1)
3433 uladv *= linfo.li_min_insn_length;
3434 state_machine_regs.address += uladv;
3438 state_machine_regs.address
3439 += ((state_machine_regs.op_index + uladv)
3440 / linfo.li_max_ops_per_insn)
3441 * linfo.li_min_insn_length;
3442 state_machine_regs.op_index
3443 = (state_machine_regs.op_index + uladv)
3444 % linfo.li_max_ops_per_insn;
3448 case DW_LNS_advance_line:
3449 adv = read_sleb128 (data, & bytes_read, end);
3451 state_machine_regs.line += adv;
3454 case DW_LNS_set_file:
3455 adv = read_uleb128 (data, & bytes_read, end);
3457 state_machine_regs.file = adv;
3459 if (file_table == NULL)
3460 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3461 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3462 /* If directory index is 0, that means current directory. */
3463 printf ("\n./%s:[++]\n",
3464 file_table[state_machine_regs.file - 1].name);
3465 else if (directory_table == NULL)
3466 printf (_("\n [Use directory table entry %d]\n"),
3467 file_table[state_machine_regs.file - 1].directory_index - 1);
3469 /* The directory index starts counting at 1. */
3470 printf ("\n%s/%s:\n",
3471 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3472 file_table[state_machine_regs.file - 1].name);
3475 case DW_LNS_set_column:
3476 uladv = read_uleb128 (data, & bytes_read, end);
3478 state_machine_regs.column = uladv;
3481 case DW_LNS_negate_stmt:
3482 adv = state_machine_regs.is_stmt;
3484 state_machine_regs.is_stmt = adv;
3487 case DW_LNS_set_basic_block:
3488 state_machine_regs.basic_block = 1;
3491 case DW_LNS_const_add_pc:
3492 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3493 if (linfo.li_max_ops_per_insn == 1)
3495 uladv *= linfo.li_min_insn_length;
3496 state_machine_regs.address += uladv;
3500 state_machine_regs.address
3501 += ((state_machine_regs.op_index + uladv)
3502 / linfo.li_max_ops_per_insn)
3503 * linfo.li_min_insn_length;
3504 state_machine_regs.op_index
3505 = (state_machine_regs.op_index + uladv)
3506 % linfo.li_max_ops_per_insn;
3510 case DW_LNS_fixed_advance_pc:
3511 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3512 state_machine_regs.address += uladv;
3513 state_machine_regs.op_index = 0;
3516 case DW_LNS_set_prologue_end:
3519 case DW_LNS_set_epilogue_begin:
3522 case DW_LNS_set_isa:
3523 uladv = read_uleb128 (data, & bytes_read, end);
3525 printf (_(" Set ISA to %lu\n"), uladv);
3529 printf (_(" Unknown opcode %d with operands: "), op_code);
3531 if (standard_opcodes != NULL)
3532 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3534 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3536 i == 1 ? "" : ", ");
3543 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3544 to the DWARF address/line matrix. */
3545 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3546 || (op_code == DW_LNS_copy))
3548 const unsigned int MAX_FILENAME_LENGTH = 35;
3550 char *newFileName = NULL;
3551 size_t fileNameLength;
3554 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3556 fileName = "<unknown>";
3558 fileNameLength = strlen (fileName);
3560 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3562 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3563 /* Truncate file name */
3564 strncpy (newFileName,
3565 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3566 MAX_FILENAME_LENGTH + 1);
3570 newFileName = (char *) xmalloc (fileNameLength + 1);
3571 strncpy (newFileName, fileName, fileNameLength + 1);
3574 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3576 if (linfo.li_max_ops_per_insn == 1)
3577 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3578 newFileName, state_machine_regs.line,
3579 state_machine_regs.address);
3581 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3582 newFileName, state_machine_regs.line,
3583 state_machine_regs.address,
3584 state_machine_regs.op_index);
3588 if (linfo.li_max_ops_per_insn == 1)
3589 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3590 newFileName, state_machine_regs.line,
3591 state_machine_regs.address);
3593 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3594 newFileName, state_machine_regs.line,
3595 state_machine_regs.address,
3596 state_machine_regs.op_index);
3599 if (op_code == DW_LNE_end_sequence)
3613 if (directory_table)
3615 free (directory_table);
3616 directory_table = NULL;
3627 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3629 unsigned char *data = section->start;
3630 unsigned char *end = data + section->size;
3632 int retValDecoded = 1;
3634 if (do_debug_lines == 0)
3635 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3637 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3638 retValRaw = display_debug_lines_raw (section, data, end);
3640 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3641 retValDecoded = display_debug_lines_decoded (section, data, end);
3643 if (!retValRaw || !retValDecoded)
3650 find_debug_info_for_offset (unsigned long offset)
3654 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3657 for (i = 0; i < num_debug_info_entries; i++)
3658 if (debug_information[i].cu_offset == offset)
3659 return debug_information + i;
3665 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3667 /* See gdb/gdb-index.h. */
3668 static const char * const kinds[] =
3680 return _ (kinds[kind]);
3684 display_debug_pubnames_worker (struct dwarf_section *section,
3685 void *file ATTRIBUTE_UNUSED,
3688 DWARF2_Internal_PubNames names;
3689 unsigned char *start = section->start;
3690 unsigned char *end = start + section->size;
3692 /* It does not matter if this load fails,
3693 we test for that later on. */
3694 load_debug_info (file);
3696 printf (_("Contents of the %s section:\n\n"), section->name);
3700 unsigned char *data;
3701 unsigned long offset;
3702 unsigned int offset_size, initial_length_size;
3706 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3707 if (names.pn_length == 0xffffffff)
3709 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3711 initial_length_size = 12;
3716 initial_length_size = 4;
3719 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3720 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3722 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3723 && num_debug_info_entries > 0
3724 && find_debug_info_for_offset (names.pn_offset) == NULL)
3725 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3726 (unsigned long) names.pn_offset, section->name);
3728 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3730 /* PR 17531: file: 7615b6b2. */
3731 if ((dwarf_signed_vma) names.pn_length < 0
3732 /* PR 17531: file: a5dbeaa7. */
3733 || start + names.pn_length + initial_length_size < start)
3735 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3739 start += names.pn_length + initial_length_size;
3741 printf (_(" Length: %ld\n"),
3742 (long) names.pn_length);
3743 printf (_(" Version: %d\n"),
3745 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3746 (unsigned long) names.pn_offset);
3747 printf (_(" Size of area in .debug_info section: %ld\n"),
3748 (long) names.pn_size);
3750 if (names.pn_version != 2 && names.pn_version != 3)
3752 static int warned = 0;
3756 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3764 printf (_("\n Offset Kind Name\n"));
3766 printf (_("\n Offset\tName\n"));
3770 bfd_size_type maxprint;
3772 SAFE_BYTE_GET (offset, data, offset_size, end);
3776 data += offset_size;
3779 maxprint = (end - data) - 1;
3783 unsigned int kind_data;
3784 gdb_index_symbol_kind kind;
3785 const char *kind_name;
3788 SAFE_BYTE_GET (kind_data, data, 1, end);
3791 /* GCC computes the kind as the upper byte in the CU index
3792 word, and then right shifts it by the CU index size.
3793 Left shift KIND to where the gdb-index.h accessor macros
3795 kind_data <<= GDB_INDEX_CU_BITSIZE;
3796 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3797 kind_name = get_gdb_index_symbol_kind_name (kind);
3798 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3799 printf (" %-6lx %s,%-10s %.*s\n",
3800 offset, is_static ? _("s") : _("g"),
3801 kind_name, (int) maxprint, data);
3804 printf (" %-6lx\t%.*s\n", offset, (int) maxprint, data);
3806 data += strnlen ((char *) data, maxprint) + 1;
3811 while (offset != 0);
3819 display_debug_pubnames (struct dwarf_section *section, void *file)
3821 return display_debug_pubnames_worker (section, file, 0);
3825 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3827 return display_debug_pubnames_worker (section, file, 1);
3831 display_debug_macinfo (struct dwarf_section *section,
3832 void *file ATTRIBUTE_UNUSED)
3834 unsigned char *start = section->start;
3835 unsigned char *end = start + section->size;
3836 unsigned char *curr = start;
3837 unsigned int bytes_read;
3838 enum dwarf_macinfo_record_type op;
3840 printf (_("Contents of the %s section:\n\n"), section->name);
3844 unsigned int lineno;
3845 const unsigned char *string;
3847 op = (enum dwarf_macinfo_record_type) *curr;
3852 case DW_MACINFO_start_file:
3854 unsigned int filenum;
3856 lineno = read_uleb128 (curr, & bytes_read, end);
3858 filenum = read_uleb128 (curr, & bytes_read, end);
3861 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3866 case DW_MACINFO_end_file:
3867 printf (_(" DW_MACINFO_end_file\n"));
3870 case DW_MACINFO_define:
3871 lineno = read_uleb128 (curr, & bytes_read, end);
3874 curr += strnlen ((char *) string, end - string) + 1;
3875 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3879 case DW_MACINFO_undef:
3880 lineno = read_uleb128 (curr, & bytes_read, end);
3883 curr += strnlen ((char *) string, end - string) + 1;
3884 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3888 case DW_MACINFO_vendor_ext:
3890 unsigned int constant;
3892 constant = read_uleb128 (curr, & bytes_read, end);
3895 curr += strnlen ((char *) string, end - string) + 1;
3896 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3906 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3907 filename and dirname corresponding to file name table entry with index
3908 FILEIDX. Return NULL on failure. */
3910 static unsigned char *
3911 get_line_filename_and_dirname (dwarf_vma line_offset,
3913 unsigned char **dir_name)
3915 struct dwarf_section *section = &debug_displays [line].section;
3916 unsigned char *hdrptr, *dirtable, *file_name;
3917 unsigned int offset_size, initial_length_size;
3918 unsigned int version, opcode_base, bytes_read;
3919 dwarf_vma length, diridx;
3920 const unsigned char * end;
3923 if (section->start == NULL
3924 || line_offset >= section->size
3928 hdrptr = section->start + line_offset;
3929 end = section->start + section->size;
3931 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3932 if (length == 0xffffffff)
3934 /* This section is 64-bit DWARF 3. */
3935 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3937 initial_length_size = 12;
3942 initial_length_size = 4;
3944 if (length + initial_length_size > section->size)
3947 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3948 if (version != 2 && version != 3 && version != 4)
3950 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3952 hdrptr++; /* Skip max_ops_per_insn. */
3953 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3955 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3956 if (opcode_base == 0)
3959 hdrptr += opcode_base - 1;
3961 /* Skip over dirname table. */
3962 while (*hdrptr != '\0')
3963 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3964 hdrptr++; /* Skip the NUL at the end of the table. */
3965 /* Now skip over preceding filename table entries. */
3966 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3968 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3969 read_uleb128 (hdrptr, &bytes_read, end);
3970 hdrptr += bytes_read;
3971 read_uleb128 (hdrptr, &bytes_read, end);
3972 hdrptr += bytes_read;
3973 read_uleb128 (hdrptr, &bytes_read, end);
3974 hdrptr += bytes_read;
3976 if (hdrptr == end || *hdrptr == '\0')
3979 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3980 diridx = read_uleb128 (hdrptr, &bytes_read, end);
3983 for (; *dirtable != '\0' && diridx > 1; diridx--)
3984 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
3985 if (*dirtable == '\0')
3987 *dir_name = dirtable;
3992 display_debug_macro (struct dwarf_section *section,
3995 unsigned char *start = section->start;
3996 unsigned char *end = start + section->size;
3997 unsigned char *curr = start;
3998 unsigned char *extended_op_buf[256];
3999 unsigned int bytes_read;
4001 load_debug_section (str, file);
4002 load_debug_section (line, file);
4004 printf (_("Contents of the %s section:\n\n"), section->name);
4008 unsigned int lineno, version, flags;
4009 unsigned int offset_size = 4;
4010 const unsigned char *string;
4011 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4012 unsigned char **extended_ops = NULL;
4014 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4017 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4022 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4025 printf (_(" Offset: 0x%lx\n"),
4026 (unsigned long) sec_offset);
4027 printf (_(" Version: %d\n"), version);
4028 printf (_(" Offset size: %d\n"), offset_size);
4031 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4032 printf (_(" Offset into .debug_line: 0x%lx\n"),
4033 (unsigned long) line_offset);
4037 unsigned int i, count, op;
4040 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4042 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4043 extended_ops = extended_op_buf;
4046 printf (_(" Extension opcode arguments:\n"));
4047 for (i = 0; i < count; i++)
4049 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4050 extended_ops[op] = curr;
4051 nargs = read_uleb128 (curr, &bytes_read, end);
4054 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
4057 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
4058 for (n = 0; n < nargs; n++)
4062 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4063 printf ("%s%s", get_FORM_name (form),
4064 n == nargs - 1 ? "\n" : ", ");
4074 case DW_FORM_block1:
4075 case DW_FORM_block2:
4076 case DW_FORM_block4:
4078 case DW_FORM_string:
4080 case DW_FORM_sec_offset:
4083 error (_("Invalid extension opcode form %s\n"),
4084 get_FORM_name (form));
4100 error (_(".debug_macro section not zero terminated\n"));
4104 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4110 case DW_MACRO_GNU_start_file:
4112 unsigned int filenum;
4113 unsigned char *file_name = NULL, *dir_name = NULL;
4115 lineno = read_uleb128 (curr, &bytes_read, end);
4117 filenum = read_uleb128 (curr, &bytes_read, end);
4120 if ((flags & 2) == 0)
4121 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4124 = get_line_filename_and_dirname (line_offset, filenum,
4126 if (file_name == NULL)
4127 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4130 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4132 dir_name != NULL ? (const char *) dir_name : "",
4133 dir_name != NULL ? "/" : "", file_name);
4137 case DW_MACRO_GNU_end_file:
4138 printf (_(" DW_MACRO_GNU_end_file\n"));
4141 case DW_MACRO_GNU_define:
4142 lineno = read_uleb128 (curr, &bytes_read, end);
4145 curr += strnlen ((char *) string, end - string) + 1;
4146 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4150 case DW_MACRO_GNU_undef:
4151 lineno = read_uleb128 (curr, &bytes_read, end);
4154 curr += strnlen ((char *) string, end - string) + 1;
4155 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4159 case DW_MACRO_GNU_define_indirect:
4160 lineno = read_uleb128 (curr, &bytes_read, end);
4162 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4163 string = fetch_indirect_string (offset);
4164 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4168 case DW_MACRO_GNU_undef_indirect:
4169 lineno = read_uleb128 (curr, &bytes_read, end);
4171 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4172 string = fetch_indirect_string (offset);
4173 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4177 case DW_MACRO_GNU_transparent_include:
4178 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4179 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4180 (unsigned long) offset);
4183 case DW_MACRO_GNU_define_indirect_alt:
4184 lineno = read_uleb128 (curr, &bytes_read, end);
4186 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4187 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4188 lineno, (unsigned long) offset);
4191 case DW_MACRO_GNU_undef_indirect_alt:
4192 lineno = read_uleb128 (curr, &bytes_read, end);
4194 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4195 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4196 lineno, (unsigned long) offset);
4199 case DW_MACRO_GNU_transparent_include_alt:
4200 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4201 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4202 (unsigned long) offset);
4206 if (extended_ops == NULL || extended_ops[op] == NULL)
4208 error (_(" Unknown macro opcode %02x seen\n"), op);
4213 /* Skip over unhandled opcodes. */
4215 unsigned char *desc = extended_ops[op];
4216 nargs = read_uleb128 (desc, &bytes_read, end);
4220 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4223 printf (_(" DW_MACRO_GNU_%02x -"), op);
4224 for (n = 0; n < nargs; n++)
4228 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4230 = read_and_display_attr_value (0, val,
4231 curr, end, 0, 0, offset_size,
4232 version, NULL, 0, NULL,
4250 display_debug_abbrev (struct dwarf_section *section,
4251 void *file ATTRIBUTE_UNUSED)
4253 abbrev_entry *entry;
4254 unsigned char *start = section->start;
4255 unsigned char *end = start + section->size;
4257 printf (_("Contents of the %s section:\n\n"), section->name);
4261 unsigned char *last;
4266 start = process_abbrev_section (start, end);
4268 if (first_abbrev == NULL)
4271 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
4273 for (entry = first_abbrev; entry; entry = entry->next)
4277 printf (" %ld %s [%s]\n",
4279 get_TAG_name (entry->tag),
4280 entry->children ? _("has children") : _("no children"));
4282 for (attr = entry->first_attr; attr; attr = attr->next)
4283 printf (" %-18s %s\n",
4284 get_AT_name (attr->attribute),
4285 get_FORM_name (attr->form));
4295 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4298 display_loc_list (struct dwarf_section *section,
4299 unsigned char **start_ptr,
4300 unsigned int debug_info_entry,
4301 unsigned long offset,
4302 unsigned long base_address,
4305 unsigned char *start = *start_ptr;
4306 unsigned char *section_end = section->start + section->size;
4307 unsigned long cu_offset;
4308 unsigned int pointer_size;
4309 unsigned int offset_size;
4314 unsigned short length;
4315 int need_frame_base;
4317 if (debug_info_entry >= num_debug_info_entries)
4319 warn (_("No debug information available for loc lists of entry: %u\n"),
4324 cu_offset = debug_information [debug_info_entry].cu_offset;
4325 pointer_size = debug_information [debug_info_entry].pointer_size;
4326 offset_size = debug_information [debug_info_entry].offset_size;
4327 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4329 if (pointer_size < 2 || pointer_size > 8)
4331 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4332 pointer_size, debug_info_entry);
4338 if (start + 2 * pointer_size > section_end)
4340 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4345 printf (" %8.8lx ", offset + (start - *start_ptr));
4347 /* Note: we use sign extension here in order to be sure that we can detect
4348 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4349 address will not affect the values that we display since we always show
4350 hex values, and always the bottom 32-bits. */
4351 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4352 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4354 if (begin == 0 && end == 0)
4356 printf (_("<End of list>\n"));
4360 /* Check base address specifiers. */
4361 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4364 print_dwarf_vma (begin, pointer_size);
4365 print_dwarf_vma (end, pointer_size);
4366 printf (_("(base address)\n"));
4370 if (start + 2 > section_end)
4372 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4377 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4379 if (start + length > section_end)
4381 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4386 print_dwarf_vma (begin + base_address, pointer_size);
4387 print_dwarf_vma (end + base_address, pointer_size);
4390 need_frame_base = decode_location_expression (start,
4395 cu_offset, section);
4398 if (need_frame_base && !has_frame_base)
4399 printf (_(" [without DW_AT_frame_base]"));
4402 fputs (_(" (start == end)"), stdout);
4403 else if (begin > end)
4404 fputs (_(" (start > end)"), stdout);
4414 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4415 right-adjusted in a field of length LEN, and followed by a space. */
4418 print_addr_index (unsigned int idx, unsigned int len)
4420 static char buf[15];
4421 snprintf (buf, sizeof (buf), "[%d]", idx);
4422 printf ("%*s ", len, buf);
4425 /* Display a location list from a .dwo section. It uses address indexes rather
4426 than embedded addresses. This code closely follows display_loc_list, but the
4427 two are sufficiently different that combining things is very ugly. */
4430 display_loc_list_dwo (struct dwarf_section *section,
4431 unsigned char **start_ptr,
4432 unsigned int debug_info_entry,
4433 unsigned long offset,
4436 unsigned char *start = *start_ptr;
4437 unsigned char *section_end = section->start + section->size;
4438 unsigned long cu_offset;
4439 unsigned int pointer_size;
4440 unsigned int offset_size;
4443 unsigned short length;
4444 int need_frame_base;
4446 unsigned int bytes_read;
4448 if (debug_info_entry >= num_debug_info_entries)
4450 warn (_("No debug information for loc lists of entry: %u\n"),
4455 cu_offset = debug_information [debug_info_entry].cu_offset;
4456 pointer_size = debug_information [debug_info_entry].pointer_size;
4457 offset_size = debug_information [debug_info_entry].offset_size;
4458 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4460 if (pointer_size < 2 || pointer_size > 8)
4462 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4463 pointer_size, debug_info_entry);
4469 printf (" %8.8lx ", offset + (start - *start_ptr));
4471 if (start >= section_end)
4473 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4478 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4481 case 0: /* A terminating entry. */
4483 printf (_("<End of list>\n"));
4485 case 1: /* A base-address entry. */
4486 idx = read_uleb128 (start, &bytes_read, section_end);
4487 start += bytes_read;
4488 print_addr_index (idx, 8);
4490 printf (_("(base address selection entry)\n"));
4492 case 2: /* A start/end entry. */
4493 idx = read_uleb128 (start, &bytes_read, section_end);
4494 start += bytes_read;
4495 print_addr_index (idx, 8);
4496 idx = read_uleb128 (start, &bytes_read, section_end);
4497 start += bytes_read;
4498 print_addr_index (idx, 8);
4500 case 3: /* A start/length entry. */
4501 idx = read_uleb128 (start, &bytes_read, section_end);
4502 start += bytes_read;
4503 print_addr_index (idx, 8);
4504 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4505 printf ("%08x ", idx);
4507 case 4: /* An offset pair entry. */
4508 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4509 printf ("%08x ", idx);
4510 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4511 printf ("%08x ", idx);
4514 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4519 if (start + 2 > section_end)
4521 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4526 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4527 if (start + length > section_end)
4529 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4535 need_frame_base = decode_location_expression (start,
4540 cu_offset, section);
4543 if (need_frame_base && !has_frame_base)
4544 printf (_(" [without DW_AT_frame_base]"));
4554 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4556 static dwarf_vma *loc_offsets;
4559 loc_offsets_compar (const void *ap, const void *bp)
4561 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4562 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4564 return (a > b) - (b > a);
4568 display_debug_loc (struct dwarf_section *section, void *file)
4570 unsigned char *start = section->start;
4571 unsigned long bytes;
4572 unsigned char *section_begin = start;
4573 unsigned int num_loc_list = 0;
4574 unsigned long last_offset = 0;
4575 unsigned int first = 0;
4579 int seen_first_offset = 0;
4580 int locs_sorted = 1;
4581 unsigned char *next;
4582 unsigned int *array = NULL;
4583 const char *suffix = strrchr (section->name, '.');
4586 if (suffix && strcmp (suffix, ".dwo") == 0)
4589 bytes = section->size;
4593 printf (_("\nThe %s section is empty.\n"), section->name);
4597 if (load_debug_info (file) == 0)
4599 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4604 /* Check the order of location list in .debug_info section. If
4605 offsets of location lists are in the ascending order, we can
4606 use `debug_information' directly. */
4607 for (i = 0; i < num_debug_info_entries; i++)
4611 num = debug_information [i].num_loc_offsets;
4612 if (num > num_loc_list)
4615 /* Check if we can use `debug_information' directly. */
4616 if (locs_sorted && num != 0)
4618 if (!seen_first_offset)
4620 /* This is the first location list. */
4621 last_offset = debug_information [i].loc_offsets [0];
4623 seen_first_offset = 1;
4629 for (; j < num; j++)
4632 debug_information [i].loc_offsets [j])
4637 last_offset = debug_information [i].loc_offsets [j];
4642 if (!seen_first_offset)
4643 error (_("No location lists in .debug_info section!\n"));
4645 if (debug_information [first].num_loc_offsets > 0
4646 && debug_information [first].loc_offsets [0] != 0)
4647 warn (_("Location lists in %s section start at 0x%s\n"),
4649 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4652 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4653 printf (_("Contents of the %s section:\n\n"), section->name);
4654 printf (_(" Offset Begin End Expression\n"));
4656 seen_first_offset = 0;
4657 for (i = first; i < num_debug_info_entries; i++)
4659 unsigned long offset;
4660 unsigned long base_address;
4665 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4667 loc_offsets = debug_information [i].loc_offsets;
4668 qsort (array, debug_information [i].num_loc_offsets,
4669 sizeof (*array), loc_offsets_compar);
4672 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4674 j = locs_sorted ? k : array[k];
4676 && debug_information [i].loc_offsets [locs_sorted
4677 ? k - 1 : array [k - 1]]
4678 == debug_information [i].loc_offsets [j])
4680 has_frame_base = debug_information [i].have_frame_base [j];
4681 offset = debug_information [i].loc_offsets [j];
4682 next = section_begin + offset;
4683 base_address = debug_information [i].base_address;
4685 if (!seen_first_offset)
4686 seen_first_offset = 1;
4690 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4691 (unsigned long) (start - section_begin),
4692 (unsigned long) (next - section_begin));
4693 else if (start > next)
4694 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4695 (unsigned long) (start - section_begin),
4696 (unsigned long) (next - section_begin));
4700 if (offset >= bytes)
4702 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4708 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4710 display_loc_list (section, &start, i, offset, base_address,
4715 if (start < section->start + section->size)
4716 warn (_("There are %ld unused bytes at the end of section %s\n"),
4717 (long) (section->start + section->size - start), section->name);
4724 display_debug_str (struct dwarf_section *section,
4725 void *file ATTRIBUTE_UNUSED)
4727 unsigned char *start = section->start;
4728 unsigned long bytes = section->size;
4729 dwarf_vma addr = section->address;
4733 printf (_("\nThe %s section is empty.\n"), section->name);
4737 printf (_("Contents of the %s section:\n\n"), section->name);
4745 lbytes = (bytes > 16 ? 16 : bytes);
4747 printf (" 0x%8.8lx ", (unsigned long) addr);
4749 for (j = 0; j < 16; j++)
4752 printf ("%2.2x", start[j]);
4760 for (j = 0; j < lbytes; j++)
4763 if (k >= ' ' && k < 0x80)
4782 display_debug_info (struct dwarf_section *section, void *file)
4784 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4788 display_debug_types (struct dwarf_section *section, void *file)
4790 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4794 display_trace_info (struct dwarf_section *section, void *file)
4796 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4800 display_debug_aranges (struct dwarf_section *section,
4801 void *file ATTRIBUTE_UNUSED)
4803 unsigned char *start = section->start;
4804 unsigned char *end = start + section->size;
4806 printf (_("Contents of the %s section:\n\n"), section->name);
4808 /* It does not matter if this load fails,
4809 we test for that later on. */
4810 load_debug_info (file);
4814 unsigned char *hdrptr;
4815 DWARF2_Internal_ARange arange;
4816 unsigned char *addr_ranges;
4819 unsigned char address_size;
4821 unsigned int offset_size;
4822 unsigned int initial_length_size;
4826 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4827 if (arange.ar_length == 0xffffffff)
4829 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4831 initial_length_size = 12;
4836 initial_length_size = 4;
4839 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4840 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4842 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4843 && num_debug_info_entries > 0
4844 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4845 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4846 (unsigned long) arange.ar_info_offset, section->name);
4848 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4849 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4851 if (arange.ar_version != 2 && arange.ar_version != 3)
4853 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4857 printf (_(" Length: %ld\n"),
4858 (long) arange.ar_length);
4859 printf (_(" Version: %d\n"), arange.ar_version);
4860 printf (_(" Offset into .debug_info: 0x%lx\n"),
4861 (unsigned long) arange.ar_info_offset);
4862 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4863 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4865 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4867 /* PR 17512: file: 001-108546-0.001:0.1. */
4868 if (address_size == 0 || address_size > 8)
4870 error (_("Invalid address size in %s section!\n"),
4875 /* The DWARF spec does not require that the address size be a power
4876 of two, but we do. This will have to change if we ever encounter
4877 an uneven architecture. */
4878 if ((address_size & (address_size - 1)) != 0)
4880 warn (_("Pointer size + Segment size is not a power of two.\n"));
4884 if (address_size > 4)
4885 printf (_("\n Address Length\n"));
4887 printf (_("\n Address Length\n"));
4889 addr_ranges = hdrptr;
4891 /* Must pad to an alignment boundary that is twice the address size. */
4892 excess = (hdrptr - start) % (2 * address_size);
4894 addr_ranges += (2 * address_size) - excess;
4896 start += arange.ar_length + initial_length_size;
4898 while (addr_ranges + 2 * address_size <= start)
4900 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4901 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4904 print_dwarf_vma (address, address_size);
4905 print_dwarf_vma (length, address_size);
4915 /* Comparison function for qsort. */
4917 comp_addr_base (const void * v0, const void * v1)
4919 debug_info * info0 = (debug_info *) v0;
4920 debug_info * info1 = (debug_info *) v1;
4921 return info0->addr_base - info1->addr_base;
4924 /* Display the debug_addr section. */
4926 display_debug_addr (struct dwarf_section *section,
4929 debug_info **debug_addr_info;
4930 unsigned char *entry;
4935 if (section->size == 0)
4937 printf (_("\nThe %s section is empty.\n"), section->name);
4941 if (load_debug_info (file) == 0)
4943 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4948 printf (_("Contents of the %s section:\n\n"), section->name);
4950 /* PR 17531: file: cf38d01b.
4951 We use xcalloc because a corrupt file may not have initialised all of the
4952 fields in the debug_info structure, which means that the sort below might
4953 try to move uninitialised data. */
4954 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
4955 sizeof (debug_info *));
4958 for (i = 0; i < num_debug_info_entries; i++)
4959 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4961 /* PR 17531: file: cf38d01b. */
4962 if (debug_information[i].addr_base >= section->size)
4963 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
4964 (unsigned long) debug_information[i].addr_base, i);
4966 debug_addr_info [count++] = debug_information + i;
4969 /* Add a sentinel to make iteration convenient. */
4970 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
4971 debug_addr_info [count]->addr_base = section->size;
4972 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
4974 for (i = 0; i < count; i++)
4977 unsigned int address_size = debug_addr_info [i]->pointer_size;
4979 printf (_(" For compilation unit at offset 0x%s:\n"),
4980 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
4982 printf (_("\tIndex\tAddress\n"));
4983 entry = section->start + debug_addr_info [i]->addr_base;
4984 end = section->start + debug_addr_info [i + 1]->addr_base;
4988 dwarf_vma base = byte_get (entry, address_size);
4989 printf (_("\t%d:\t"), idx);
4990 print_dwarf_vma (base, address_size);
4992 entry += address_size;
4998 free (debug_addr_info);
5002 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5004 display_debug_str_offsets (struct dwarf_section *section,
5005 void *file ATTRIBUTE_UNUSED)
5007 if (section->size == 0)
5009 printf (_("\nThe %s section is empty.\n"), section->name);
5012 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5013 what the offset size is for this section. */
5017 /* Each debug_information[x].range_lists[y] gets this representation for
5018 sorting purposes. */
5022 /* The debug_information[x].range_lists[y] value. */
5023 unsigned long ranges_offset;
5025 /* Original debug_information to find parameters of the data. */
5026 debug_info *debug_info_p;
5029 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5032 range_entry_compar (const void *ap, const void *bp)
5034 const struct range_entry *a_re = (const struct range_entry *) ap;
5035 const struct range_entry *b_re = (const struct range_entry *) bp;
5036 const unsigned long a = a_re->ranges_offset;
5037 const unsigned long b = b_re->ranges_offset;
5039 return (a > b) - (b > a);
5043 display_debug_ranges (struct dwarf_section *section,
5044 void *file ATTRIBUTE_UNUSED)
5046 unsigned char *start = section->start;
5047 unsigned char *last_start = start;
5048 unsigned long bytes = section->size;
5049 unsigned char *section_begin = start;
5050 unsigned char *finish = start + bytes;
5051 unsigned int num_range_list, i;
5052 struct range_entry *range_entries, *range_entry_fill;
5056 printf (_("\nThe %s section is empty.\n"), section->name);
5060 if (load_debug_info (file) == 0)
5062 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5068 for (i = 0; i < num_debug_info_entries; i++)
5069 num_range_list += debug_information [i].num_range_lists;
5071 if (num_range_list == 0)
5073 /* This can happen when the file was compiled with -gsplit-debug
5074 which removes references to range lists from the primary .o file. */
5075 printf (_("No range lists in .debug_info section.\n"));
5079 range_entries = (struct range_entry *)
5080 xmalloc (sizeof (*range_entries) * num_range_list);
5081 range_entry_fill = range_entries;
5083 for (i = 0; i < num_debug_info_entries; i++)
5085 debug_info *debug_info_p = &debug_information[i];
5088 for (j = 0; j < debug_info_p->num_range_lists; j++)
5090 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5091 range_entry_fill->debug_info_p = debug_info_p;
5096 qsort (range_entries, num_range_list, sizeof (*range_entries),
5097 range_entry_compar);
5099 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5100 warn (_("Range lists in %s section start at 0x%lx\n"),
5101 section->name, range_entries[0].ranges_offset);
5103 printf (_("Contents of the %s section:\n\n"), section->name);
5104 printf (_(" Offset Begin End\n"));
5106 for (i = 0; i < num_range_list; i++)
5108 struct range_entry *range_entry = &range_entries[i];
5109 debug_info *debug_info_p = range_entry->debug_info_p;
5110 unsigned int pointer_size;
5111 unsigned long offset;
5112 unsigned char *next;
5113 unsigned long base_address;
5115 pointer_size = debug_info_p->pointer_size;
5116 offset = range_entry->ranges_offset;
5117 next = section_begin + offset;
5118 base_address = debug_info_p->base_address;
5120 /* PR 17512: file: 001-101485-0.001:0.1. */
5121 if (pointer_size < 2 || pointer_size > 8)
5123 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5124 pointer_size, offset);
5128 if (dwarf_check != 0 && i > 0)
5131 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5132 (unsigned long) (start - section_begin),
5133 (unsigned long) (next - section_begin), section->name);
5134 else if (start > next)
5136 if (next == last_start)
5138 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5139 (unsigned long) (start - section_begin),
5140 (unsigned long) (next - section_begin), section->name);
5146 while (start < finish)
5151 /* Note: we use sign extension here in order to be sure that
5152 we can detect the -1 escape value. Sign extension into the
5153 top 32 bits of a 32-bit address will not affect the values
5154 that we display since we always show hex values, and always
5155 the bottom 32-bits. */
5156 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5157 if (start >= finish)
5159 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5161 printf (" %8.8lx ", offset);
5163 if (begin == 0 && end == 0)
5165 printf (_("<End of list>\n"));
5169 /* Check base address specifiers. */
5170 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5173 print_dwarf_vma (begin, pointer_size);
5174 print_dwarf_vma (end, pointer_size);
5175 printf ("(base address)\n");
5179 print_dwarf_vma (begin + base_address, pointer_size);
5180 print_dwarf_vma (end + base_address, pointer_size);
5183 fputs (_("(start == end)"), stdout);
5184 else if (begin > end)
5185 fputs (_("(start > end)"), stdout);
5192 free (range_entries);
5197 typedef struct Frame_Chunk
5199 struct Frame_Chunk *next;
5200 unsigned char *chunk_start;
5202 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5203 short int *col_type;
5206 unsigned int code_factor;
5213 unsigned char fde_encoding;
5214 unsigned char cfa_exp;
5215 unsigned char ptr_size;
5216 unsigned char segment_size;
5220 static const char *const *dwarf_regnames;
5221 static unsigned int dwarf_regnames_count;
5223 /* A marker for a col_type that means this column was never referenced
5224 in the frame info. */
5225 #define DW_CFA_unreferenced (-1)
5227 /* Return 0 if no more space is needed, 1 if more space is needed,
5228 -1 for invalid reg. */
5231 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5233 unsigned int prev = fc->ncols;
5235 if (reg < (unsigned int) fc->ncols)
5238 if (dwarf_regnames_count
5239 && reg > dwarf_regnames_count)
5242 fc->ncols = reg + 1;
5243 /* PR 17512: file: 10450-2643-0.004.
5244 If reg == -1 then this can happen... */
5248 /* PR 17512: file: 2844a11d. */
5249 if (fc->ncols > 1024)
5251 error (_("Unfeasibly large register number: %u\n"), reg);
5253 /* FIXME: 1024 is an arbitrary limit. Increase it if
5254 we ever encounter a valid binary that exceeds it. */
5258 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5259 sizeof (short int));
5260 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5261 /* PR 17512: file:002-10025-0.005. */
5262 if (fc->col_type == NULL || fc->col_offset == NULL)
5264 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5270 while (prev < fc->ncols)
5272 fc->col_type[prev] = DW_CFA_unreferenced;
5273 fc->col_offset[prev] = 0;
5279 static const char *const dwarf_regnames_i386[] =
5281 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5282 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5283 "eip", "eflags", NULL, /* 8 - 10 */
5284 "st0", "st1", "st2", "st3", /* 11 - 14 */
5285 "st4", "st5", "st6", "st7", /* 15 - 18 */
5286 NULL, NULL, /* 19 - 20 */
5287 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5288 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5289 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5290 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5291 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5292 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5293 "tr", "ldtr", /* 48 - 49 */
5294 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5295 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5296 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5297 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5298 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5299 NULL, NULL, NULL, /* 90 - 92 */
5300 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5304 init_dwarf_regnames_i386 (void)
5306 dwarf_regnames = dwarf_regnames_i386;
5307 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5310 static const char *const dwarf_regnames_x86_64[] =
5312 "rax", "rdx", "rcx", "rbx",
5313 "rsi", "rdi", "rbp", "rsp",
5314 "r8", "r9", "r10", "r11",
5315 "r12", "r13", "r14", "r15",
5317 "xmm0", "xmm1", "xmm2", "xmm3",
5318 "xmm4", "xmm5", "xmm6", "xmm7",
5319 "xmm8", "xmm9", "xmm10", "xmm11",
5320 "xmm12", "xmm13", "xmm14", "xmm15",
5321 "st0", "st1", "st2", "st3",
5322 "st4", "st5", "st6", "st7",
5323 "mm0", "mm1", "mm2", "mm3",
5324 "mm4", "mm5", "mm6", "mm7",
5326 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5327 "fs.base", "gs.base", NULL, NULL,
5329 "mxcsr", "fcw", "fsw",
5330 "xmm16", "xmm17", "xmm18", "xmm19",
5331 "xmm20", "xmm21", "xmm22", "xmm23",
5332 "xmm24", "xmm25", "xmm26", "xmm27",
5333 "xmm28", "xmm29", "xmm30", "xmm31",
5334 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5335 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5336 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5337 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5338 NULL, NULL, NULL, /* 115 - 117 */
5339 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5343 init_dwarf_regnames_x86_64 (void)
5345 dwarf_regnames = dwarf_regnames_x86_64;
5346 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5349 static const char *const dwarf_regnames_aarch64[] =
5351 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5352 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5353 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5354 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5355 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5356 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5357 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5358 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5359 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5360 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5361 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5362 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5366 init_dwarf_regnames_aarch64 (void)
5368 dwarf_regnames = dwarf_regnames_aarch64;
5369 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5373 init_dwarf_regnames (unsigned int e_machine)
5379 init_dwarf_regnames_i386 ();
5385 init_dwarf_regnames_x86_64 ();
5389 init_dwarf_regnames_aarch64 ();
5398 regname (unsigned int regno, int row)
5400 static char reg[64];
5402 && regno < dwarf_regnames_count
5403 && dwarf_regnames [regno] != NULL)
5406 return dwarf_regnames [regno];
5407 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5408 dwarf_regnames [regno]);
5411 snprintf (reg, sizeof (reg), "r%d", regno);
5416 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5421 if (*max_regs < fc->ncols)
5422 *max_regs = fc->ncols;
5424 if (*need_col_headers)
5426 static const char *sloc = " LOC";
5428 *need_col_headers = 0;
5430 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5432 for (r = 0; r < *max_regs; r++)
5433 if (fc->col_type[r] != DW_CFA_unreferenced)
5438 printf ("%-5s ", regname (r, 1));
5444 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5446 strcpy (tmp, "exp");
5448 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5449 printf ("%-8s ", tmp);
5451 for (r = 0; r < fc->ncols; r++)
5453 if (fc->col_type[r] != DW_CFA_unreferenced)
5455 switch (fc->col_type[r])
5457 case DW_CFA_undefined:
5460 case DW_CFA_same_value:
5464 sprintf (tmp, "c%+d", fc->col_offset[r]);
5466 case DW_CFA_val_offset:
5467 sprintf (tmp, "v%+d", fc->col_offset[r]);
5469 case DW_CFA_register:
5470 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5472 case DW_CFA_expression:
5473 strcpy (tmp, "exp");
5475 case DW_CFA_val_expression:
5476 strcpy (tmp, "vexp");
5479 strcpy (tmp, "n/a");
5482 printf ("%-5s ", tmp);
5488 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5489 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5490 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5492 static unsigned char *
5493 read_cie (unsigned char *start, unsigned char *end,
5494 Frame_Chunk **p_cie, int *p_version,
5495 unsigned long *p_aug_len, unsigned char **p_aug)
5499 unsigned int length_return;
5500 unsigned char *augmentation_data = NULL;
5501 unsigned long augmentation_data_len = 0;
5504 /* PR 17512: file: 001-228113-0.004. */
5508 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5509 memset (fc, 0, sizeof (Frame_Chunk));
5511 fc->col_type = (short int *) xmalloc (sizeof (short int));
5512 fc->col_offset = (int *) xmalloc (sizeof (int));
5516 fc->augmentation = (char *) start;
5517 /* PR 17512: file: 001-228113-0.004.
5518 Skip past augmentation name, but avoid running off the end of the data. */
5520 if (* start ++ == '\0')
5524 warn (_("No terminator for augmentation name\n"));
5528 if (strcmp (fc->augmentation, "eh") == 0)
5529 start += eh_addr_size;
5533 GET (fc->ptr_size, 1);
5534 GET (fc->segment_size, 1);
5535 eh_addr_size = fc->ptr_size;
5539 fc->ptr_size = eh_addr_size;
5540 fc->segment_size = 0;
5542 fc->code_factor = LEB ();
5543 fc->data_factor = SLEB ();
5553 if (fc->augmentation[0] == 'z')
5555 augmentation_data_len = LEB ();
5556 augmentation_data = start;
5557 start += augmentation_data_len;
5558 /* PR 17512: file: 11042-2589-0.004. */
5561 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5566 if (augmentation_data_len)
5570 unsigned char *qend;
5572 p = (unsigned char *) fc->augmentation + 1;
5573 q = augmentation_data;
5574 qend = q + augmentation_data_len;
5576 /* PR 17531: file: 015adfaa. */
5579 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5580 augmentation_data_len = 0;
5583 while (p < end && q < augmentation_data + augmentation_data_len)
5588 q += 1 + size_of_encoded_value (*q);
5590 fc->fde_encoding = *q++;
5597 /* Note - it is OK if this loop terminates with q < qend.
5598 Padding may have been inserted to align the end of the CIE. */
5603 *p_version = version;
5606 *p_aug_len = augmentation_data_len;
5607 *p_aug = augmentation_data;
5613 display_debug_frames (struct dwarf_section *section,
5614 void *file ATTRIBUTE_UNUSED)
5616 unsigned char *start = section->start;
5617 unsigned char *end = start + section->size;
5618 unsigned char *section_start = start;
5619 Frame_Chunk *chunks = 0, *forward_refs = 0;
5620 Frame_Chunk *remembered_state = 0;
5622 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5623 unsigned int length_return;
5624 unsigned int max_regs = 0;
5625 const char *bad_reg = _("bad register: ");
5626 int saved_eh_addr_size = eh_addr_size;
5628 printf (_("Contents of the %s section:\n"), section->name);
5632 unsigned char *saved_start;
5633 unsigned char *block_end;
5638 int need_col_headers = 1;
5639 unsigned char *augmentation_data = NULL;
5640 unsigned long augmentation_data_len = 0;
5641 unsigned int encoded_ptr_size = saved_eh_addr_size;
5642 unsigned int offset_size;
5643 unsigned int initial_length_size;
5645 saved_start = start;
5647 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5651 printf ("\n%08lx ZERO terminator\n\n",
5652 (unsigned long)(saved_start - section_start));
5653 /* Skip any zero terminators that directly follow.
5654 A corrupt section size could have loaded a whole
5655 slew of zero filled memory bytes. eg
5656 PR 17512: file: 070-19381-0.004. */
5657 while (start < end && * start == 0)
5662 if (length == 0xffffffff)
5664 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5666 initial_length_size = 12;
5671 initial_length_size = 4;
5674 block_end = saved_start + length + initial_length_size;
5675 if (block_end > end || block_end < start)
5677 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5678 dwarf_vmatoa_1 (NULL, length, offset_size),
5679 (unsigned long) (saved_start - section_start));
5683 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5685 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5686 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5691 start = read_cie (start, end, &cie, &version,
5692 &augmentation_data_len, &augmentation_data);
5693 /* PR 17512: file: 027-135133-0.005. */
5700 fc->chunk_start = saved_start;
5701 mreg = max_regs > 0 ? max_regs - 1 : 0;
5704 if (frame_need_space (fc, mreg) < 0)
5706 if (fc->fde_encoding)
5707 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5709 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5710 print_dwarf_vma (length, fc->ptr_size);
5711 print_dwarf_vma (cie_id, offset_size);
5713 if (do_debug_frames_interp)
5715 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5716 fc->code_factor, fc->data_factor, fc->ra);
5721 printf (" Version: %d\n", version);
5722 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5725 printf (" Pointer Size: %u\n", fc->ptr_size);
5726 printf (" Segment Size: %u\n", fc->segment_size);
5728 printf (" Code alignment factor: %u\n", fc->code_factor);
5729 printf (" Data alignment factor: %d\n", fc->data_factor);
5730 printf (" Return address column: %d\n", fc->ra);
5732 if (augmentation_data_len)
5736 printf (" Augmentation data: ");
5737 for (i = 0; i < augmentation_data_len; ++i)
5738 /* FIXME: If do_wide is FALSE, then we should
5739 add carriage returns at 80 columns... */
5740 printf (" %02x", augmentation_data[i]);
5748 unsigned char *look_for;
5749 static Frame_Chunk fde_fc;
5750 unsigned long segment_selector;
5754 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5755 look_for = start - 4 - ((cie_id ^ sign) - sign);
5758 look_for = section_start + cie_id;
5760 if (look_for <= saved_start)
5762 for (cie = chunks; cie ; cie = cie->next)
5763 if (cie->chunk_start == look_for)
5768 for (cie = forward_refs; cie ; cie = cie->next)
5769 if (cie->chunk_start == look_for)
5773 unsigned int off_size;
5774 unsigned char *cie_scan;
5776 cie_scan = look_for;
5778 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5779 if (length == 0xffffffff)
5781 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5788 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5791 : ((off_size == 4 && c_id == DW_CIE_ID)
5792 || (off_size == 8 && c_id == DW64_CIE_ID)))
5797 read_cie (cie_scan, end, &cie, &version,
5798 &augmentation_data_len, &augmentation_data);
5799 /* PR 17512: file: 3450-2098-0.004. */
5802 warn (_("Failed to read CIE information\n"));
5805 cie->next = forward_refs;
5807 cie->chunk_start = look_for;
5808 mreg = max_regs > 0 ? max_regs - 1 : 0;
5811 if (frame_need_space (cie, mreg) < 0)
5813 warn (_("Invalid max register\n"));
5816 if (cie->fde_encoding)
5818 = size_of_encoded_value (cie->fde_encoding);
5825 memset (fc, 0, sizeof (Frame_Chunk));
5829 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5830 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5831 (unsigned long) (saved_start - section_start));
5833 fc->col_type = (short int *) xmalloc (sizeof (short int));
5834 fc->col_offset = (int *) xmalloc (sizeof (int));
5835 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5837 warn (_("Invalid max register\n"));
5841 fc->augmentation = "";
5842 fc->fde_encoding = 0;
5843 fc->ptr_size = eh_addr_size;
5844 fc->segment_size = 0;
5848 fc->ncols = cie->ncols;
5849 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5850 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
5851 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5852 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5853 fc->augmentation = cie->augmentation;
5854 fc->ptr_size = cie->ptr_size;
5855 eh_addr_size = cie->ptr_size;
5856 fc->segment_size = cie->segment_size;
5857 fc->code_factor = cie->code_factor;
5858 fc->data_factor = cie->data_factor;
5859 fc->cfa_reg = cie->cfa_reg;
5860 fc->cfa_offset = cie->cfa_offset;
5862 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5864 warn (_("Invalid max register\n"));
5867 fc->fde_encoding = cie->fde_encoding;
5870 if (fc->fde_encoding)
5871 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5873 segment_selector = 0;
5874 if (fc->segment_size)
5875 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5877 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
5879 /* FIXME: It appears that sometimes the final pc_range value is
5880 encoded in less than encoded_ptr_size bytes. See the x86_64
5881 run of the "objcopy on compressed debug sections" test for an
5883 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5885 if (cie->augmentation[0] == 'z')
5887 augmentation_data_len = LEB ();
5888 augmentation_data = start;
5889 start += augmentation_data_len;
5890 /* PR 17512: file: 722-8446-0.004. */
5891 if (start >= end || ((signed long) augmentation_data_len) < 0)
5893 warn (_("Corrupt augmentation data length: %lx\n"),
5894 augmentation_data_len);
5896 augmentation_data = NULL;
5897 augmentation_data_len = 0;
5901 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5902 (unsigned long)(saved_start - section_start),
5903 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5904 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5905 (unsigned long)(cie->chunk_start - section_start));
5907 if (fc->segment_size)
5908 printf ("%04lx:", segment_selector);
5911 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5912 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5914 if (! do_debug_frames_interp && augmentation_data_len)
5918 printf (" Augmentation data: ");
5919 for (i = 0; i < augmentation_data_len; ++i)
5920 printf (" %02x", augmentation_data[i]);
5926 /* At this point, fc is the current chunk, cie (if any) is set, and
5927 we're about to interpret instructions for the chunk. */
5928 /* ??? At present we need to do this always, since this sizes the
5929 fc->col_type and fc->col_offset arrays, which we write into always.
5930 We should probably split the interpreted and non-interpreted bits
5931 into two different routines, since there's so much that doesn't
5932 really overlap between them. */
5933 if (1 || do_debug_frames_interp)
5935 /* Start by making a pass over the chunk, allocating storage
5936 and taking note of what registers are used. */
5937 unsigned char *tmp = start;
5939 while (start < block_end)
5941 unsigned int reg, op, opa;
5949 /* Warning: if you add any more cases to this switch, be
5950 sure to add them to the corresponding switch below. */
5953 case DW_CFA_advance_loc:
5957 if (frame_need_space (fc, opa) >= 0)
5958 fc->col_type[opa] = DW_CFA_undefined;
5960 case DW_CFA_restore:
5961 if (frame_need_space (fc, opa) >= 0)
5962 fc->col_type[opa] = DW_CFA_undefined;
5964 case DW_CFA_set_loc:
5965 start += encoded_ptr_size;
5967 case DW_CFA_advance_loc1:
5970 case DW_CFA_advance_loc2:
5973 case DW_CFA_advance_loc4:
5976 case DW_CFA_offset_extended:
5977 case DW_CFA_val_offset:
5978 reg = LEB (); LEB ();
5979 if (frame_need_space (fc, reg) >= 0)
5980 fc->col_type[reg] = DW_CFA_undefined;
5982 case DW_CFA_restore_extended:
5984 if (frame_need_space (fc, reg) >= 0)
5985 fc->col_type[reg] = DW_CFA_undefined;
5987 case DW_CFA_undefined:
5989 if (frame_need_space (fc, reg) >= 0)
5990 fc->col_type[reg] = DW_CFA_undefined;
5992 case DW_CFA_same_value:
5994 if (frame_need_space (fc, reg) >= 0)
5995 fc->col_type[reg] = DW_CFA_undefined;
5997 case DW_CFA_register:
5998 reg = LEB (); LEB ();
5999 if (frame_need_space (fc, reg) >= 0)
6000 fc->col_type[reg] = DW_CFA_undefined;
6002 case DW_CFA_def_cfa:
6005 case DW_CFA_def_cfa_register:
6008 case DW_CFA_def_cfa_offset:
6011 case DW_CFA_def_cfa_expression:
6013 if (start + temp < start)
6015 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6021 case DW_CFA_expression:
6022 case DW_CFA_val_expression:
6025 if (start + temp < start)
6027 /* PR 17512: file:306-192417-0.005. */
6028 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6033 if (frame_need_space (fc, reg) >= 0)
6034 fc->col_type[reg] = DW_CFA_undefined;
6036 case DW_CFA_offset_extended_sf:
6037 case DW_CFA_val_offset_sf:
6038 reg = LEB (); SLEB ();
6039 if (frame_need_space (fc, reg) >= 0)
6040 fc->col_type[reg] = DW_CFA_undefined;
6042 case DW_CFA_def_cfa_sf:
6045 case DW_CFA_def_cfa_offset_sf:
6048 case DW_CFA_MIPS_advance_loc8:
6051 case DW_CFA_GNU_args_size:
6054 case DW_CFA_GNU_negative_offset_extended:
6055 reg = LEB (); LEB ();
6056 if (frame_need_space (fc, reg) >= 0)
6057 fc->col_type[reg] = DW_CFA_undefined;
6066 /* Now we know what registers are used, make a second pass over
6067 the chunk, this time actually printing out the info. */
6069 while (start < block_end)
6072 unsigned long ul, reg, roffs;
6076 const char *reg_prefix = "";
6083 /* Warning: if you add any more cases to this switch, be
6084 sure to add them to the corresponding switch above. */
6087 case DW_CFA_advance_loc:
6088 if (do_debug_frames_interp)
6089 frame_display_row (fc, &need_col_headers, &max_regs);
6091 printf (" DW_CFA_advance_loc: %d to %s\n",
6092 opa * fc->code_factor,
6093 dwarf_vmatoa_1 (NULL,
6094 fc->pc_begin + opa * fc->code_factor,
6096 fc->pc_begin += opa * fc->code_factor;
6101 if (opa >= (unsigned int) fc->ncols)
6102 reg_prefix = bad_reg;
6103 if (! do_debug_frames_interp || *reg_prefix != '\0')
6104 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6105 reg_prefix, regname (opa, 0),
6106 roffs * fc->data_factor);
6107 if (*reg_prefix == '\0')
6109 fc->col_type[opa] = DW_CFA_offset;
6110 fc->col_offset[opa] = roffs * fc->data_factor;
6114 case DW_CFA_restore:
6115 if (opa >= (unsigned int) cie->ncols
6116 || opa >= (unsigned int) fc->ncols)
6117 reg_prefix = bad_reg;
6118 if (! do_debug_frames_interp || *reg_prefix != '\0')
6119 printf (" DW_CFA_restore: %s%s\n",
6120 reg_prefix, regname (opa, 0));
6121 if (*reg_prefix == '\0')
6123 fc->col_type[opa] = cie->col_type[opa];
6124 fc->col_offset[opa] = cie->col_offset[opa];
6125 if (do_debug_frames_interp
6126 && fc->col_type[opa] == DW_CFA_unreferenced)
6127 fc->col_type[opa] = DW_CFA_undefined;
6131 case DW_CFA_set_loc:
6132 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6133 if (do_debug_frames_interp)
6134 frame_display_row (fc, &need_col_headers, &max_regs);
6136 printf (" DW_CFA_set_loc: %s\n",
6137 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6141 case DW_CFA_advance_loc1:
6142 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6143 if (do_debug_frames_interp)
6144 frame_display_row (fc, &need_col_headers, &max_regs);
6146 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6147 (unsigned long) (ofs * fc->code_factor),
6148 dwarf_vmatoa_1 (NULL,
6149 fc->pc_begin + ofs * fc->code_factor,
6151 fc->pc_begin += ofs * fc->code_factor;
6154 case DW_CFA_advance_loc2:
6155 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6156 if (do_debug_frames_interp)
6157 frame_display_row (fc, &need_col_headers, &max_regs);
6159 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6160 (unsigned long) (ofs * fc->code_factor),
6161 dwarf_vmatoa_1 (NULL,
6162 fc->pc_begin + ofs * fc->code_factor,
6164 fc->pc_begin += ofs * fc->code_factor;
6167 case DW_CFA_advance_loc4:
6168 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6169 if (do_debug_frames_interp)
6170 frame_display_row (fc, &need_col_headers, &max_regs);
6172 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6173 (unsigned long) (ofs * fc->code_factor),
6174 dwarf_vmatoa_1 (NULL,
6175 fc->pc_begin + ofs * fc->code_factor,
6177 fc->pc_begin += ofs * fc->code_factor;
6180 case DW_CFA_offset_extended:
6183 if (reg >= (unsigned int) fc->ncols)
6184 reg_prefix = bad_reg;
6185 if (! do_debug_frames_interp || *reg_prefix != '\0')
6186 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6187 reg_prefix, regname (reg, 0),
6188 roffs * fc->data_factor);
6189 if (*reg_prefix == '\0')
6191 fc->col_type[reg] = DW_CFA_offset;
6192 fc->col_offset[reg] = roffs * fc->data_factor;
6196 case DW_CFA_val_offset:
6199 if (reg >= (unsigned int) fc->ncols)
6200 reg_prefix = bad_reg;
6201 if (! do_debug_frames_interp || *reg_prefix != '\0')
6202 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6203 reg_prefix, regname (reg, 0),
6204 roffs * fc->data_factor);
6205 if (*reg_prefix == '\0')
6207 fc->col_type[reg] = DW_CFA_val_offset;
6208 fc->col_offset[reg] = roffs * fc->data_factor;
6212 case DW_CFA_restore_extended:
6214 if (reg >= (unsigned int) cie->ncols
6215 || reg >= (unsigned int) fc->ncols)
6216 reg_prefix = bad_reg;
6217 if (! do_debug_frames_interp || *reg_prefix != '\0')
6218 printf (" DW_CFA_restore_extended: %s%s\n",
6219 reg_prefix, regname (reg, 0));
6220 if (*reg_prefix == '\0')
6222 fc->col_type[reg] = cie->col_type[reg];
6223 fc->col_offset[reg] = cie->col_offset[reg];
6227 case DW_CFA_undefined:
6229 if (reg >= (unsigned int) fc->ncols)
6230 reg_prefix = bad_reg;
6231 if (! do_debug_frames_interp || *reg_prefix != '\0')
6232 printf (" DW_CFA_undefined: %s%s\n",
6233 reg_prefix, regname (reg, 0));
6234 if (*reg_prefix == '\0')
6236 fc->col_type[reg] = DW_CFA_undefined;
6237 fc->col_offset[reg] = 0;
6241 case DW_CFA_same_value:
6243 if (reg >= (unsigned int) fc->ncols)
6244 reg_prefix = bad_reg;
6245 if (! do_debug_frames_interp || *reg_prefix != '\0')
6246 printf (" DW_CFA_same_value: %s%s\n",
6247 reg_prefix, regname (reg, 0));
6248 if (*reg_prefix == '\0')
6250 fc->col_type[reg] = DW_CFA_same_value;
6251 fc->col_offset[reg] = 0;
6255 case DW_CFA_register:
6258 if (reg >= (unsigned int) fc->ncols)
6259 reg_prefix = bad_reg;
6260 if (! do_debug_frames_interp || *reg_prefix != '\0')
6262 printf (" DW_CFA_register: %s%s in ",
6263 reg_prefix, regname (reg, 0));
6264 puts (regname (roffs, 0));
6266 if (*reg_prefix == '\0')
6268 fc->col_type[reg] = DW_CFA_register;
6269 fc->col_offset[reg] = roffs;
6273 case DW_CFA_remember_state:
6274 if (! do_debug_frames_interp)
6275 printf (" DW_CFA_remember_state\n");
6276 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6277 rs->cfa_offset = fc->cfa_offset;
6278 rs->cfa_reg = fc->cfa_reg;
6280 rs->cfa_exp = fc->cfa_exp;
6281 rs->ncols = fc->ncols;
6282 rs->col_type = (short int *) xcmalloc (rs->ncols,
6283 sizeof (* rs->col_type));
6284 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6285 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6286 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6287 rs->next = remembered_state;
6288 remembered_state = rs;
6291 case DW_CFA_restore_state:
6292 if (! do_debug_frames_interp)
6293 printf (" DW_CFA_restore_state\n");
6294 rs = remembered_state;
6297 remembered_state = rs->next;
6298 fc->cfa_offset = rs->cfa_offset;
6299 fc->cfa_reg = rs->cfa_reg;
6301 fc->cfa_exp = rs->cfa_exp;
6302 if (frame_need_space (fc, rs->ncols - 1) < 0)
6304 warn (_("Invalid column number in saved frame state\n"));
6308 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6309 memcpy (fc->col_offset, rs->col_offset,
6310 rs->ncols * sizeof (* rs->col_offset));
6311 free (rs->col_type);
6312 free (rs->col_offset);
6315 else if (do_debug_frames_interp)
6316 printf ("Mismatched DW_CFA_restore_state\n");
6319 case DW_CFA_def_cfa:
6320 fc->cfa_reg = LEB ();
6321 fc->cfa_offset = LEB ();
6323 if (! do_debug_frames_interp)
6324 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6325 regname (fc->cfa_reg, 0), fc->cfa_offset);
6328 case DW_CFA_def_cfa_register:
6329 fc->cfa_reg = LEB ();
6331 if (! do_debug_frames_interp)
6332 printf (" DW_CFA_def_cfa_register: %s\n",
6333 regname (fc->cfa_reg, 0));
6336 case DW_CFA_def_cfa_offset:
6337 fc->cfa_offset = LEB ();
6338 if (! do_debug_frames_interp)
6339 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6343 if (! do_debug_frames_interp)
6344 printf (" DW_CFA_nop\n");
6347 case DW_CFA_def_cfa_expression:
6349 if (start >= block_end || start + ul > block_end || start + ul < start)
6351 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6354 if (! do_debug_frames_interp)
6356 printf (" DW_CFA_def_cfa_expression (");
6357 decode_location_expression (start, eh_addr_size, 0, -1,
6365 case DW_CFA_expression:
6368 if (reg >= (unsigned int) fc->ncols)
6369 reg_prefix = bad_reg;
6370 /* PR 17512: file: 069-133014-0.006. */
6371 /* PR 17512: file: 98c02eb4. */
6372 if (start >= block_end || start + ul > block_end || start + ul < start)
6374 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6377 if (! do_debug_frames_interp || *reg_prefix != '\0')
6379 printf (" DW_CFA_expression: %s%s (",
6380 reg_prefix, regname (reg, 0));
6381 decode_location_expression (start, eh_addr_size, 0, -1,
6385 if (*reg_prefix == '\0')
6386 fc->col_type[reg] = DW_CFA_expression;
6390 case DW_CFA_val_expression:
6393 if (reg >= (unsigned int) fc->ncols)
6394 reg_prefix = bad_reg;
6395 if (start >= block_end || start + ul > block_end || start + ul < start)
6397 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6400 if (! do_debug_frames_interp || *reg_prefix != '\0')
6402 printf (" DW_CFA_val_expression: %s%s (",
6403 reg_prefix, regname (reg, 0));
6404 decode_location_expression (start, eh_addr_size, 0, -1,
6408 if (*reg_prefix == '\0')
6409 fc->col_type[reg] = DW_CFA_val_expression;
6413 case DW_CFA_offset_extended_sf:
6416 if (frame_need_space (fc, reg) < 0)
6417 reg_prefix = bad_reg;
6418 if (! do_debug_frames_interp || *reg_prefix != '\0')
6419 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6420 reg_prefix, regname (reg, 0),
6421 l * fc->data_factor);
6422 if (*reg_prefix == '\0')
6424 fc->col_type[reg] = DW_CFA_offset;
6425 fc->col_offset[reg] = l * fc->data_factor;
6429 case DW_CFA_val_offset_sf:
6432 if (frame_need_space (fc, reg) < 0)
6433 reg_prefix = bad_reg;
6434 if (! do_debug_frames_interp || *reg_prefix != '\0')
6435 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6436 reg_prefix, regname (reg, 0),
6437 l * fc->data_factor);
6438 if (*reg_prefix == '\0')
6440 fc->col_type[reg] = DW_CFA_val_offset;
6441 fc->col_offset[reg] = l * fc->data_factor;
6445 case DW_CFA_def_cfa_sf:
6446 fc->cfa_reg = LEB ();
6447 fc->cfa_offset = SLEB ();
6448 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6450 if (! do_debug_frames_interp)
6451 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6452 regname (fc->cfa_reg, 0), fc->cfa_offset);
6455 case DW_CFA_def_cfa_offset_sf:
6456 fc->cfa_offset = SLEB ();
6457 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6458 if (! do_debug_frames_interp)
6459 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
6462 case DW_CFA_MIPS_advance_loc8:
6463 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6464 if (do_debug_frames_interp)
6465 frame_display_row (fc, &need_col_headers, &max_regs);
6467 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6468 (unsigned long) (ofs * fc->code_factor),
6469 dwarf_vmatoa_1 (NULL,
6470 fc->pc_begin + ofs * fc->code_factor,
6472 fc->pc_begin += ofs * fc->code_factor;
6475 case DW_CFA_GNU_window_save:
6476 if (! do_debug_frames_interp)
6477 printf (" DW_CFA_GNU_window_save\n");
6480 case DW_CFA_GNU_args_size:
6482 if (! do_debug_frames_interp)
6483 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6486 case DW_CFA_GNU_negative_offset_extended:
6489 if (frame_need_space (fc, reg) < 0)
6490 reg_prefix = bad_reg;
6491 if (! do_debug_frames_interp || *reg_prefix != '\0')
6492 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6493 reg_prefix, regname (reg, 0),
6494 l * fc->data_factor);
6495 if (*reg_prefix == '\0')
6497 fc->col_type[reg] = DW_CFA_offset;
6498 fc->col_offset[reg] = l * fc->data_factor;
6503 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6504 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6506 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6511 if (do_debug_frames_interp)
6512 frame_display_row (fc, &need_col_headers, &max_regs);
6515 eh_addr_size = saved_eh_addr_size;
6528 display_gdb_index (struct dwarf_section *section,
6529 void *file ATTRIBUTE_UNUSED)
6531 unsigned char *start = section->start;
6533 uint32_t cu_list_offset, tu_list_offset;
6534 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6535 unsigned int cu_list_elements, tu_list_elements;
6536 unsigned int address_table_size, symbol_table_slots;
6537 unsigned char *cu_list, *tu_list;
6538 unsigned char *address_table, *symbol_table, *constant_pool;
6541 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6543 printf (_("Contents of the %s section:\n"), section->name);
6545 if (section->size < 6 * sizeof (uint32_t))
6547 warn (_("Truncated header in the %s section.\n"), section->name);
6551 version = byte_get_little_endian (start, 4);
6552 printf (_("Version %ld\n"), (long) version);
6554 /* Prior versions are obsolete, and future versions may not be
6555 backwards compatible. */
6556 if (version < 3 || version > 8)
6558 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6562 warn (_("The address table data in version 3 may be wrong.\n"));
6564 warn (_("Version 4 does not support case insensitive lookups.\n"));
6566 warn (_("Version 5 does not include inlined functions.\n"));
6568 warn (_("Version 6 does not include symbol attributes.\n"));
6569 /* Version 7 indices generated by Gold have bad type unit references,
6570 PR binutils/15021. But we don't know if the index was generated by
6571 Gold or not, so to avoid worrying users with gdb-generated indices
6572 we say nothing for version 7 here. */
6574 cu_list_offset = byte_get_little_endian (start + 4, 4);
6575 tu_list_offset = byte_get_little_endian (start + 8, 4);
6576 address_table_offset = byte_get_little_endian (start + 12, 4);
6577 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6578 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6580 if (cu_list_offset > section->size
6581 || tu_list_offset > section->size
6582 || address_table_offset > section->size
6583 || symbol_table_offset > section->size
6584 || constant_pool_offset > section->size)
6586 warn (_("Corrupt header in the %s section.\n"), section->name);
6590 /* PR 17531: file: 418d0a8a. */
6591 if (tu_list_offset < cu_list_offset)
6593 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6594 tu_list_offset, cu_list_offset);
6598 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6600 if (address_table_offset < tu_list_offset)
6602 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6603 address_table_offset, tu_list_offset);
6607 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6609 /* PR 17531: file: 18a47d3d. */
6610 if (symbol_table_offset < address_table_offset)
6612 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6613 symbol_table_offset, address_table_offset);
6617 address_table_size = symbol_table_offset - address_table_offset;
6619 if (constant_pool_offset < symbol_table_offset)
6621 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6622 constant_pool_offset, symbol_table_offset);
6626 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6628 cu_list = start + cu_list_offset;
6629 tu_list = start + tu_list_offset;
6630 address_table = start + address_table_offset;
6631 symbol_table = start + symbol_table_offset;
6632 constant_pool = start + constant_pool_offset;
6634 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6636 warn (_("Address table extends beyond end of section.\n"));
6640 printf (_("\nCU table:\n"));
6641 for (i = 0; i < cu_list_elements; i += 2)
6643 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6644 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6646 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6647 (unsigned long) cu_offset,
6648 (unsigned long) (cu_offset + cu_length - 1));
6651 printf (_("\nTU table:\n"));
6652 for (i = 0; i < tu_list_elements; i += 3)
6654 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6655 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6656 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6658 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6659 (unsigned long) tu_offset,
6660 (unsigned long) type_offset);
6661 print_dwarf_vma (signature, 8);
6665 printf (_("\nAddress table:\n"));
6666 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6669 uint64_t low = byte_get_little_endian (address_table + i, 8);
6670 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6671 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6673 print_dwarf_vma (low, 8);
6674 print_dwarf_vma (high, 8);
6675 printf (_("%lu\n"), (unsigned long) cu_index);
6678 printf (_("\nSymbol table:\n"));
6679 for (i = 0; i < symbol_table_slots; ++i)
6681 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6682 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6683 uint32_t num_cus, cu;
6685 if (name_offset != 0
6686 || cu_vector_offset != 0)
6690 /* PR 17531: file: 5b7b07ad. */
6691 if (constant_pool + name_offset < constant_pool
6692 || constant_pool + name_offset >= section->start + section->size)
6694 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6695 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6699 printf ("[%3u] %.*s:", i,
6700 (int) (section->size - (constant_pool_offset + name_offset)),
6701 constant_pool + name_offset);
6703 if (constant_pool + cu_vector_offset < constant_pool
6704 || constant_pool + cu_vector_offset >= section->start + section->size - 3)
6706 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6707 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6708 cu_vector_offset, i);
6712 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
6714 if (num_cus * 4 < num_cus
6715 || constant_pool + cu_vector_offset + 4 + num_cus * 4
6716 >= section->start + section->size)
6718 printf ("<invalid number of CUs: %d>\n", num_cus);
6719 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6726 for (j = 0; j < num_cus; ++j)
6729 gdb_index_symbol_kind kind;
6731 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6732 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6733 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6734 cu = GDB_INDEX_CU_VALUE (cu);
6735 /* Convert to TU number if it's for a type unit. */
6736 if (cu >= cu_list_elements / 2)
6737 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6738 (unsigned long) (cu - cu_list_elements / 2));
6740 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6742 printf (" [%s, %s]",
6743 is_static ? _("static") : _("global"),
6744 get_gdb_index_symbol_kind_name (kind));
6756 /* Pre-allocate enough space for the CU/TU sets needed. */
6759 prealloc_cu_tu_list (unsigned int nshndx)
6761 if (shndx_pool == NULL)
6763 shndx_pool_size = nshndx;
6764 shndx_pool_used = 0;
6765 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6766 sizeof (unsigned int));
6770 shndx_pool_size = shndx_pool_used + nshndx;
6771 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6772 sizeof (unsigned int));
6777 add_shndx_to_cu_tu_entry (unsigned int shndx)
6779 if (shndx_pool_used >= shndx_pool_size)
6781 error (_("Internal error: out of space in the shndx pool.\n"));
6784 shndx_pool [shndx_pool_used++] = shndx;
6788 end_cu_tu_entry (void)
6790 if (shndx_pool_used >= shndx_pool_size)
6792 error (_("Internal error: out of space in the shndx pool.\n"));
6795 shndx_pool [shndx_pool_used++] = 0;
6798 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6801 get_DW_SECT_short_name (unsigned int dw_sect)
6803 static char buf[16];
6811 case DW_SECT_ABBREV:
6817 case DW_SECT_STR_OFFSETS:
6819 case DW_SECT_MACINFO:
6827 snprintf (buf, sizeof (buf), "%d", dw_sect);
6831 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6832 These sections are extensions for Fission.
6833 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6836 process_cu_tu_index (struct dwarf_section *section, int do_display)
6838 unsigned char *phdr = section->start;
6839 unsigned char *limit = phdr + section->size;
6840 unsigned char *phash;
6841 unsigned char *pindex;
6842 unsigned char *ppool;
6843 unsigned int version;
6844 unsigned int ncols = 0;
6846 unsigned int nslots;
6849 dwarf_vma signature_high;
6850 dwarf_vma signature_low;
6853 /* PR 17512: file: 002-168123-0.004. */
6856 warn (_("Section %s is empty\n"), section->name);
6859 /* PR 17512: file: 002-376-0.004. */
6860 if (section->size < 24)
6862 warn (_("Section %s is too small to contain a CU/TU header\n"),
6867 SAFE_BYTE_GET (version, phdr, 4, limit);
6869 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6870 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6871 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6874 pindex = phash + nslots * 8;
6875 ppool = pindex + nslots * 4;
6877 /* PR 17531: file: 45d69832. */
6878 if (pindex < phash || ppool < phdr)
6880 warn (_("Section %s is too small for %d slots\n"),
6881 section->name, nslots);
6887 printf (_("Contents of the %s section:\n\n"), section->name);
6888 printf (_(" Version: %d\n"), version);
6890 printf (_(" Number of columns: %d\n"), ncols);
6891 printf (_(" Number of used entries: %d\n"), nused);
6892 printf (_(" Number of slots: %d\n\n"), nslots);
6897 warn (_("Section %s too small for %d hash table entries\n"),
6898 section->name, nslots);
6905 prealloc_cu_tu_list ((limit - ppool) / 4);
6906 for (i = 0; i < nslots; i++)
6908 unsigned char *shndx_list;
6911 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
6912 if (signature_high != 0 || signature_low != 0)
6914 SAFE_BYTE_GET (j, pindex, 4, limit);
6915 shndx_list = ppool + j * 4;
6917 printf (_(" [%3d] Signature: 0x%s Sections: "),
6918 i, dwarf_vmatoa64 (signature_high, signature_low,
6919 buf, sizeof (buf)));
6922 if (shndx_list >= limit)
6924 warn (_("Section %s too small for shndx pool\n"),
6928 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
6932 printf (" %d", shndx);
6934 add_shndx_to_cu_tu_entry (shndx);
6946 else if (version == 2)
6949 unsigned int dw_sect;
6950 unsigned char *ph = phash;
6951 unsigned char *pi = pindex;
6952 unsigned char *poffsets = ppool + ncols * 4;
6953 unsigned char *psizes = poffsets + nused * ncols * 4;
6954 unsigned char *pend = psizes + nused * ncols * 4;
6955 bfd_boolean is_tu_index;
6956 struct cu_tu_set *this_set = NULL;
6958 unsigned char *prow;
6960 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
6964 warn (_("Section %s too small for offset and size tables\n"),
6971 printf (_(" Offset table\n"));
6972 printf (" slot %-16s ",
6973 is_tu_index ? _("signature") : _("dwo_id"));
6980 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
6986 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
6993 for (j = 0; j < ncols; j++)
6995 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
6996 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7001 for (i = 0; i < nslots; i++)
7003 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7005 SAFE_BYTE_GET (row, pi, 4, limit);
7008 /* PR 17531: file: a05f6ab3. */
7011 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7017 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7019 prow = poffsets + (row - 1) * ncols * 4;
7022 printf (_(" [%3d] 0x%s"),
7023 i, dwarf_vmatoa64 (signature_high, signature_low,
7024 buf, sizeof (buf)));
7025 for (j = 0; j < ncols; j++)
7027 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7029 printf (" %8d", val);
7032 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7034 /* PR 17531: file: 10796eb3. */
7035 if (dw_sect >= DW_SECT_MAX)
7036 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7038 this_set [row - 1].section_offsets [dw_sect] = val;
7054 printf (_(" Size table\n"));
7055 printf (" slot %-16s ",
7056 is_tu_index ? _("signature") : _("dwo_id"));
7059 for (j = 0; j < ncols; j++)
7061 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7063 printf (" %8s", get_DW_SECT_short_name (val));
7069 for (i = 0; i < nslots; i++)
7071 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7073 SAFE_BYTE_GET (row, pi, 4, limit);
7076 prow = psizes + (row - 1) * ncols * 4;
7079 printf (_(" [%3d] 0x%s"),
7080 i, dwarf_vmatoa64 (signature_high, signature_low,
7081 buf, sizeof (buf)));
7083 for (j = 0; j < ncols; j++)
7085 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7087 printf (" %8d", val);
7090 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7091 if (dw_sect >= DW_SECT_MAX)
7092 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7094 this_set [row - 1].section_sizes [dw_sect] = val;
7106 else if (do_display)
7107 printf (_(" Unsupported version (%d)\n"), version);
7115 /* Load the CU and TU indexes if present. This will build a list of
7116 section sets that we can use to associate a .debug_info.dwo section
7117 with its associated .debug_abbrev.dwo section in a .dwp file. */
7120 load_cu_tu_indexes (void *file)
7122 /* If we have already loaded (or tried to load) the CU and TU indexes
7123 then do not bother to repeat the task. */
7124 if (cu_tu_indexes_read)
7127 if (load_debug_section (dwp_cu_index, file))
7128 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7130 if (load_debug_section (dwp_tu_index, file))
7131 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7133 cu_tu_indexes_read = 1;
7136 /* Find the set of sections that includes section SHNDX. */
7139 find_cu_tu_set (void *file, unsigned int shndx)
7143 load_cu_tu_indexes (file);
7145 /* Find SHNDX in the shndx pool. */
7146 for (i = 0; i < shndx_pool_used; i++)
7147 if (shndx_pool [i] == shndx)
7150 if (i >= shndx_pool_used)
7153 /* Now backup to find the first entry in the set. */
7154 while (i > 0 && shndx_pool [i - 1] != 0)
7157 return shndx_pool + i;
7160 /* Display a .debug_cu_index or .debug_tu_index section. */
7163 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7165 return process_cu_tu_index (section, 1);
7169 display_debug_not_supported (struct dwarf_section *section,
7170 void *file ATTRIBUTE_UNUSED)
7172 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7178 /* Like malloc, but takes two parameters like calloc.
7179 Verifies that the first parameter is not too large.
7180 Note: does *not* initialise the allocated memory to zero. */
7182 cmalloc (size_t nmemb, size_t size)
7184 /* Check for overflow. */
7185 if (nmemb >= ~(size_t) 0 / size)
7188 return xmalloc (nmemb * size);
7191 /* Like xmalloc, but takes two parameters like calloc.
7192 Verifies that the first parameter is not too large.
7193 Note: does *not* initialise the allocated memory to zero. */
7195 xcmalloc (size_t nmemb, size_t size)
7197 /* Check for overflow. */
7198 if (nmemb >= ~(size_t) 0 / size)
7201 return xmalloc (nmemb * size);
7204 /* Like xrealloc, but takes three parameters.
7205 Verifies that the second parameter is not too large.
7206 Note: does *not* initialise any new memory to zero. */
7208 xcrealloc (void *ptr, size_t nmemb, size_t size)
7210 /* Check for overflow. */
7211 if (nmemb >= ~(size_t) 0 / size)
7214 return xrealloc (ptr, nmemb * size);
7217 /* Like xcalloc, but verifies that the first parameter is not too large. */
7219 xcalloc2 (size_t nmemb, size_t size)
7221 /* Check for overflow. */
7222 if (nmemb >= ~(size_t) 0 / size)
7225 return xcalloc (nmemb, size);
7229 free_debug_memory (void)
7235 for (i = 0; i < max; i++)
7236 free_debug_section ((enum dwarf_section_display_enum) i);
7238 if (debug_information != NULL)
7240 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7242 for (i = 0; i < num_debug_info_entries; i++)
7244 if (!debug_information [i].max_loc_offsets)
7246 free (debug_information [i].loc_offsets);
7247 free (debug_information [i].have_frame_base);
7249 if (!debug_information [i].max_range_lists)
7250 free (debug_information [i].range_lists);
7253 free (debug_information);
7254 debug_information = NULL;
7255 alloc_num_debug_info_entries = num_debug_info_entries = 0;
7260 dwarf_select_sections_by_names (const char *names)
7264 const char * option;
7268 debug_dump_long_opts;
7270 static const debug_dump_long_opts opts_table [] =
7272 /* Please keep this table alpha- sorted. */
7273 { "Ranges", & do_debug_ranges, 1 },
7274 { "abbrev", & do_debug_abbrevs, 1 },
7275 { "addr", & do_debug_addr, 1 },
7276 { "aranges", & do_debug_aranges, 1 },
7277 { "cu_index", & do_debug_cu_index, 1 },
7278 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7279 { "frames", & do_debug_frames, 1 },
7280 { "frames-interp", & do_debug_frames_interp, 1 },
7281 /* The special .gdb_index section. */
7282 { "gdb_index", & do_gdb_index, 1 },
7283 { "info", & do_debug_info, 1 },
7284 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
7285 { "loc", & do_debug_loc, 1 },
7286 { "macro", & do_debug_macinfo, 1 },
7287 { "pubnames", & do_debug_pubnames, 1 },
7288 { "pubtypes", & do_debug_pubtypes, 1 },
7289 /* This entry is for compatability
7290 with earlier versions of readelf. */
7291 { "ranges", & do_debug_aranges, 1 },
7292 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7293 { "str", & do_debug_str, 1 },
7294 /* These trace_* sections are used by Itanium VMS. */
7295 { "trace_abbrev", & do_trace_abbrevs, 1 },
7296 { "trace_aranges", & do_trace_aranges, 1 },
7297 { "trace_info", & do_trace_info, 1 },
7306 const debug_dump_long_opts * entry;
7308 for (entry = opts_table; entry->option; entry++)
7310 size_t len = strlen (entry->option);
7312 if (strncmp (p, entry->option, len) == 0
7313 && (p[len] == ',' || p[len] == '\0'))
7315 * entry->variable |= entry->val;
7317 /* The --debug-dump=frames-interp option also
7318 enables the --debug-dump=frames option. */
7319 if (do_debug_frames_interp)
7320 do_debug_frames = 1;
7327 if (entry->option == NULL)
7329 warn (_("Unrecognized debug option '%s'\n"), p);
7330 p = strchr (p, ',');
7341 dwarf_select_sections_by_letters (const char *letters)
7343 unsigned int lindex = 0;
7345 while (letters[lindex])
7346 switch (letters[lindex++])
7353 do_debug_abbrevs = 1;
7357 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7361 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7365 do_debug_pubnames = 1;
7369 do_debug_pubtypes = 1;
7373 do_debug_aranges = 1;
7377 do_debug_ranges = 1;
7381 do_debug_frames_interp = 1;
7383 do_debug_frames = 1;
7387 do_debug_macinfo = 1;
7399 warn (_("Unrecognized debug option '%s'\n"), optarg);
7405 dwarf_select_sections_all (void)
7408 do_debug_abbrevs = 1;
7409 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7410 do_debug_pubnames = 1;
7411 do_debug_pubtypes = 1;
7412 do_debug_aranges = 1;
7413 do_debug_ranges = 1;
7414 do_debug_frames = 1;
7415 do_debug_macinfo = 1;
7420 do_trace_abbrevs = 1;
7421 do_trace_aranges = 1;
7423 do_debug_cu_index = 1;
7426 struct dwarf_section_display debug_displays[] =
7428 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL },
7429 display_debug_abbrev, &do_debug_abbrevs, 0 },
7430 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL },
7431 display_debug_aranges, &do_debug_aranges, 1 },
7432 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL },
7433 display_debug_frames, &do_debug_frames, 1 },
7434 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL },
7435 display_debug_info, &do_debug_info, 1 },
7436 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL },
7437 display_debug_lines, &do_debug_lines, 1 },
7438 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
7439 display_debug_pubnames, &do_debug_pubnames, 0 },
7440 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
7441 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7442 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL },
7443 display_debug_frames, &do_debug_frames, 1 },
7444 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL },
7445 display_debug_macinfo, &do_debug_macinfo, 0 },
7446 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL },
7447 display_debug_macro, &do_debug_macinfo, 1 },
7448 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL },
7449 display_debug_str, &do_debug_str, 0 },
7450 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL },
7451 display_debug_loc, &do_debug_loc, 1 },
7452 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7453 display_debug_pubnames, &do_debug_pubtypes, 0 },
7454 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7455 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7456 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL },
7457 display_debug_ranges, &do_debug_ranges, 1 },
7458 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
7459 display_debug_not_supported, NULL, 0 },
7460 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
7461 display_debug_not_supported, NULL, 0 },
7462 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL },
7463 display_debug_types, &do_debug_info, 1 },
7464 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
7465 display_debug_not_supported, NULL, 0 },
7466 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL },
7467 display_gdb_index, &do_gdb_index, 0 },
7468 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL },
7469 display_trace_info, &do_trace_info, 1 },
7470 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL },
7471 display_debug_abbrev, &do_trace_abbrevs, 0 },
7472 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL },
7473 display_debug_aranges, &do_trace_aranges, 0 },
7474 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7475 display_debug_info, &do_debug_info, 1 },
7476 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
7477 display_debug_abbrev, &do_debug_abbrevs, 0 },
7478 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7479 display_debug_types, &do_debug_info, 1 },
7480 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
7481 display_debug_lines, &do_debug_lines, 1 },
7482 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL },
7483 display_debug_loc, &do_debug_loc, 1 },
7484 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
7485 display_debug_macro, &do_debug_macinfo, 1 },
7486 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
7487 display_debug_macinfo, &do_debug_macinfo, 0 },
7488 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL },
7489 display_debug_str, &do_debug_str, 1 },
7490 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
7491 display_debug_str_offsets, NULL, 0 },
7492 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
7493 display_debug_str_offsets, NULL, 0 },
7494 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL },
7495 display_debug_addr, &do_debug_addr, 1 },
7496 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL },
7497 display_cu_index, &do_debug_cu_index, 0 },
7498 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL },
7499 display_cu_index, &do_debug_cu_index, 0 },