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));
2450 start += compunit.cu_length + initial_length_size;
2452 if (compunit.cu_version != 2
2453 && compunit.cu_version != 3
2454 && compunit.cu_version != 4)
2456 warn (_("CU at offset %s contains corrupt or "
2457 "unsupported version number: %d.\n"),
2458 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2464 /* Process the abbrevs used by this compilation unit. */
2465 if (compunit.cu_abbrev_offset >= abbrev_size)
2466 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2467 (unsigned long) compunit.cu_abbrev_offset,
2468 (unsigned long) abbrev_size);
2469 /* PR 17531: file:4bcd9ce9. */
2470 else if (abbrev_base >= abbrev_size)
2471 warn (_("Debug info is corrupted, abbrev base (%lx) is larger than abbrev section size (%lx)\n"),
2472 (unsigned long) abbrev_base,
2473 (unsigned long) abbrev_size);
2475 process_abbrev_section
2476 (((unsigned char *) debug_displays [abbrev_sec].section.start
2477 + abbrev_base + compunit.cu_abbrev_offset),
2478 ((unsigned char *) debug_displays [abbrev_sec].section.start
2479 + abbrev_base + abbrev_size));
2484 while (tags < start)
2486 unsigned int bytes_read;
2487 unsigned long abbrev_number;
2488 unsigned long die_offset;
2489 abbrev_entry *entry;
2491 int do_printing = 1;
2493 die_offset = tags - section_begin;
2495 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2498 /* A null DIE marks the end of a list of siblings or it may also be
2499 a section padding. */
2500 if (abbrev_number == 0)
2502 /* Check if it can be a section padding for the last CU. */
2503 if (level == 0 && start == end)
2507 for (chk = tags; chk < start; chk++)
2514 if (!do_loc && die_offset >= dwarf_start_die
2515 && (dwarf_cutoff_level == -1
2516 || level < dwarf_cutoff_level))
2517 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2523 static unsigned num_bogus_warns = 0;
2525 if (num_bogus_warns < 3)
2527 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2528 die_offset, section->name);
2530 if (num_bogus_warns == 3)
2531 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2534 if (dwarf_start_die != 0 && level < saved_level)
2541 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2545 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2546 saved_level = level;
2547 do_printing = (dwarf_cutoff_level == -1
2548 || level < dwarf_cutoff_level);
2550 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2551 level, die_offset, abbrev_number);
2552 else if (dwarf_cutoff_level == -1
2553 || last_level < dwarf_cutoff_level)
2554 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2559 /* Scan through the abbreviation list until we reach the
2561 for (entry = first_abbrev;
2562 entry && entry->entry != abbrev_number;
2563 entry = entry->next)
2568 if (!do_loc && do_printing)
2573 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2574 die_offset, abbrev_number);
2578 if (!do_loc && do_printing)
2579 printf (" (%s)\n", get_TAG_name (entry->tag));
2584 need_base_address = 0;
2586 case DW_TAG_compile_unit:
2587 need_base_address = 1;
2589 case DW_TAG_entry_point:
2590 case DW_TAG_subprogram:
2591 need_base_address = 0;
2592 /* Assuming that there is no DW_AT_frame_base. */
2593 have_frame_base = 0;
2597 for (attr = entry->first_attr;
2598 attr && attr->attribute;
2603 if (! do_loc && do_printing)
2604 /* Show the offset from where the tag was extracted. */
2605 printf (" <%lx>", (unsigned long)(tags - section_begin));
2607 if (debug_information && unit < alloc_num_debug_info_entries)
2608 arg = debug_information + unit;
2612 tags = read_and_display_attr (attr->attribute,
2617 compunit.cu_pointer_size,
2619 compunit.cu_version,
2621 do_loc || ! do_printing,
2626 if (entry->children)
2631 /* Set num_debug_info_entries here so that it can be used to check if
2632 we need to process .debug_loc and .debug_ranges sections. */
2633 if ((do_loc || do_debug_loc || do_debug_ranges)
2634 && num_debug_info_entries == 0
2637 if (num_units > alloc_num_debug_info_entries)
2638 num_debug_info_entries = alloc_num_debug_info_entries;
2640 num_debug_info_entries = num_units;
2649 /* Locate and scan the .debug_info section in the file and record the pointer
2650 sizes and offsets for the compilation units in it. Usually an executable
2651 will have just one pointer size, but this is not guaranteed, and so we try
2652 not to make any assumptions. Returns zero upon failure, or the number of
2653 compilation units upon success. */
2656 load_debug_info (void * file)
2658 /* Reset the last pointer size so that we can issue correct error
2659 messages if we are displaying the contents of more than one section. */
2660 last_pointer_size = 0;
2661 warned_about_missing_comp_units = FALSE;
2663 /* If we have already tried and failed to load the .debug_info
2664 section then do not bother to repeat the task. */
2665 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2668 /* If we already have the information there is nothing else to do. */
2669 if (num_debug_info_entries > 0)
2670 return num_debug_info_entries;
2672 /* If this is a DWARF package file, load the CU and TU indexes. */
2673 load_cu_tu_indexes (file);
2675 if (load_debug_section (info, file)
2676 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2677 return num_debug_info_entries;
2679 if (load_debug_section (info_dwo, file)
2680 && process_debug_info (&debug_displays [info_dwo].section, file,
2682 return num_debug_info_entries;
2684 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2688 /* Read a DWARF .debug_line section header starting at DATA.
2689 Upon success returns an updated DATA pointer and the LINFO
2690 structure and the END_OF_SEQUENCE pointer will be filled in.
2691 Otherwise returns NULL. */
2693 static unsigned char *
2694 read_debug_line_header (struct dwarf_section * section,
2695 unsigned char * data,
2696 unsigned char * end,
2697 DWARF2_Internal_LineInfo * linfo,
2698 unsigned char ** end_of_sequence)
2700 unsigned char *hdrptr;
2701 unsigned int offset_size;
2702 unsigned int initial_length_size;
2704 /* Extract information from the Line Number Program Header.
2705 (section 6.2.4 in the Dwarf3 doc). */
2708 /* Get and check the length of the block. */
2709 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2711 if (linfo->li_length == 0xffffffff)
2713 /* This section is 64-bit DWARF 3. */
2714 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2716 initial_length_size = 12;
2721 initial_length_size = 4;
2724 if (linfo->li_length + initial_length_size > section->size)
2726 /* If the length is just a bias against the initial_length_size then
2727 this means that the field has a relocation against it which has not
2728 been applied. (Ie we are dealing with an object file, not a linked
2729 binary). Do not complain but instead assume that the rest of the
2730 section applies to this particular header. */
2731 if (linfo->li_length == - initial_length_size)
2733 linfo->li_length = section->size - initial_length_size;
2737 warn (_("The line info appears to be corrupt - the section is too small\n"));
2742 /* Get and check the version number. */
2743 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2745 if (linfo->li_version != 2
2746 && linfo->li_version != 3
2747 && linfo->li_version != 4)
2749 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2753 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2754 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2756 if (linfo->li_version >= 4)
2758 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2760 if (linfo->li_max_ops_per_insn == 0)
2762 warn (_("Invalid maximum operations per insn.\n"));
2767 linfo->li_max_ops_per_insn = 1;
2769 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2770 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2771 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2772 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2774 * end_of_sequence = data + linfo->li_length + initial_length_size;
2775 /* PR 17512: file:002-117414-0.004. */
2776 if (* end_of_sequence > end)
2778 warn (_("Line length %s extends beyond end of section\n"),
2779 dwarf_vmatoa ("u", linfo->li_length));
2780 * end_of_sequence = end;
2788 display_debug_lines_raw (struct dwarf_section *section,
2789 unsigned char *data,
2792 unsigned char *start = section->start;
2794 printf (_("Raw dump of debug contents of section %s:\n\n"),
2799 static DWARF2_Internal_LineInfo saved_linfo;
2800 DWARF2_Internal_LineInfo linfo;
2801 unsigned char *standard_opcodes;
2802 unsigned char *end_of_sequence;
2803 unsigned int last_dir_entry = 0;
2806 if (const_strneq (section->name, ".debug_line.")
2807 /* Note: the following does not apply to .debug_line.dwo sections.
2808 These are full debug_line sections. */
2809 && strcmp (section->name, ".debug_line.dwo") != 0)
2811 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2812 section containing just the Line Number Statements. They are
2813 created by the assembler and intended to be used alongside gcc's
2814 -ffunction-sections command line option. When the linker's
2815 garbage collection decides to discard a .text.<foo> section it
2816 can then also discard the line number information in .debug_line.<foo>.
2818 Since the section is a fragment it does not have the details
2819 needed to fill out a LineInfo structure, so instead we use the
2820 details from the last full debug_line section that we processed. */
2821 end_of_sequence = end;
2822 standard_opcodes = NULL;
2823 linfo = saved_linfo;
2824 /* PR 17531: file: 0522b371. */
2825 if (linfo.li_line_range == 0)
2827 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2830 reset_state_machine (linfo.li_default_is_stmt);
2834 unsigned char * hdrptr;
2836 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2837 & end_of_sequence)) == NULL)
2840 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
2841 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2842 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2843 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2844 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2845 if (linfo.li_version >= 4)
2846 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2847 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2848 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2849 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2850 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2852 /* PR 17512: file: 1665-6428-0.004. */
2853 if (linfo.li_line_range == 0)
2855 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2856 linfo.li_line_range = 1;
2859 reset_state_machine (linfo.li_default_is_stmt);
2861 /* Display the contents of the Opcodes table. */
2862 standard_opcodes = hdrptr;
2864 /* PR 17512: file: 002-417945-0.004. */
2865 if (standard_opcodes + linfo.li_opcode_base >= end)
2867 warn (_("Line Base extends beyond end of section\n"));
2871 printf (_("\n Opcodes:\n"));
2873 for (i = 1; i < linfo.li_opcode_base; i++)
2874 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2876 /* Display the contents of the Directory table. */
2877 data = standard_opcodes + linfo.li_opcode_base - 1;
2880 printf (_("\n The Directory Table is empty.\n"));
2883 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2884 (long)(data - start));
2886 while (data < end && *data != 0)
2888 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2890 data += strnlen ((char *) data, end - data) + 1;
2893 /* PR 17512: file: 002-132094-0.004. */
2894 if (data >= end - 1)
2898 /* Skip the NUL at the end of the table. */
2901 /* Display the contents of the File Name table. */
2903 printf (_("\n The File Name Table is empty.\n"));
2906 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2907 (long)(data - start));
2908 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2910 while (data < end && *data != 0)
2912 unsigned char *name;
2913 unsigned int bytes_read;
2915 printf (" %d\t", ++state_machine_regs.last_file_entry);
2917 data += strnlen ((char *) data, end - data) + 1;
2920 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2923 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2926 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2928 printf ("%.*s\n", (int)(end - name), name);
2932 warn (_("Corrupt file name table entry\n"));
2938 /* Skip the NUL at the end of the table. */
2941 saved_linfo = linfo;
2944 /* Now display the statements. */
2945 if (data >= end_of_sequence)
2946 printf (_(" No Line Number Statements.\n"));
2949 printf (_(" Line Number Statements:\n"));
2951 while (data < end_of_sequence)
2953 unsigned char op_code;
2954 dwarf_signed_vma adv;
2956 unsigned int bytes_read;
2958 printf (" [0x%08lx]", (long)(data - start));
2962 if (op_code >= linfo.li_opcode_base)
2964 op_code -= linfo.li_opcode_base;
2965 uladv = (op_code / linfo.li_line_range);
2966 if (linfo.li_max_ops_per_insn == 1)
2968 uladv *= linfo.li_min_insn_length;
2969 state_machine_regs.address += uladv;
2970 printf (_(" Special opcode %d: "
2971 "advance Address by %s to 0x%s"),
2972 op_code, dwarf_vmatoa ("u", uladv),
2973 dwarf_vmatoa ("x", state_machine_regs.address));
2977 state_machine_regs.address
2978 += ((state_machine_regs.op_index + uladv)
2979 / linfo.li_max_ops_per_insn)
2980 * linfo.li_min_insn_length;
2981 state_machine_regs.op_index
2982 = (state_machine_regs.op_index + uladv)
2983 % linfo.li_max_ops_per_insn;
2984 printf (_(" Special opcode %d: "
2985 "advance Address by %s to 0x%s[%d]"),
2986 op_code, dwarf_vmatoa ("u", uladv),
2987 dwarf_vmatoa ("x", state_machine_regs.address),
2988 state_machine_regs.op_index);
2990 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2991 state_machine_regs.line += adv;
2992 printf (_(" and Line by %s to %d\n"),
2993 dwarf_vmatoa ("d", adv), state_machine_regs.line);
2995 else switch (op_code)
2997 case DW_LNS_extended_op:
2998 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3002 printf (_(" Copy\n"));
3005 case DW_LNS_advance_pc:
3006 uladv = read_uleb128 (data, & bytes_read, end);
3008 if (linfo.li_max_ops_per_insn == 1)
3010 uladv *= linfo.li_min_insn_length;
3011 state_machine_regs.address += uladv;
3012 printf (_(" Advance PC by %s to 0x%s\n"),
3013 dwarf_vmatoa ("u", uladv),
3014 dwarf_vmatoa ("x", state_machine_regs.address));
3018 state_machine_regs.address
3019 += ((state_machine_regs.op_index + uladv)
3020 / linfo.li_max_ops_per_insn)
3021 * linfo.li_min_insn_length;
3022 state_machine_regs.op_index
3023 = (state_machine_regs.op_index + uladv)
3024 % linfo.li_max_ops_per_insn;
3025 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3026 dwarf_vmatoa ("u", uladv),
3027 dwarf_vmatoa ("x", state_machine_regs.address),
3028 state_machine_regs.op_index);
3032 case DW_LNS_advance_line:
3033 adv = read_sleb128 (data, & bytes_read, end);
3035 state_machine_regs.line += adv;
3036 printf (_(" Advance Line by %s to %d\n"),
3037 dwarf_vmatoa ("d", adv),
3038 state_machine_regs.line);
3041 case DW_LNS_set_file:
3042 adv = read_uleb128 (data, & bytes_read, end);
3044 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3045 dwarf_vmatoa ("d", adv));
3046 state_machine_regs.file = adv;
3049 case DW_LNS_set_column:
3050 uladv = read_uleb128 (data, & bytes_read, end);
3052 printf (_(" Set column to %s\n"),
3053 dwarf_vmatoa ("u", uladv));
3054 state_machine_regs.column = uladv;
3057 case DW_LNS_negate_stmt:
3058 adv = state_machine_regs.is_stmt;
3060 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3061 state_machine_regs.is_stmt = adv;
3064 case DW_LNS_set_basic_block:
3065 printf (_(" Set basic block\n"));
3066 state_machine_regs.basic_block = 1;
3069 case DW_LNS_const_add_pc:
3070 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3071 if (linfo.li_max_ops_per_insn)
3073 uladv *= linfo.li_min_insn_length;
3074 state_machine_regs.address += uladv;
3075 printf (_(" Advance PC by constant %s to 0x%s\n"),
3076 dwarf_vmatoa ("u", uladv),
3077 dwarf_vmatoa ("x", state_machine_regs.address));
3081 state_machine_regs.address
3082 += ((state_machine_regs.op_index + uladv)
3083 / linfo.li_max_ops_per_insn)
3084 * linfo.li_min_insn_length;
3085 state_machine_regs.op_index
3086 = (state_machine_regs.op_index + uladv)
3087 % linfo.li_max_ops_per_insn;
3088 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3089 dwarf_vmatoa ("u", uladv),
3090 dwarf_vmatoa ("x", state_machine_regs.address),
3091 state_machine_regs.op_index);
3095 case DW_LNS_fixed_advance_pc:
3096 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3097 state_machine_regs.address += uladv;
3098 state_machine_regs.op_index = 0;
3099 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3100 dwarf_vmatoa ("u", uladv),
3101 dwarf_vmatoa ("x", state_machine_regs.address));
3104 case DW_LNS_set_prologue_end:
3105 printf (_(" Set prologue_end to true\n"));
3108 case DW_LNS_set_epilogue_begin:
3109 printf (_(" Set epilogue_begin to true\n"));
3112 case DW_LNS_set_isa:
3113 uladv = read_uleb128 (data, & bytes_read, end);
3115 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3119 printf (_(" Unknown opcode %d with operands: "), op_code);
3121 if (standard_opcodes != NULL)
3122 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3124 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3126 i == 1 ? "" : ", ");
3142 unsigned char *name;
3143 unsigned int directory_index;
3144 unsigned int modification_date;
3145 unsigned int length;
3148 /* Output a decoded representation of the .debug_line section. */
3151 display_debug_lines_decoded (struct dwarf_section *section,
3152 unsigned char *data,
3155 static DWARF2_Internal_LineInfo saved_linfo;
3157 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3162 /* This loop amounts to one iteration per compilation unit. */
3163 DWARF2_Internal_LineInfo linfo;
3164 unsigned char *standard_opcodes;
3165 unsigned char *end_of_sequence;
3167 File_Entry *file_table = NULL;
3168 unsigned int n_files = 0;
3169 unsigned char **directory_table = NULL;
3170 unsigned int n_directories = 0;
3172 if (const_strneq (section->name, ".debug_line.")
3173 /* Note: the following does not apply to .debug_line.dwo sections.
3174 These are full debug_line sections. */
3175 && strcmp (section->name, ".debug_line.dwo") != 0)
3177 /* See comment in display_debug_lines_raw(). */
3178 end_of_sequence = end;
3179 standard_opcodes = NULL;
3180 linfo = saved_linfo;
3181 /* PR 17531: file: 0522b371. */
3182 if (linfo.li_line_range == 0)
3184 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3187 reset_state_machine (linfo.li_default_is_stmt);
3191 unsigned char *hdrptr;
3193 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3194 & end_of_sequence)) == NULL)
3197 /* PR 17531: file: 0522b371. */
3198 if (linfo.li_line_range == 0)
3200 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3201 linfo.li_line_range = 1;
3203 reset_state_machine (linfo.li_default_is_stmt);
3205 /* Save a pointer to the contents of the Opcodes table. */
3206 standard_opcodes = hdrptr;
3208 /* Traverse the Directory table just to count entries. */
3209 data = standard_opcodes + linfo.li_opcode_base - 1;
3212 unsigned char *ptr_directory_table = data;
3216 data += strnlen ((char *) data, end - data) + 1;
3220 /* Go through the directory table again to save the directories. */
3221 directory_table = (unsigned char **)
3222 xmalloc (n_directories * sizeof (unsigned char *));
3225 while (*ptr_directory_table != 0)
3227 directory_table[i] = ptr_directory_table;
3228 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3229 ptr_directory_table - end) + 1;
3233 /* Skip the NUL at the end of the table. */
3236 /* Traverse the File Name table just to count the entries. */
3239 unsigned char *ptr_file_name_table = data;
3243 unsigned int bytes_read;
3245 /* Skip Name, directory index, last modification time and length
3247 data += strnlen ((char *) data, end - data) + 1;
3248 read_uleb128 (data, & bytes_read, end);
3250 read_uleb128 (data, & bytes_read, end);
3252 read_uleb128 (data, & bytes_read, end);
3258 /* Go through the file table again to save the strings. */
3259 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3262 while (*ptr_file_name_table != 0)
3264 unsigned int bytes_read;
3266 file_table[i].name = ptr_file_name_table;
3267 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3268 end - ptr_file_name_table) + 1;
3270 /* We are not interested in directory, time or size. */
3271 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3273 ptr_file_name_table += bytes_read;
3274 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3276 ptr_file_name_table += bytes_read;
3277 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3278 ptr_file_name_table += bytes_read;
3283 /* Print the Compilation Unit's name and a header. */
3284 if (directory_table == NULL)
3286 printf (_("CU: %s:\n"), file_table[0].name);
3287 printf (_("File name Line number Starting address\n"));
3291 unsigned int ix = file_table[0].directory_index;
3292 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3294 if (do_wide || strlen (directory) < 76)
3295 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3297 printf ("%s:\n", file_table[0].name);
3299 printf (_("File name Line number Starting address\n"));
3303 /* Skip the NUL at the end of the table. */
3306 saved_linfo = linfo;
3309 /* This loop iterates through the Dwarf Line Number Program. */
3310 while (data < end_of_sequence)
3312 unsigned char op_code;
3314 unsigned long int uladv;
3315 unsigned int bytes_read;
3316 int is_special_opcode = 0;
3320 if (op_code >= linfo.li_opcode_base)
3322 op_code -= linfo.li_opcode_base;
3323 uladv = (op_code / linfo.li_line_range);
3324 if (linfo.li_max_ops_per_insn == 1)
3326 uladv *= linfo.li_min_insn_length;
3327 state_machine_regs.address += uladv;
3331 state_machine_regs.address
3332 += ((state_machine_regs.op_index + uladv)
3333 / linfo.li_max_ops_per_insn)
3334 * linfo.li_min_insn_length;
3335 state_machine_regs.op_index
3336 = (state_machine_regs.op_index + uladv)
3337 % linfo.li_max_ops_per_insn;
3340 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3341 state_machine_regs.line += adv;
3342 is_special_opcode = 1;
3344 else switch (op_code)
3346 case DW_LNS_extended_op:
3348 unsigned int ext_op_code_len;
3349 unsigned char ext_op_code;
3350 unsigned char *op_code_data = data;
3352 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3354 op_code_data += bytes_read;
3356 if (ext_op_code_len == 0)
3358 warn (_("Badly formed extended line op encountered!\n"));
3361 ext_op_code_len += bytes_read;
3362 ext_op_code = *op_code_data++;
3364 switch (ext_op_code)
3366 case DW_LNE_end_sequence:
3367 reset_state_machine (linfo.li_default_is_stmt);
3369 case DW_LNE_set_address:
3370 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3372 ext_op_code_len - bytes_read - 1,
3374 state_machine_regs.op_index = 0;
3376 case DW_LNE_define_file:
3378 file_table = (File_Entry *) xrealloc
3379 (file_table, (n_files + 1) * sizeof (File_Entry));
3381 ++state_machine_regs.last_file_entry;
3382 /* Source file name. */
3383 file_table[n_files].name = op_code_data;
3384 op_code_data += strlen ((char *) op_code_data) + 1;
3385 /* Directory index. */
3386 file_table[n_files].directory_index =
3387 read_uleb128 (op_code_data, & bytes_read,
3389 op_code_data += bytes_read;
3390 /* Last modification time. */
3391 file_table[n_files].modification_date =
3392 read_uleb128 (op_code_data, & bytes_read,
3394 op_code_data += bytes_read;
3396 file_table[n_files].length =
3397 read_uleb128 (op_code_data, & bytes_read,
3403 case DW_LNE_set_discriminator:
3404 case DW_LNE_HP_set_sequence:
3405 /* Simply ignored. */
3409 printf (_("UNKNOWN (%u): length %d\n"),
3410 ext_op_code, ext_op_code_len - bytes_read);
3413 data += ext_op_code_len;
3419 case DW_LNS_advance_pc:
3420 uladv = read_uleb128 (data, & bytes_read, end);
3422 if (linfo.li_max_ops_per_insn == 1)
3424 uladv *= linfo.li_min_insn_length;
3425 state_machine_regs.address += uladv;
3429 state_machine_regs.address
3430 += ((state_machine_regs.op_index + uladv)
3431 / linfo.li_max_ops_per_insn)
3432 * linfo.li_min_insn_length;
3433 state_machine_regs.op_index
3434 = (state_machine_regs.op_index + uladv)
3435 % linfo.li_max_ops_per_insn;
3439 case DW_LNS_advance_line:
3440 adv = read_sleb128 (data, & bytes_read, end);
3442 state_machine_regs.line += adv;
3445 case DW_LNS_set_file:
3446 adv = read_uleb128 (data, & bytes_read, end);
3448 state_machine_regs.file = adv;
3450 if (file_table == NULL)
3451 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3452 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3453 /* If directory index is 0, that means current directory. */
3454 printf ("\n./%s:[++]\n",
3455 file_table[state_machine_regs.file - 1].name);
3456 else if (directory_table == NULL)
3457 printf (_("\n [Use directory table entry %d]\n"),
3458 file_table[state_machine_regs.file - 1].directory_index - 1);
3460 /* The directory index starts counting at 1. */
3461 printf ("\n%s/%s:\n",
3462 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3463 file_table[state_machine_regs.file - 1].name);
3466 case DW_LNS_set_column:
3467 uladv = read_uleb128 (data, & bytes_read, end);
3469 state_machine_regs.column = uladv;
3472 case DW_LNS_negate_stmt:
3473 adv = state_machine_regs.is_stmt;
3475 state_machine_regs.is_stmt = adv;
3478 case DW_LNS_set_basic_block:
3479 state_machine_regs.basic_block = 1;
3482 case DW_LNS_const_add_pc:
3483 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3484 if (linfo.li_max_ops_per_insn == 1)
3486 uladv *= linfo.li_min_insn_length;
3487 state_machine_regs.address += uladv;
3491 state_machine_regs.address
3492 += ((state_machine_regs.op_index + uladv)
3493 / linfo.li_max_ops_per_insn)
3494 * linfo.li_min_insn_length;
3495 state_machine_regs.op_index
3496 = (state_machine_regs.op_index + uladv)
3497 % linfo.li_max_ops_per_insn;
3501 case DW_LNS_fixed_advance_pc:
3502 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3503 state_machine_regs.address += uladv;
3504 state_machine_regs.op_index = 0;
3507 case DW_LNS_set_prologue_end:
3510 case DW_LNS_set_epilogue_begin:
3513 case DW_LNS_set_isa:
3514 uladv = read_uleb128 (data, & bytes_read, end);
3516 printf (_(" Set ISA to %lu\n"), uladv);
3520 printf (_(" Unknown opcode %d with operands: "), op_code);
3522 if (standard_opcodes != NULL)
3523 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3525 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3527 i == 1 ? "" : ", ");
3534 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3535 to the DWARF address/line matrix. */
3536 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3537 || (op_code == DW_LNS_copy))
3539 const unsigned int MAX_FILENAME_LENGTH = 35;
3541 char *newFileName = NULL;
3542 size_t fileNameLength;
3545 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3547 fileName = "<unknown>";
3549 fileNameLength = strlen (fileName);
3551 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3553 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3554 /* Truncate file name */
3555 strncpy (newFileName,
3556 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3557 MAX_FILENAME_LENGTH + 1);
3561 newFileName = (char *) xmalloc (fileNameLength + 1);
3562 strncpy (newFileName, fileName, fileNameLength + 1);
3565 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3567 if (linfo.li_max_ops_per_insn == 1)
3568 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3569 newFileName, state_machine_regs.line,
3570 state_machine_regs.address);
3572 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3573 newFileName, state_machine_regs.line,
3574 state_machine_regs.address,
3575 state_machine_regs.op_index);
3579 if (linfo.li_max_ops_per_insn == 1)
3580 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3581 newFileName, state_machine_regs.line,
3582 state_machine_regs.address);
3584 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3585 newFileName, state_machine_regs.line,
3586 state_machine_regs.address,
3587 state_machine_regs.op_index);
3590 if (op_code == DW_LNE_end_sequence)
3604 if (directory_table)
3606 free (directory_table);
3607 directory_table = NULL;
3618 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3620 unsigned char *data = section->start;
3621 unsigned char *end = data + section->size;
3623 int retValDecoded = 1;
3625 if (do_debug_lines == 0)
3626 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3628 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3629 retValRaw = display_debug_lines_raw (section, data, end);
3631 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3632 retValDecoded = display_debug_lines_decoded (section, data, end);
3634 if (!retValRaw || !retValDecoded)
3641 find_debug_info_for_offset (unsigned long offset)
3645 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3648 for (i = 0; i < num_debug_info_entries; i++)
3649 if (debug_information[i].cu_offset == offset)
3650 return debug_information + i;
3656 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3658 /* See gdb/gdb-index.h. */
3659 static const char * const kinds[] =
3671 return _ (kinds[kind]);
3675 display_debug_pubnames_worker (struct dwarf_section *section,
3676 void *file ATTRIBUTE_UNUSED,
3679 DWARF2_Internal_PubNames names;
3680 unsigned char *start = section->start;
3681 unsigned char *end = start + section->size;
3683 /* It does not matter if this load fails,
3684 we test for that later on. */
3685 load_debug_info (file);
3687 printf (_("Contents of the %s section:\n\n"), section->name);
3691 unsigned char *data;
3692 unsigned long offset;
3693 unsigned int offset_size, initial_length_size;
3697 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3698 if (names.pn_length == 0xffffffff)
3700 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3702 initial_length_size = 12;
3707 initial_length_size = 4;
3710 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3711 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3713 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3714 && num_debug_info_entries > 0
3715 && find_debug_info_for_offset (names.pn_offset) == NULL)
3716 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3717 (unsigned long) names.pn_offset, section->name);
3719 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3721 /* PR 17531: file: 7615b6b2. */
3722 if ((dwarf_signed_vma) names.pn_length < 0)
3724 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3728 start += names.pn_length + initial_length_size;
3730 printf (_(" Length: %ld\n"),
3731 (long) names.pn_length);
3732 printf (_(" Version: %d\n"),
3734 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3735 (unsigned long) names.pn_offset);
3736 printf (_(" Size of area in .debug_info section: %ld\n"),
3737 (long) names.pn_size);
3739 if (names.pn_version != 2 && names.pn_version != 3)
3741 static int warned = 0;
3745 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3753 printf (_("\n Offset Kind Name\n"));
3755 printf (_("\n Offset\tName\n"));
3759 bfd_size_type maxprint;
3761 SAFE_BYTE_GET (offset, data, offset_size, end);
3765 data += offset_size;
3768 maxprint = (end - data) - 1;
3772 unsigned int kind_data;
3773 gdb_index_symbol_kind kind;
3774 const char *kind_name;
3777 SAFE_BYTE_GET (kind_data, data, 1, end);
3780 /* GCC computes the kind as the upper byte in the CU index
3781 word, and then right shifts it by the CU index size.
3782 Left shift KIND to where the gdb-index.h accessor macros
3784 kind_data <<= GDB_INDEX_CU_BITSIZE;
3785 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3786 kind_name = get_gdb_index_symbol_kind_name (kind);
3787 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3788 printf (" %-6lx %s,%-10s %.*s\n",
3789 offset, is_static ? _("s") : _("g"),
3790 kind_name, (int) maxprint, data);
3793 printf (" %-6lx\t%.*s\n", offset, (int) maxprint, data);
3795 data += strnlen ((char *) data, maxprint) + 1;
3800 while (offset != 0);
3808 display_debug_pubnames (struct dwarf_section *section, void *file)
3810 return display_debug_pubnames_worker (section, file, 0);
3814 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3816 return display_debug_pubnames_worker (section, file, 1);
3820 display_debug_macinfo (struct dwarf_section *section,
3821 void *file ATTRIBUTE_UNUSED)
3823 unsigned char *start = section->start;
3824 unsigned char *end = start + section->size;
3825 unsigned char *curr = start;
3826 unsigned int bytes_read;
3827 enum dwarf_macinfo_record_type op;
3829 printf (_("Contents of the %s section:\n\n"), section->name);
3833 unsigned int lineno;
3834 const unsigned char *string;
3836 op = (enum dwarf_macinfo_record_type) *curr;
3841 case DW_MACINFO_start_file:
3843 unsigned int filenum;
3845 lineno = read_uleb128 (curr, & bytes_read, end);
3847 filenum = read_uleb128 (curr, & bytes_read, end);
3850 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3855 case DW_MACINFO_end_file:
3856 printf (_(" DW_MACINFO_end_file\n"));
3859 case DW_MACINFO_define:
3860 lineno = read_uleb128 (curr, & bytes_read, end);
3863 curr += strnlen ((char *) string, end - string) + 1;
3864 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3868 case DW_MACINFO_undef:
3869 lineno = read_uleb128 (curr, & bytes_read, end);
3872 curr += strnlen ((char *) string, end - string) + 1;
3873 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3877 case DW_MACINFO_vendor_ext:
3879 unsigned int constant;
3881 constant = read_uleb128 (curr, & bytes_read, end);
3884 curr += strnlen ((char *) string, end - string) + 1;
3885 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3895 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3896 filename and dirname corresponding to file name table entry with index
3897 FILEIDX. Return NULL on failure. */
3899 static unsigned char *
3900 get_line_filename_and_dirname (dwarf_vma line_offset,
3902 unsigned char **dir_name)
3904 struct dwarf_section *section = &debug_displays [line].section;
3905 unsigned char *hdrptr, *dirtable, *file_name;
3906 unsigned int offset_size, initial_length_size;
3907 unsigned int version, opcode_base, bytes_read;
3908 dwarf_vma length, diridx;
3909 const unsigned char * end;
3912 if (section->start == NULL
3913 || line_offset >= section->size
3917 hdrptr = section->start + line_offset;
3918 end = section->start + section->size;
3920 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3921 if (length == 0xffffffff)
3923 /* This section is 64-bit DWARF 3. */
3924 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3926 initial_length_size = 12;
3931 initial_length_size = 4;
3933 if (length + initial_length_size > section->size)
3936 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3937 if (version != 2 && version != 3 && version != 4)
3939 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3941 hdrptr++; /* Skip max_ops_per_insn. */
3942 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3944 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3945 if (opcode_base == 0)
3948 hdrptr += opcode_base - 1;
3950 /* Skip over dirname table. */
3951 while (*hdrptr != '\0')
3952 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3953 hdrptr++; /* Skip the NUL at the end of the table. */
3954 /* Now skip over preceding filename table entries. */
3955 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3957 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3958 read_uleb128 (hdrptr, &bytes_read, end);
3959 hdrptr += bytes_read;
3960 read_uleb128 (hdrptr, &bytes_read, end);
3961 hdrptr += bytes_read;
3962 read_uleb128 (hdrptr, &bytes_read, end);
3963 hdrptr += bytes_read;
3965 if (hdrptr == end || *hdrptr == '\0')
3968 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3969 diridx = read_uleb128 (hdrptr, &bytes_read, end);
3972 for (; *dirtable != '\0' && diridx > 1; diridx--)
3973 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
3974 if (*dirtable == '\0')
3976 *dir_name = dirtable;
3981 display_debug_macro (struct dwarf_section *section,
3984 unsigned char *start = section->start;
3985 unsigned char *end = start + section->size;
3986 unsigned char *curr = start;
3987 unsigned char *extended_op_buf[256];
3988 unsigned int bytes_read;
3990 load_debug_section (str, file);
3991 load_debug_section (line, file);
3993 printf (_("Contents of the %s section:\n\n"), section->name);
3997 unsigned int lineno, version, flags;
3998 unsigned int offset_size = 4;
3999 const unsigned char *string;
4000 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4001 unsigned char **extended_ops = NULL;
4003 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4006 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4011 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4014 printf (_(" Offset: 0x%lx\n"),
4015 (unsigned long) sec_offset);
4016 printf (_(" Version: %d\n"), version);
4017 printf (_(" Offset size: %d\n"), offset_size);
4020 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4021 printf (_(" Offset into .debug_line: 0x%lx\n"),
4022 (unsigned long) line_offset);
4026 unsigned int i, count, op;
4029 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4031 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4032 extended_ops = extended_op_buf;
4035 printf (_(" Extension opcode arguments:\n"));
4036 for (i = 0; i < count; i++)
4038 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4039 extended_ops[op] = curr;
4040 nargs = read_uleb128 (curr, &bytes_read, end);
4043 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
4046 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
4047 for (n = 0; n < nargs; n++)
4051 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4052 printf ("%s%s", get_FORM_name (form),
4053 n == nargs - 1 ? "\n" : ", ");
4063 case DW_FORM_block1:
4064 case DW_FORM_block2:
4065 case DW_FORM_block4:
4067 case DW_FORM_string:
4069 case DW_FORM_sec_offset:
4072 error (_("Invalid extension opcode form %s\n"),
4073 get_FORM_name (form));
4089 error (_(".debug_macro section not zero terminated\n"));
4093 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4099 case DW_MACRO_GNU_start_file:
4101 unsigned int filenum;
4102 unsigned char *file_name = NULL, *dir_name = NULL;
4104 lineno = read_uleb128 (curr, &bytes_read, end);
4106 filenum = read_uleb128 (curr, &bytes_read, end);
4109 if ((flags & 2) == 0)
4110 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4113 = get_line_filename_and_dirname (line_offset, filenum,
4115 if (file_name == NULL)
4116 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4119 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4121 dir_name != NULL ? (const char *) dir_name : "",
4122 dir_name != NULL ? "/" : "", file_name);
4126 case DW_MACRO_GNU_end_file:
4127 printf (_(" DW_MACRO_GNU_end_file\n"));
4130 case DW_MACRO_GNU_define:
4131 lineno = read_uleb128 (curr, &bytes_read, end);
4134 curr += strnlen ((char *) string, end - string) + 1;
4135 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4139 case DW_MACRO_GNU_undef:
4140 lineno = read_uleb128 (curr, &bytes_read, end);
4143 curr += strnlen ((char *) string, end - string) + 1;
4144 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4148 case DW_MACRO_GNU_define_indirect:
4149 lineno = read_uleb128 (curr, &bytes_read, end);
4151 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4152 string = fetch_indirect_string (offset);
4153 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4157 case DW_MACRO_GNU_undef_indirect:
4158 lineno = read_uleb128 (curr, &bytes_read, end);
4160 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4161 string = fetch_indirect_string (offset);
4162 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4166 case DW_MACRO_GNU_transparent_include:
4167 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4168 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4169 (unsigned long) offset);
4172 case DW_MACRO_GNU_define_indirect_alt:
4173 lineno = read_uleb128 (curr, &bytes_read, end);
4175 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4176 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4177 lineno, (unsigned long) offset);
4180 case DW_MACRO_GNU_undef_indirect_alt:
4181 lineno = read_uleb128 (curr, &bytes_read, end);
4183 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4184 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4185 lineno, (unsigned long) offset);
4188 case DW_MACRO_GNU_transparent_include_alt:
4189 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4190 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4191 (unsigned long) offset);
4195 if (extended_ops == NULL || extended_ops[op] == NULL)
4197 error (_(" Unknown macro opcode %02x seen\n"), op);
4202 /* Skip over unhandled opcodes. */
4204 unsigned char *desc = extended_ops[op];
4205 nargs = read_uleb128 (desc, &bytes_read, end);
4209 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4212 printf (_(" DW_MACRO_GNU_%02x -"), op);
4213 for (n = 0; n < nargs; n++)
4217 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4219 = read_and_display_attr_value (0, val,
4220 curr, end, 0, 0, offset_size,
4221 version, NULL, 0, NULL,
4239 display_debug_abbrev (struct dwarf_section *section,
4240 void *file ATTRIBUTE_UNUSED)
4242 abbrev_entry *entry;
4243 unsigned char *start = section->start;
4244 unsigned char *end = start + section->size;
4246 printf (_("Contents of the %s section:\n\n"), section->name);
4250 unsigned char *last;
4255 start = process_abbrev_section (start, end);
4257 if (first_abbrev == NULL)
4260 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
4262 for (entry = first_abbrev; entry; entry = entry->next)
4266 printf (" %ld %s [%s]\n",
4268 get_TAG_name (entry->tag),
4269 entry->children ? _("has children") : _("no children"));
4271 for (attr = entry->first_attr; attr; attr = attr->next)
4272 printf (" %-18s %s\n",
4273 get_AT_name (attr->attribute),
4274 get_FORM_name (attr->form));
4284 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4287 display_loc_list (struct dwarf_section *section,
4288 unsigned char **start_ptr,
4289 unsigned int debug_info_entry,
4290 unsigned long offset,
4291 unsigned long base_address,
4294 unsigned char *start = *start_ptr;
4295 unsigned char *section_end = section->start + section->size;
4296 unsigned long cu_offset;
4297 unsigned int pointer_size;
4298 unsigned int offset_size;
4303 unsigned short length;
4304 int need_frame_base;
4306 if (debug_info_entry >= num_debug_info_entries)
4308 warn (_("No debug information available for loc lists of entry: %u\n"),
4313 cu_offset = debug_information [debug_info_entry].cu_offset;
4314 pointer_size = debug_information [debug_info_entry].pointer_size;
4315 offset_size = debug_information [debug_info_entry].offset_size;
4316 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4318 if (pointer_size < 2 || pointer_size > 8)
4320 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4321 pointer_size, debug_info_entry);
4327 if (start + 2 * pointer_size > section_end)
4329 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4334 printf (" %8.8lx ", offset + (start - *start_ptr));
4336 /* Note: we use sign extension here in order to be sure that we can detect
4337 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4338 address will not affect the values that we display since we always show
4339 hex values, and always the bottom 32-bits. */
4340 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4341 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4343 if (begin == 0 && end == 0)
4345 printf (_("<End of list>\n"));
4349 /* Check base address specifiers. */
4350 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4353 print_dwarf_vma (begin, pointer_size);
4354 print_dwarf_vma (end, pointer_size);
4355 printf (_("(base address)\n"));
4359 if (start + 2 > section_end)
4361 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4366 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4368 if (start + length > section_end)
4370 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4375 print_dwarf_vma (begin + base_address, pointer_size);
4376 print_dwarf_vma (end + base_address, pointer_size);
4379 need_frame_base = decode_location_expression (start,
4384 cu_offset, section);
4387 if (need_frame_base && !has_frame_base)
4388 printf (_(" [without DW_AT_frame_base]"));
4391 fputs (_(" (start == end)"), stdout);
4392 else if (begin > end)
4393 fputs (_(" (start > end)"), stdout);
4403 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4404 right-adjusted in a field of length LEN, and followed by a space. */
4407 print_addr_index (unsigned int idx, unsigned int len)
4409 static char buf[15];
4410 snprintf (buf, sizeof (buf), "[%d]", idx);
4411 printf ("%*s ", len, buf);
4414 /* Display a location list from a .dwo section. It uses address indexes rather
4415 than embedded addresses. This code closely follows display_loc_list, but the
4416 two are sufficiently different that combining things is very ugly. */
4419 display_loc_list_dwo (struct dwarf_section *section,
4420 unsigned char **start_ptr,
4421 unsigned int debug_info_entry,
4422 unsigned long offset,
4425 unsigned char *start = *start_ptr;
4426 unsigned char *section_end = section->start + section->size;
4427 unsigned long cu_offset;
4428 unsigned int pointer_size;
4429 unsigned int offset_size;
4432 unsigned short length;
4433 int need_frame_base;
4435 unsigned int bytes_read;
4437 if (debug_info_entry >= num_debug_info_entries)
4439 warn (_("No debug information for loc lists of entry: %u\n"),
4444 cu_offset = debug_information [debug_info_entry].cu_offset;
4445 pointer_size = debug_information [debug_info_entry].pointer_size;
4446 offset_size = debug_information [debug_info_entry].offset_size;
4447 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4449 if (pointer_size < 2 || pointer_size > 8)
4451 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4452 pointer_size, debug_info_entry);
4458 printf (" %8.8lx ", offset + (start - *start_ptr));
4460 if (start >= section_end)
4462 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4467 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4470 case 0: /* A terminating entry. */
4472 printf (_("<End of list>\n"));
4474 case 1: /* A base-address entry. */
4475 idx = read_uleb128 (start, &bytes_read, section_end);
4476 start += bytes_read;
4477 print_addr_index (idx, 8);
4479 printf (_("(base address selection entry)\n"));
4481 case 2: /* A start/end entry. */
4482 idx = read_uleb128 (start, &bytes_read, section_end);
4483 start += bytes_read;
4484 print_addr_index (idx, 8);
4485 idx = read_uleb128 (start, &bytes_read, section_end);
4486 start += bytes_read;
4487 print_addr_index (idx, 8);
4489 case 3: /* A start/length entry. */
4490 idx = read_uleb128 (start, &bytes_read, section_end);
4491 start += bytes_read;
4492 print_addr_index (idx, 8);
4493 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4494 printf ("%08x ", idx);
4496 case 4: /* An offset pair entry. */
4497 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4498 printf ("%08x ", idx);
4499 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4500 printf ("%08x ", idx);
4503 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4508 if (start + 2 > section_end)
4510 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4515 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4516 if (start + length > section_end)
4518 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4524 need_frame_base = decode_location_expression (start,
4529 cu_offset, section);
4532 if (need_frame_base && !has_frame_base)
4533 printf (_(" [without DW_AT_frame_base]"));
4543 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4545 static dwarf_vma *loc_offsets;
4548 loc_offsets_compar (const void *ap, const void *bp)
4550 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4551 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4553 return (a > b) - (b > a);
4557 display_debug_loc (struct dwarf_section *section, void *file)
4559 unsigned char *start = section->start;
4560 unsigned long bytes;
4561 unsigned char *section_begin = start;
4562 unsigned int num_loc_list = 0;
4563 unsigned long last_offset = 0;
4564 unsigned int first = 0;
4568 int seen_first_offset = 0;
4569 int locs_sorted = 1;
4570 unsigned char *next;
4571 unsigned int *array = NULL;
4572 const char *suffix = strrchr (section->name, '.');
4575 if (suffix && strcmp (suffix, ".dwo") == 0)
4578 bytes = section->size;
4582 printf (_("\nThe %s section is empty.\n"), section->name);
4586 if (load_debug_info (file) == 0)
4588 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4593 /* Check the order of location list in .debug_info section. If
4594 offsets of location lists are in the ascending order, we can
4595 use `debug_information' directly. */
4596 for (i = 0; i < num_debug_info_entries; i++)
4600 num = debug_information [i].num_loc_offsets;
4601 if (num > num_loc_list)
4604 /* Check if we can use `debug_information' directly. */
4605 if (locs_sorted && num != 0)
4607 if (!seen_first_offset)
4609 /* This is the first location list. */
4610 last_offset = debug_information [i].loc_offsets [0];
4612 seen_first_offset = 1;
4618 for (; j < num; j++)
4621 debug_information [i].loc_offsets [j])
4626 last_offset = debug_information [i].loc_offsets [j];
4631 if (!seen_first_offset)
4632 error (_("No location lists in .debug_info section!\n"));
4634 if (debug_information [first].num_loc_offsets > 0
4635 && debug_information [first].loc_offsets [0] != 0)
4636 warn (_("Location lists in %s section start at 0x%s\n"),
4638 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4641 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4642 printf (_("Contents of the %s section:\n\n"), section->name);
4643 printf (_(" Offset Begin End Expression\n"));
4645 seen_first_offset = 0;
4646 for (i = first; i < num_debug_info_entries; i++)
4648 unsigned long offset;
4649 unsigned long base_address;
4654 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4656 loc_offsets = debug_information [i].loc_offsets;
4657 qsort (array, debug_information [i].num_loc_offsets,
4658 sizeof (*array), loc_offsets_compar);
4661 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4663 j = locs_sorted ? k : array[k];
4665 && debug_information [i].loc_offsets [locs_sorted
4666 ? k - 1 : array [k - 1]]
4667 == debug_information [i].loc_offsets [j])
4669 has_frame_base = debug_information [i].have_frame_base [j];
4670 offset = debug_information [i].loc_offsets [j];
4671 next = section_begin + offset;
4672 base_address = debug_information [i].base_address;
4674 if (!seen_first_offset)
4675 seen_first_offset = 1;
4679 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4680 (unsigned long) (start - section_begin),
4681 (unsigned long) (next - section_begin));
4682 else if (start > next)
4683 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4684 (unsigned long) (start - section_begin),
4685 (unsigned long) (next - section_begin));
4689 if (offset >= bytes)
4691 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4697 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4699 display_loc_list (section, &start, i, offset, base_address,
4704 if (start < section->start + section->size)
4705 warn (_("There are %ld unused bytes at the end of section %s\n"),
4706 (long) (section->start + section->size - start), section->name);
4713 display_debug_str (struct dwarf_section *section,
4714 void *file ATTRIBUTE_UNUSED)
4716 unsigned char *start = section->start;
4717 unsigned long bytes = section->size;
4718 dwarf_vma addr = section->address;
4722 printf (_("\nThe %s section is empty.\n"), section->name);
4726 printf (_("Contents of the %s section:\n\n"), section->name);
4734 lbytes = (bytes > 16 ? 16 : bytes);
4736 printf (" 0x%8.8lx ", (unsigned long) addr);
4738 for (j = 0; j < 16; j++)
4741 printf ("%2.2x", start[j]);
4749 for (j = 0; j < lbytes; j++)
4752 if (k >= ' ' && k < 0x80)
4771 display_debug_info (struct dwarf_section *section, void *file)
4773 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4777 display_debug_types (struct dwarf_section *section, void *file)
4779 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4783 display_trace_info (struct dwarf_section *section, void *file)
4785 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4789 display_debug_aranges (struct dwarf_section *section,
4790 void *file ATTRIBUTE_UNUSED)
4792 unsigned char *start = section->start;
4793 unsigned char *end = start + section->size;
4795 printf (_("Contents of the %s section:\n\n"), section->name);
4797 /* It does not matter if this load fails,
4798 we test for that later on. */
4799 load_debug_info (file);
4803 unsigned char *hdrptr;
4804 DWARF2_Internal_ARange arange;
4805 unsigned char *addr_ranges;
4808 unsigned char address_size;
4810 unsigned int offset_size;
4811 unsigned int initial_length_size;
4815 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4816 if (arange.ar_length == 0xffffffff)
4818 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4820 initial_length_size = 12;
4825 initial_length_size = 4;
4828 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4829 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4831 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4832 && num_debug_info_entries > 0
4833 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4834 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4835 (unsigned long) arange.ar_info_offset, section->name);
4837 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4838 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4840 if (arange.ar_version != 2 && arange.ar_version != 3)
4842 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4846 printf (_(" Length: %ld\n"),
4847 (long) arange.ar_length);
4848 printf (_(" Version: %d\n"), arange.ar_version);
4849 printf (_(" Offset into .debug_info: 0x%lx\n"),
4850 (unsigned long) arange.ar_info_offset);
4851 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4852 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4854 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4856 /* PR 17512: file: 001-108546-0.001:0.1. */
4857 if (address_size == 0 || address_size > 8)
4859 error (_("Invalid address size in %s section!\n"),
4864 /* The DWARF spec does not require that the address size be a power
4865 of two, but we do. This will have to change if we ever encounter
4866 an uneven architecture. */
4867 if ((address_size & (address_size - 1)) != 0)
4869 warn (_("Pointer size + Segment size is not a power of two.\n"));
4873 if (address_size > 4)
4874 printf (_("\n Address Length\n"));
4876 printf (_("\n Address Length\n"));
4878 addr_ranges = hdrptr;
4880 /* Must pad to an alignment boundary that is twice the address size. */
4881 excess = (hdrptr - start) % (2 * address_size);
4883 addr_ranges += (2 * address_size) - excess;
4885 start += arange.ar_length + initial_length_size;
4887 while (addr_ranges + 2 * address_size <= start)
4889 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4890 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4893 print_dwarf_vma (address, address_size);
4894 print_dwarf_vma (length, address_size);
4904 /* Comparison function for qsort. */
4906 comp_addr_base (const void * v0, const void * v1)
4908 debug_info * info0 = (debug_info *) v0;
4909 debug_info * info1 = (debug_info *) v1;
4910 return info0->addr_base - info1->addr_base;
4913 /* Display the debug_addr section. */
4915 display_debug_addr (struct dwarf_section *section,
4918 debug_info **debug_addr_info;
4919 unsigned char *entry;
4924 if (section->size == 0)
4926 printf (_("\nThe %s section is empty.\n"), section->name);
4930 if (load_debug_info (file) == 0)
4932 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4937 printf (_("Contents of the %s section:\n\n"), section->name);
4939 /* PR 17531: file: cf38d01b.
4940 We use xcalloc because a corrupt file may not have initialised all of the
4941 fields in the debug_info structure, which means that the sort below might
4942 try to move uninitialised data. */
4943 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
4944 sizeof (debug_info *));
4947 for (i = 0; i < num_debug_info_entries; i++)
4948 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4950 /* PR 17531: file: cf38d01b. */
4951 if (debug_information[i].addr_base >= section->size)
4952 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
4953 (unsigned long) debug_information[i].addr_base, i);
4955 debug_addr_info [count++] = debug_information + i;
4958 /* Add a sentinel to make iteration convenient. */
4959 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
4960 debug_addr_info [count]->addr_base = section->size;
4961 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
4963 for (i = 0; i < count; i++)
4966 unsigned int address_size = debug_addr_info [i]->pointer_size;
4968 printf (_(" For compilation unit at offset 0x%s:\n"),
4969 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
4971 printf (_("\tIndex\tAddress\n"));
4972 entry = section->start + debug_addr_info [i]->addr_base;
4973 end = section->start + debug_addr_info [i + 1]->addr_base;
4977 dwarf_vma base = byte_get (entry, address_size);
4978 printf (_("\t%d:\t"), idx);
4979 print_dwarf_vma (base, address_size);
4981 entry += address_size;
4987 free (debug_addr_info);
4991 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4993 display_debug_str_offsets (struct dwarf_section *section,
4994 void *file ATTRIBUTE_UNUSED)
4996 if (section->size == 0)
4998 printf (_("\nThe %s section is empty.\n"), section->name);
5001 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5002 what the offset size is for this section. */
5006 /* Each debug_information[x].range_lists[y] gets this representation for
5007 sorting purposes. */
5011 /* The debug_information[x].range_lists[y] value. */
5012 unsigned long ranges_offset;
5014 /* Original debug_information to find parameters of the data. */
5015 debug_info *debug_info_p;
5018 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5021 range_entry_compar (const void *ap, const void *bp)
5023 const struct range_entry *a_re = (const struct range_entry *) ap;
5024 const struct range_entry *b_re = (const struct range_entry *) bp;
5025 const unsigned long a = a_re->ranges_offset;
5026 const unsigned long b = b_re->ranges_offset;
5028 return (a > b) - (b > a);
5032 display_debug_ranges (struct dwarf_section *section,
5033 void *file ATTRIBUTE_UNUSED)
5035 unsigned char *start = section->start;
5036 unsigned char *last_start = start;
5037 unsigned long bytes = section->size;
5038 unsigned char *section_begin = start;
5039 unsigned char *finish = start + bytes;
5040 unsigned int num_range_list, i;
5041 struct range_entry *range_entries, *range_entry_fill;
5045 printf (_("\nThe %s section is empty.\n"), section->name);
5049 if (load_debug_info (file) == 0)
5051 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5057 for (i = 0; i < num_debug_info_entries; i++)
5058 num_range_list += debug_information [i].num_range_lists;
5060 if (num_range_list == 0)
5062 /* This can happen when the file was compiled with -gsplit-debug
5063 which removes references to range lists from the primary .o file. */
5064 printf (_("No range lists in .debug_info section.\n"));
5068 range_entries = (struct range_entry *)
5069 xmalloc (sizeof (*range_entries) * num_range_list);
5070 range_entry_fill = range_entries;
5072 for (i = 0; i < num_debug_info_entries; i++)
5074 debug_info *debug_info_p = &debug_information[i];
5077 for (j = 0; j < debug_info_p->num_range_lists; j++)
5079 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5080 range_entry_fill->debug_info_p = debug_info_p;
5085 qsort (range_entries, num_range_list, sizeof (*range_entries),
5086 range_entry_compar);
5088 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5089 warn (_("Range lists in %s section start at 0x%lx\n"),
5090 section->name, range_entries[0].ranges_offset);
5092 printf (_("Contents of the %s section:\n\n"), section->name);
5093 printf (_(" Offset Begin End\n"));
5095 for (i = 0; i < num_range_list; i++)
5097 struct range_entry *range_entry = &range_entries[i];
5098 debug_info *debug_info_p = range_entry->debug_info_p;
5099 unsigned int pointer_size;
5100 unsigned long offset;
5101 unsigned char *next;
5102 unsigned long base_address;
5104 pointer_size = debug_info_p->pointer_size;
5105 offset = range_entry->ranges_offset;
5106 next = section_begin + offset;
5107 base_address = debug_info_p->base_address;
5109 /* PR 17512: file: 001-101485-0.001:0.1. */
5110 if (pointer_size < 2 || pointer_size > 8)
5112 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5113 pointer_size, offset);
5117 if (dwarf_check != 0 && i > 0)
5120 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5121 (unsigned long) (start - section_begin),
5122 (unsigned long) (next - section_begin), section->name);
5123 else if (start > next)
5125 if (next == last_start)
5127 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5128 (unsigned long) (start - section_begin),
5129 (unsigned long) (next - section_begin), section->name);
5135 while (start < finish)
5140 /* Note: we use sign extension here in order to be sure that
5141 we can detect the -1 escape value. Sign extension into the
5142 top 32 bits of a 32-bit address will not affect the values
5143 that we display since we always show hex values, and always
5144 the bottom 32-bits. */
5145 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5146 if (start >= finish)
5148 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5150 printf (" %8.8lx ", offset);
5152 if (begin == 0 && end == 0)
5154 printf (_("<End of list>\n"));
5158 /* Check base address specifiers. */
5159 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5162 print_dwarf_vma (begin, pointer_size);
5163 print_dwarf_vma (end, pointer_size);
5164 printf ("(base address)\n");
5168 print_dwarf_vma (begin + base_address, pointer_size);
5169 print_dwarf_vma (end + base_address, pointer_size);
5172 fputs (_("(start == end)"), stdout);
5173 else if (begin > end)
5174 fputs (_("(start > end)"), stdout);
5181 free (range_entries);
5186 typedef struct Frame_Chunk
5188 struct Frame_Chunk *next;
5189 unsigned char *chunk_start;
5191 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5192 short int *col_type;
5195 unsigned int code_factor;
5202 unsigned char fde_encoding;
5203 unsigned char cfa_exp;
5204 unsigned char ptr_size;
5205 unsigned char segment_size;
5209 static const char *const *dwarf_regnames;
5210 static unsigned int dwarf_regnames_count;
5212 /* A marker for a col_type that means this column was never referenced
5213 in the frame info. */
5214 #define DW_CFA_unreferenced (-1)
5216 /* Return 0 if no more space is needed, 1 if more space is needed,
5217 -1 for invalid reg. */
5220 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5222 unsigned int prev = fc->ncols;
5224 if (reg < (unsigned int) fc->ncols)
5227 if (dwarf_regnames_count
5228 && reg > dwarf_regnames_count)
5231 fc->ncols = reg + 1;
5232 /* PR 17512: file: 10450-2643-0.004.
5233 If reg == -1 then this can happen... */
5237 /* PR 17512: file: 2844a11d. */
5238 if (fc->ncols > 1024)
5240 error (_("Unfeasibly large register number: %u\n"), reg);
5242 /* FIXME: 1024 is an arbitrary limit. Increase it if
5243 we ever encounter a valid binary that exceeds it. */
5247 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5248 sizeof (short int));
5249 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5250 /* PR 17512: file:002-10025-0.005. */
5251 if (fc->col_type == NULL || fc->col_offset == NULL)
5253 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5259 while (prev < fc->ncols)
5261 fc->col_type[prev] = DW_CFA_unreferenced;
5262 fc->col_offset[prev] = 0;
5268 static const char *const dwarf_regnames_i386[] =
5270 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5271 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5272 "eip", "eflags", NULL, /* 8 - 10 */
5273 "st0", "st1", "st2", "st3", /* 11 - 14 */
5274 "st4", "st5", "st6", "st7", /* 15 - 18 */
5275 NULL, NULL, /* 19 - 20 */
5276 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5277 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5278 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5279 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5280 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5281 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5282 "tr", "ldtr", /* 48 - 49 */
5283 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5284 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5285 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5286 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5287 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5288 NULL, NULL, NULL, /* 90 - 92 */
5289 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5293 init_dwarf_regnames_i386 (void)
5295 dwarf_regnames = dwarf_regnames_i386;
5296 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5299 static const char *const dwarf_regnames_x86_64[] =
5301 "rax", "rdx", "rcx", "rbx",
5302 "rsi", "rdi", "rbp", "rsp",
5303 "r8", "r9", "r10", "r11",
5304 "r12", "r13", "r14", "r15",
5306 "xmm0", "xmm1", "xmm2", "xmm3",
5307 "xmm4", "xmm5", "xmm6", "xmm7",
5308 "xmm8", "xmm9", "xmm10", "xmm11",
5309 "xmm12", "xmm13", "xmm14", "xmm15",
5310 "st0", "st1", "st2", "st3",
5311 "st4", "st5", "st6", "st7",
5312 "mm0", "mm1", "mm2", "mm3",
5313 "mm4", "mm5", "mm6", "mm7",
5315 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5316 "fs.base", "gs.base", NULL, NULL,
5318 "mxcsr", "fcw", "fsw",
5319 "xmm16", "xmm17", "xmm18", "xmm19",
5320 "xmm20", "xmm21", "xmm22", "xmm23",
5321 "xmm24", "xmm25", "xmm26", "xmm27",
5322 "xmm28", "xmm29", "xmm30", "xmm31",
5323 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5324 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5325 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5326 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5327 NULL, NULL, NULL, /* 115 - 117 */
5328 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5332 init_dwarf_regnames_x86_64 (void)
5334 dwarf_regnames = dwarf_regnames_x86_64;
5335 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5338 static const char *const dwarf_regnames_aarch64[] =
5340 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5341 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5342 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5343 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5344 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5345 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5346 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5347 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5348 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5349 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5350 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5351 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5355 init_dwarf_regnames_aarch64 (void)
5357 dwarf_regnames = dwarf_regnames_aarch64;
5358 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5362 init_dwarf_regnames (unsigned int e_machine)
5368 init_dwarf_regnames_i386 ();
5374 init_dwarf_regnames_x86_64 ();
5378 init_dwarf_regnames_aarch64 ();
5387 regname (unsigned int regno, int row)
5389 static char reg[64];
5391 && regno < dwarf_regnames_count
5392 && dwarf_regnames [regno] != NULL)
5395 return dwarf_regnames [regno];
5396 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5397 dwarf_regnames [regno]);
5400 snprintf (reg, sizeof (reg), "r%d", regno);
5405 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5410 if (*max_regs < fc->ncols)
5411 *max_regs = fc->ncols;
5413 if (*need_col_headers)
5415 static const char *sloc = " LOC";
5417 *need_col_headers = 0;
5419 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5421 for (r = 0; r < *max_regs; r++)
5422 if (fc->col_type[r] != DW_CFA_unreferenced)
5427 printf ("%-5s ", regname (r, 1));
5433 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5435 strcpy (tmp, "exp");
5437 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5438 printf ("%-8s ", tmp);
5440 for (r = 0; r < fc->ncols; r++)
5442 if (fc->col_type[r] != DW_CFA_unreferenced)
5444 switch (fc->col_type[r])
5446 case DW_CFA_undefined:
5449 case DW_CFA_same_value:
5453 sprintf (tmp, "c%+d", fc->col_offset[r]);
5455 case DW_CFA_val_offset:
5456 sprintf (tmp, "v%+d", fc->col_offset[r]);
5458 case DW_CFA_register:
5459 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5461 case DW_CFA_expression:
5462 strcpy (tmp, "exp");
5464 case DW_CFA_val_expression:
5465 strcpy (tmp, "vexp");
5468 strcpy (tmp, "n/a");
5471 printf ("%-5s ", tmp);
5477 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5478 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5479 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5481 static unsigned char *
5482 read_cie (unsigned char *start, unsigned char *end,
5483 Frame_Chunk **p_cie, int *p_version,
5484 unsigned long *p_aug_len, unsigned char **p_aug)
5488 unsigned int length_return;
5489 unsigned char *augmentation_data = NULL;
5490 unsigned long augmentation_data_len = 0;
5493 /* PR 17512: file: 001-228113-0.004. */
5497 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5498 memset (fc, 0, sizeof (Frame_Chunk));
5500 fc->col_type = (short int *) xmalloc (sizeof (short int));
5501 fc->col_offset = (int *) xmalloc (sizeof (int));
5505 fc->augmentation = (char *) start;
5506 /* PR 17512: file: 001-228113-0.004.
5507 Skip past augmentation name, but avoid running off the end of the data. */
5509 if (* start ++ == '\0')
5513 warn (_("No terminator for augmentation name\n"));
5517 if (strcmp (fc->augmentation, "eh") == 0)
5518 start += eh_addr_size;
5522 GET (fc->ptr_size, 1);
5523 GET (fc->segment_size, 1);
5524 eh_addr_size = fc->ptr_size;
5528 fc->ptr_size = eh_addr_size;
5529 fc->segment_size = 0;
5531 fc->code_factor = LEB ();
5532 fc->data_factor = SLEB ();
5542 if (fc->augmentation[0] == 'z')
5544 augmentation_data_len = LEB ();
5545 augmentation_data = start;
5546 start += augmentation_data_len;
5547 /* PR 17512: file: 11042-2589-0.004. */
5550 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5555 if (augmentation_data_len)
5559 unsigned char *qend;
5561 p = (unsigned char *) fc->augmentation + 1;
5562 q = augmentation_data;
5563 qend = q + augmentation_data_len;
5565 /* PR 17531: file: 015adfaa. */
5568 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5569 augmentation_data_len = 0;
5572 while (p < end && q < augmentation_data + augmentation_data_len)
5577 q += 1 + size_of_encoded_value (*q);
5579 fc->fde_encoding = *q++;
5586 /* Note - it is OK if this loop terminates with q < qend.
5587 Padding may have been inserted to align the end of the CIE. */
5592 *p_version = version;
5595 *p_aug_len = augmentation_data_len;
5596 *p_aug = augmentation_data;
5602 display_debug_frames (struct dwarf_section *section,
5603 void *file ATTRIBUTE_UNUSED)
5605 unsigned char *start = section->start;
5606 unsigned char *end = start + section->size;
5607 unsigned char *section_start = start;
5608 Frame_Chunk *chunks = 0, *forward_refs = 0;
5609 Frame_Chunk *remembered_state = 0;
5611 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5612 unsigned int length_return;
5613 unsigned int max_regs = 0;
5614 const char *bad_reg = _("bad register: ");
5615 int saved_eh_addr_size = eh_addr_size;
5617 printf (_("Contents of the %s section:\n"), section->name);
5621 unsigned char *saved_start;
5622 unsigned char *block_end;
5627 int need_col_headers = 1;
5628 unsigned char *augmentation_data = NULL;
5629 unsigned long augmentation_data_len = 0;
5630 unsigned int encoded_ptr_size = saved_eh_addr_size;
5631 unsigned int offset_size;
5632 unsigned int initial_length_size;
5634 saved_start = start;
5636 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5640 printf ("\n%08lx ZERO terminator\n\n",
5641 (unsigned long)(saved_start - section_start));
5642 /* Skip any zero terminators that directly follow.
5643 A corrupt section size could have loaded a whole
5644 slew of zero filled memory bytes. eg
5645 PR 17512: file: 070-19381-0.004. */
5646 while (start < end && * start == 0)
5651 if (length == 0xffffffff)
5653 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5655 initial_length_size = 12;
5660 initial_length_size = 4;
5663 block_end = saved_start + length + initial_length_size;
5664 if (block_end > end || block_end < start)
5666 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5667 dwarf_vmatoa_1 (NULL, length, offset_size),
5668 (unsigned long) (saved_start - section_start));
5672 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5674 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5675 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5680 start = read_cie (start, end, &cie, &version,
5681 &augmentation_data_len, &augmentation_data);
5682 /* PR 17512: file: 027-135133-0.005. */
5689 fc->chunk_start = saved_start;
5690 mreg = max_regs > 0 ? max_regs - 1 : 0;
5693 if (frame_need_space (fc, mreg) < 0)
5695 if (fc->fde_encoding)
5696 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5698 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5699 print_dwarf_vma (length, fc->ptr_size);
5700 print_dwarf_vma (cie_id, offset_size);
5702 if (do_debug_frames_interp)
5704 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5705 fc->code_factor, fc->data_factor, fc->ra);
5710 printf (" Version: %d\n", version);
5711 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5714 printf (" Pointer Size: %u\n", fc->ptr_size);
5715 printf (" Segment Size: %u\n", fc->segment_size);
5717 printf (" Code alignment factor: %u\n", fc->code_factor);
5718 printf (" Data alignment factor: %d\n", fc->data_factor);
5719 printf (" Return address column: %d\n", fc->ra);
5721 if (augmentation_data_len)
5725 printf (" Augmentation data: ");
5726 for (i = 0; i < augmentation_data_len; ++i)
5727 /* FIXME: If do_wide is FALSE, then we should
5728 add carriage returns at 80 columns... */
5729 printf (" %02x", augmentation_data[i]);
5737 unsigned char *look_for;
5738 static Frame_Chunk fde_fc;
5739 unsigned long segment_selector;
5743 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5744 look_for = start - 4 - ((cie_id ^ sign) - sign);
5747 look_for = section_start + cie_id;
5749 if (look_for <= saved_start)
5751 for (cie = chunks; cie ; cie = cie->next)
5752 if (cie->chunk_start == look_for)
5757 for (cie = forward_refs; cie ; cie = cie->next)
5758 if (cie->chunk_start == look_for)
5762 unsigned int off_size;
5763 unsigned char *cie_scan;
5765 cie_scan = look_for;
5767 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5768 if (length == 0xffffffff)
5770 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5777 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5780 : ((off_size == 4 && c_id == DW_CIE_ID)
5781 || (off_size == 8 && c_id == DW64_CIE_ID)))
5786 read_cie (cie_scan, end, &cie, &version,
5787 &augmentation_data_len, &augmentation_data);
5788 /* PR 17512: file: 3450-2098-0.004. */
5791 warn (_("Failed to read CIE information\n"));
5794 cie->next = forward_refs;
5796 cie->chunk_start = look_for;
5797 mreg = max_regs > 0 ? max_regs - 1 : 0;
5800 if (frame_need_space (cie, mreg) < 0)
5802 warn (_("Invalid max register\n"));
5805 if (cie->fde_encoding)
5807 = size_of_encoded_value (cie->fde_encoding);
5814 memset (fc, 0, sizeof (Frame_Chunk));
5818 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5819 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5820 (unsigned long) (saved_start - section_start));
5822 fc->col_type = (short int *) xmalloc (sizeof (short int));
5823 fc->col_offset = (int *) xmalloc (sizeof (int));
5824 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5826 warn (_("Invalid max register\n"));
5830 fc->augmentation = "";
5831 fc->fde_encoding = 0;
5832 fc->ptr_size = eh_addr_size;
5833 fc->segment_size = 0;
5837 fc->ncols = cie->ncols;
5838 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5839 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
5840 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5841 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5842 fc->augmentation = cie->augmentation;
5843 fc->ptr_size = cie->ptr_size;
5844 eh_addr_size = cie->ptr_size;
5845 fc->segment_size = cie->segment_size;
5846 fc->code_factor = cie->code_factor;
5847 fc->data_factor = cie->data_factor;
5848 fc->cfa_reg = cie->cfa_reg;
5849 fc->cfa_offset = cie->cfa_offset;
5851 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5853 warn (_("Invalid max register\n"));
5856 fc->fde_encoding = cie->fde_encoding;
5859 if (fc->fde_encoding)
5860 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5862 segment_selector = 0;
5863 if (fc->segment_size)
5864 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5866 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
5868 /* FIXME: It appears that sometimes the final pc_range value is
5869 encoded in less than encoded_ptr_size bytes. See the x86_64
5870 run of the "objcopy on compressed debug sections" test for an
5872 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5874 if (cie->augmentation[0] == 'z')
5876 augmentation_data_len = LEB ();
5877 augmentation_data = start;
5878 start += augmentation_data_len;
5879 /* PR 17512: file: 722-8446-0.004. */
5880 if (start >= end || ((signed long) augmentation_data_len) < 0)
5882 warn (_("Corrupt augmentation data length: %lx\n"),
5883 augmentation_data_len);
5885 augmentation_data = NULL;
5886 augmentation_data_len = 0;
5890 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5891 (unsigned long)(saved_start - section_start),
5892 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5893 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5894 (unsigned long)(cie->chunk_start - section_start));
5896 if (fc->segment_size)
5897 printf ("%04lx:", segment_selector);
5900 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5901 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5903 if (! do_debug_frames_interp && augmentation_data_len)
5907 printf (" Augmentation data: ");
5908 for (i = 0; i < augmentation_data_len; ++i)
5909 printf (" %02x", augmentation_data[i]);
5915 /* At this point, fc is the current chunk, cie (if any) is set, and
5916 we're about to interpret instructions for the chunk. */
5917 /* ??? At present we need to do this always, since this sizes the
5918 fc->col_type and fc->col_offset arrays, which we write into always.
5919 We should probably split the interpreted and non-interpreted bits
5920 into two different routines, since there's so much that doesn't
5921 really overlap between them. */
5922 if (1 || do_debug_frames_interp)
5924 /* Start by making a pass over the chunk, allocating storage
5925 and taking note of what registers are used. */
5926 unsigned char *tmp = start;
5928 while (start < block_end)
5930 unsigned int reg, op, opa;
5938 /* Warning: if you add any more cases to this switch, be
5939 sure to add them to the corresponding switch below. */
5942 case DW_CFA_advance_loc:
5946 if (frame_need_space (fc, opa) >= 0)
5947 fc->col_type[opa] = DW_CFA_undefined;
5949 case DW_CFA_restore:
5950 if (frame_need_space (fc, opa) >= 0)
5951 fc->col_type[opa] = DW_CFA_undefined;
5953 case DW_CFA_set_loc:
5954 start += encoded_ptr_size;
5956 case DW_CFA_advance_loc1:
5959 case DW_CFA_advance_loc2:
5962 case DW_CFA_advance_loc4:
5965 case DW_CFA_offset_extended:
5966 case DW_CFA_val_offset:
5967 reg = LEB (); LEB ();
5968 if (frame_need_space (fc, reg) >= 0)
5969 fc->col_type[reg] = DW_CFA_undefined;
5971 case DW_CFA_restore_extended:
5973 if (frame_need_space (fc, reg) >= 0)
5974 fc->col_type[reg] = DW_CFA_undefined;
5976 case DW_CFA_undefined:
5978 if (frame_need_space (fc, reg) >= 0)
5979 fc->col_type[reg] = DW_CFA_undefined;
5981 case DW_CFA_same_value:
5983 if (frame_need_space (fc, reg) >= 0)
5984 fc->col_type[reg] = DW_CFA_undefined;
5986 case DW_CFA_register:
5987 reg = LEB (); LEB ();
5988 if (frame_need_space (fc, reg) >= 0)
5989 fc->col_type[reg] = DW_CFA_undefined;
5991 case DW_CFA_def_cfa:
5994 case DW_CFA_def_cfa_register:
5997 case DW_CFA_def_cfa_offset:
6000 case DW_CFA_def_cfa_expression:
6002 if (start + temp < start)
6004 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6010 case DW_CFA_expression:
6011 case DW_CFA_val_expression:
6014 if (start + temp < start)
6016 /* PR 17512: file:306-192417-0.005. */
6017 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6022 if (frame_need_space (fc, reg) >= 0)
6023 fc->col_type[reg] = DW_CFA_undefined;
6025 case DW_CFA_offset_extended_sf:
6026 case DW_CFA_val_offset_sf:
6027 reg = LEB (); SLEB ();
6028 if (frame_need_space (fc, reg) >= 0)
6029 fc->col_type[reg] = DW_CFA_undefined;
6031 case DW_CFA_def_cfa_sf:
6034 case DW_CFA_def_cfa_offset_sf:
6037 case DW_CFA_MIPS_advance_loc8:
6040 case DW_CFA_GNU_args_size:
6043 case DW_CFA_GNU_negative_offset_extended:
6044 reg = LEB (); LEB ();
6045 if (frame_need_space (fc, reg) >= 0)
6046 fc->col_type[reg] = DW_CFA_undefined;
6055 /* Now we know what registers are used, make a second pass over
6056 the chunk, this time actually printing out the info. */
6058 while (start < block_end)
6061 unsigned long ul, reg, roffs;
6065 const char *reg_prefix = "";
6072 /* Warning: if you add any more cases to this switch, be
6073 sure to add them to the corresponding switch above. */
6076 case DW_CFA_advance_loc:
6077 if (do_debug_frames_interp)
6078 frame_display_row (fc, &need_col_headers, &max_regs);
6080 printf (" DW_CFA_advance_loc: %d to %s\n",
6081 opa * fc->code_factor,
6082 dwarf_vmatoa_1 (NULL,
6083 fc->pc_begin + opa * fc->code_factor,
6085 fc->pc_begin += opa * fc->code_factor;
6090 if (opa >= (unsigned int) fc->ncols)
6091 reg_prefix = bad_reg;
6092 if (! do_debug_frames_interp || *reg_prefix != '\0')
6093 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6094 reg_prefix, regname (opa, 0),
6095 roffs * fc->data_factor);
6096 if (*reg_prefix == '\0')
6098 fc->col_type[opa] = DW_CFA_offset;
6099 fc->col_offset[opa] = roffs * fc->data_factor;
6103 case DW_CFA_restore:
6104 if (opa >= (unsigned int) cie->ncols
6105 || opa >= (unsigned int) fc->ncols)
6106 reg_prefix = bad_reg;
6107 if (! do_debug_frames_interp || *reg_prefix != '\0')
6108 printf (" DW_CFA_restore: %s%s\n",
6109 reg_prefix, regname (opa, 0));
6110 if (*reg_prefix == '\0')
6112 fc->col_type[opa] = cie->col_type[opa];
6113 fc->col_offset[opa] = cie->col_offset[opa];
6114 if (do_debug_frames_interp
6115 && fc->col_type[opa] == DW_CFA_unreferenced)
6116 fc->col_type[opa] = DW_CFA_undefined;
6120 case DW_CFA_set_loc:
6121 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6122 if (do_debug_frames_interp)
6123 frame_display_row (fc, &need_col_headers, &max_regs);
6125 printf (" DW_CFA_set_loc: %s\n",
6126 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6130 case DW_CFA_advance_loc1:
6131 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6132 if (do_debug_frames_interp)
6133 frame_display_row (fc, &need_col_headers, &max_regs);
6135 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6136 (unsigned long) (ofs * fc->code_factor),
6137 dwarf_vmatoa_1 (NULL,
6138 fc->pc_begin + ofs * fc->code_factor,
6140 fc->pc_begin += ofs * fc->code_factor;
6143 case DW_CFA_advance_loc2:
6144 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6145 if (do_debug_frames_interp)
6146 frame_display_row (fc, &need_col_headers, &max_regs);
6148 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6149 (unsigned long) (ofs * fc->code_factor),
6150 dwarf_vmatoa_1 (NULL,
6151 fc->pc_begin + ofs * fc->code_factor,
6153 fc->pc_begin += ofs * fc->code_factor;
6156 case DW_CFA_advance_loc4:
6157 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6158 if (do_debug_frames_interp)
6159 frame_display_row (fc, &need_col_headers, &max_regs);
6161 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6162 (unsigned long) (ofs * fc->code_factor),
6163 dwarf_vmatoa_1 (NULL,
6164 fc->pc_begin + ofs * fc->code_factor,
6166 fc->pc_begin += ofs * fc->code_factor;
6169 case DW_CFA_offset_extended:
6172 if (reg >= (unsigned int) fc->ncols)
6173 reg_prefix = bad_reg;
6174 if (! do_debug_frames_interp || *reg_prefix != '\0')
6175 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6176 reg_prefix, regname (reg, 0),
6177 roffs * fc->data_factor);
6178 if (*reg_prefix == '\0')
6180 fc->col_type[reg] = DW_CFA_offset;
6181 fc->col_offset[reg] = roffs * fc->data_factor;
6185 case DW_CFA_val_offset:
6188 if (reg >= (unsigned int) fc->ncols)
6189 reg_prefix = bad_reg;
6190 if (! do_debug_frames_interp || *reg_prefix != '\0')
6191 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6192 reg_prefix, regname (reg, 0),
6193 roffs * fc->data_factor);
6194 if (*reg_prefix == '\0')
6196 fc->col_type[reg] = DW_CFA_val_offset;
6197 fc->col_offset[reg] = roffs * fc->data_factor;
6201 case DW_CFA_restore_extended:
6203 if (reg >= (unsigned int) cie->ncols
6204 || reg >= (unsigned int) fc->ncols)
6205 reg_prefix = bad_reg;
6206 if (! do_debug_frames_interp || *reg_prefix != '\0')
6207 printf (" DW_CFA_restore_extended: %s%s\n",
6208 reg_prefix, regname (reg, 0));
6209 if (*reg_prefix == '\0')
6211 fc->col_type[reg] = cie->col_type[reg];
6212 fc->col_offset[reg] = cie->col_offset[reg];
6216 case DW_CFA_undefined:
6218 if (reg >= (unsigned int) fc->ncols)
6219 reg_prefix = bad_reg;
6220 if (! do_debug_frames_interp || *reg_prefix != '\0')
6221 printf (" DW_CFA_undefined: %s%s\n",
6222 reg_prefix, regname (reg, 0));
6223 if (*reg_prefix == '\0')
6225 fc->col_type[reg] = DW_CFA_undefined;
6226 fc->col_offset[reg] = 0;
6230 case DW_CFA_same_value:
6232 if (reg >= (unsigned int) fc->ncols)
6233 reg_prefix = bad_reg;
6234 if (! do_debug_frames_interp || *reg_prefix != '\0')
6235 printf (" DW_CFA_same_value: %s%s\n",
6236 reg_prefix, regname (reg, 0));
6237 if (*reg_prefix == '\0')
6239 fc->col_type[reg] = DW_CFA_same_value;
6240 fc->col_offset[reg] = 0;
6244 case DW_CFA_register:
6247 if (reg >= (unsigned int) fc->ncols)
6248 reg_prefix = bad_reg;
6249 if (! do_debug_frames_interp || *reg_prefix != '\0')
6251 printf (" DW_CFA_register: %s%s in ",
6252 reg_prefix, regname (reg, 0));
6253 puts (regname (roffs, 0));
6255 if (*reg_prefix == '\0')
6257 fc->col_type[reg] = DW_CFA_register;
6258 fc->col_offset[reg] = roffs;
6262 case DW_CFA_remember_state:
6263 if (! do_debug_frames_interp)
6264 printf (" DW_CFA_remember_state\n");
6265 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6266 rs->cfa_offset = fc->cfa_offset;
6267 rs->cfa_reg = fc->cfa_reg;
6269 rs->cfa_exp = fc->cfa_exp;
6270 rs->ncols = fc->ncols;
6271 rs->col_type = (short int *) xcmalloc (rs->ncols,
6272 sizeof (* rs->col_type));
6273 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6274 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6275 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6276 rs->next = remembered_state;
6277 remembered_state = rs;
6280 case DW_CFA_restore_state:
6281 if (! do_debug_frames_interp)
6282 printf (" DW_CFA_restore_state\n");
6283 rs = remembered_state;
6286 remembered_state = rs->next;
6287 fc->cfa_offset = rs->cfa_offset;
6288 fc->cfa_reg = rs->cfa_reg;
6290 fc->cfa_exp = rs->cfa_exp;
6291 if (frame_need_space (fc, rs->ncols - 1) < 0)
6293 warn (_("Invalid column number in saved frame state\n"));
6297 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6298 memcpy (fc->col_offset, rs->col_offset,
6299 rs->ncols * sizeof (* rs->col_offset));
6300 free (rs->col_type);
6301 free (rs->col_offset);
6304 else if (do_debug_frames_interp)
6305 printf ("Mismatched DW_CFA_restore_state\n");
6308 case DW_CFA_def_cfa:
6309 fc->cfa_reg = LEB ();
6310 fc->cfa_offset = LEB ();
6312 if (! do_debug_frames_interp)
6313 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6314 regname (fc->cfa_reg, 0), fc->cfa_offset);
6317 case DW_CFA_def_cfa_register:
6318 fc->cfa_reg = LEB ();
6320 if (! do_debug_frames_interp)
6321 printf (" DW_CFA_def_cfa_register: %s\n",
6322 regname (fc->cfa_reg, 0));
6325 case DW_CFA_def_cfa_offset:
6326 fc->cfa_offset = LEB ();
6327 if (! do_debug_frames_interp)
6328 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6332 if (! do_debug_frames_interp)
6333 printf (" DW_CFA_nop\n");
6336 case DW_CFA_def_cfa_expression:
6338 if (start >= block_end || start + ul > block_end || start + ul < start)
6340 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6343 if (! do_debug_frames_interp)
6345 printf (" DW_CFA_def_cfa_expression (");
6346 decode_location_expression (start, eh_addr_size, 0, -1,
6354 case DW_CFA_expression:
6357 if (reg >= (unsigned int) fc->ncols)
6358 reg_prefix = bad_reg;
6359 /* PR 17512: file: 069-133014-0.006. */
6360 /* PR 17512: file: 98c02eb4. */
6361 if (start >= block_end || start + ul > block_end || start + ul < start)
6363 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6366 if (! do_debug_frames_interp || *reg_prefix != '\0')
6368 printf (" DW_CFA_expression: %s%s (",
6369 reg_prefix, regname (reg, 0));
6370 decode_location_expression (start, eh_addr_size, 0, -1,
6374 if (*reg_prefix == '\0')
6375 fc->col_type[reg] = DW_CFA_expression;
6379 case DW_CFA_val_expression:
6382 if (reg >= (unsigned int) fc->ncols)
6383 reg_prefix = bad_reg;
6384 if (start >= block_end || start + ul > block_end || start + ul < start)
6386 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6389 if (! do_debug_frames_interp || *reg_prefix != '\0')
6391 printf (" DW_CFA_val_expression: %s%s (",
6392 reg_prefix, regname (reg, 0));
6393 decode_location_expression (start, eh_addr_size, 0, -1,
6397 if (*reg_prefix == '\0')
6398 fc->col_type[reg] = DW_CFA_val_expression;
6402 case DW_CFA_offset_extended_sf:
6405 if (frame_need_space (fc, reg) < 0)
6406 reg_prefix = bad_reg;
6407 if (! do_debug_frames_interp || *reg_prefix != '\0')
6408 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6409 reg_prefix, regname (reg, 0),
6410 l * fc->data_factor);
6411 if (*reg_prefix == '\0')
6413 fc->col_type[reg] = DW_CFA_offset;
6414 fc->col_offset[reg] = l * fc->data_factor;
6418 case DW_CFA_val_offset_sf:
6421 if (frame_need_space (fc, reg) < 0)
6422 reg_prefix = bad_reg;
6423 if (! do_debug_frames_interp || *reg_prefix != '\0')
6424 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6425 reg_prefix, regname (reg, 0),
6426 l * fc->data_factor);
6427 if (*reg_prefix == '\0')
6429 fc->col_type[reg] = DW_CFA_val_offset;
6430 fc->col_offset[reg] = l * fc->data_factor;
6434 case DW_CFA_def_cfa_sf:
6435 fc->cfa_reg = LEB ();
6436 fc->cfa_offset = SLEB ();
6437 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6439 if (! do_debug_frames_interp)
6440 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6441 regname (fc->cfa_reg, 0), fc->cfa_offset);
6444 case DW_CFA_def_cfa_offset_sf:
6445 fc->cfa_offset = SLEB ();
6446 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6447 if (! do_debug_frames_interp)
6448 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
6451 case DW_CFA_MIPS_advance_loc8:
6452 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6453 if (do_debug_frames_interp)
6454 frame_display_row (fc, &need_col_headers, &max_regs);
6456 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6457 (unsigned long) (ofs * fc->code_factor),
6458 dwarf_vmatoa_1 (NULL,
6459 fc->pc_begin + ofs * fc->code_factor,
6461 fc->pc_begin += ofs * fc->code_factor;
6464 case DW_CFA_GNU_window_save:
6465 if (! do_debug_frames_interp)
6466 printf (" DW_CFA_GNU_window_save\n");
6469 case DW_CFA_GNU_args_size:
6471 if (! do_debug_frames_interp)
6472 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6475 case DW_CFA_GNU_negative_offset_extended:
6478 if (frame_need_space (fc, reg) < 0)
6479 reg_prefix = bad_reg;
6480 if (! do_debug_frames_interp || *reg_prefix != '\0')
6481 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6482 reg_prefix, regname (reg, 0),
6483 l * fc->data_factor);
6484 if (*reg_prefix == '\0')
6486 fc->col_type[reg] = DW_CFA_offset;
6487 fc->col_offset[reg] = l * fc->data_factor;
6492 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6493 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6495 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6500 if (do_debug_frames_interp)
6501 frame_display_row (fc, &need_col_headers, &max_regs);
6504 eh_addr_size = saved_eh_addr_size;
6517 display_gdb_index (struct dwarf_section *section,
6518 void *file ATTRIBUTE_UNUSED)
6520 unsigned char *start = section->start;
6522 uint32_t cu_list_offset, tu_list_offset;
6523 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6524 unsigned int cu_list_elements, tu_list_elements;
6525 unsigned int address_table_size, symbol_table_slots;
6526 unsigned char *cu_list, *tu_list;
6527 unsigned char *address_table, *symbol_table, *constant_pool;
6530 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6532 printf (_("Contents of the %s section:\n"), section->name);
6534 if (section->size < 6 * sizeof (uint32_t))
6536 warn (_("Truncated header in the %s section.\n"), section->name);
6540 version = byte_get_little_endian (start, 4);
6541 printf (_("Version %ld\n"), (long) version);
6543 /* Prior versions are obsolete, and future versions may not be
6544 backwards compatible. */
6545 if (version < 3 || version > 8)
6547 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6551 warn (_("The address table data in version 3 may be wrong.\n"));
6553 warn (_("Version 4 does not support case insensitive lookups.\n"));
6555 warn (_("Version 5 does not include inlined functions.\n"));
6557 warn (_("Version 6 does not include symbol attributes.\n"));
6558 /* Version 7 indices generated by Gold have bad type unit references,
6559 PR binutils/15021. But we don't know if the index was generated by
6560 Gold or not, so to avoid worrying users with gdb-generated indices
6561 we say nothing for version 7 here. */
6563 cu_list_offset = byte_get_little_endian (start + 4, 4);
6564 tu_list_offset = byte_get_little_endian (start + 8, 4);
6565 address_table_offset = byte_get_little_endian (start + 12, 4);
6566 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6567 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6569 if (cu_list_offset > section->size
6570 || tu_list_offset > section->size
6571 || address_table_offset > section->size
6572 || symbol_table_offset > section->size
6573 || constant_pool_offset > section->size)
6575 warn (_("Corrupt header in the %s section.\n"), section->name);
6579 /* PR 17531: file: 418d0a8a. */
6580 if (tu_list_offset < cu_list_offset)
6582 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6583 tu_list_offset, cu_list_offset);
6587 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6589 if (address_table_offset < tu_list_offset)
6591 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6592 address_table_offset, tu_list_offset);
6596 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6598 /* PR 17531: file: 18a47d3d. */
6599 if (symbol_table_offset < address_table_offset)
6601 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6602 symbol_table_offset, address_table_offset);
6606 address_table_size = symbol_table_offset - address_table_offset;
6608 if (constant_pool_offset < symbol_table_offset)
6610 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6611 constant_pool_offset, symbol_table_offset);
6615 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6617 cu_list = start + cu_list_offset;
6618 tu_list = start + tu_list_offset;
6619 address_table = start + address_table_offset;
6620 symbol_table = start + symbol_table_offset;
6621 constant_pool = start + constant_pool_offset;
6623 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6625 warn (_("Address table extends beyond end of section.\n"));
6629 printf (_("\nCU table:\n"));
6630 for (i = 0; i < cu_list_elements; i += 2)
6632 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6633 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6635 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6636 (unsigned long) cu_offset,
6637 (unsigned long) (cu_offset + cu_length - 1));
6640 printf (_("\nTU table:\n"));
6641 for (i = 0; i < tu_list_elements; i += 3)
6643 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6644 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6645 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6647 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6648 (unsigned long) tu_offset,
6649 (unsigned long) type_offset);
6650 print_dwarf_vma (signature, 8);
6654 printf (_("\nAddress table:\n"));
6655 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6658 uint64_t low = byte_get_little_endian (address_table + i, 8);
6659 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6660 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6662 print_dwarf_vma (low, 8);
6663 print_dwarf_vma (high, 8);
6664 printf (_("%lu\n"), (unsigned long) cu_index);
6667 printf (_("\nSymbol table:\n"));
6668 for (i = 0; i < symbol_table_slots; ++i)
6670 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6671 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6672 uint32_t num_cus, cu;
6674 if (name_offset != 0
6675 || cu_vector_offset != 0)
6679 /* PR 17531: file: 5b7b07ad. */
6680 if (constant_pool + name_offset < constant_pool
6681 || constant_pool + name_offset >= section->start + section->size)
6683 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6684 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6688 printf ("[%3u] %.*s:", i,
6689 (int) (section->size - (constant_pool_offset + name_offset)),
6690 constant_pool + name_offset);
6692 if (constant_pool + cu_vector_offset < constant_pool
6693 || constant_pool + cu_vector_offset >= section->start + section->size)
6695 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6696 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6697 cu_vector_offset, i);
6701 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
6703 if (num_cus * 4 < num_cus
6704 || constant_pool + cu_vector_offset + 4 + num_cus * 4 >=
6705 section->start + section->size)
6707 printf ("<invalid number of CUs: %d>\n", num_cus);
6708 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6715 for (j = 0; j < num_cus; ++j)
6718 gdb_index_symbol_kind kind;
6720 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6721 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6722 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6723 cu = GDB_INDEX_CU_VALUE (cu);
6724 /* Convert to TU number if it's for a type unit. */
6725 if (cu >= cu_list_elements / 2)
6726 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6727 (unsigned long) (cu - cu_list_elements / 2));
6729 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6731 printf (" [%s, %s]",
6732 is_static ? _("static") : _("global"),
6733 get_gdb_index_symbol_kind_name (kind));
6745 /* Pre-allocate enough space for the CU/TU sets needed. */
6748 prealloc_cu_tu_list (unsigned int nshndx)
6750 if (shndx_pool == NULL)
6752 shndx_pool_size = nshndx;
6753 shndx_pool_used = 0;
6754 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6755 sizeof (unsigned int));
6759 shndx_pool_size = shndx_pool_used + nshndx;
6760 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6761 sizeof (unsigned int));
6766 add_shndx_to_cu_tu_entry (unsigned int shndx)
6768 if (shndx_pool_used >= shndx_pool_size)
6770 error (_("Internal error: out of space in the shndx pool.\n"));
6773 shndx_pool [shndx_pool_used++] = shndx;
6777 end_cu_tu_entry (void)
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++] = 0;
6787 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6790 get_DW_SECT_short_name (unsigned int dw_sect)
6792 static char buf[16];
6800 case DW_SECT_ABBREV:
6806 case DW_SECT_STR_OFFSETS:
6808 case DW_SECT_MACINFO:
6816 snprintf (buf, sizeof (buf), "%d", dw_sect);
6820 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6821 These sections are extensions for Fission.
6822 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6825 process_cu_tu_index (struct dwarf_section *section, int do_display)
6827 unsigned char *phdr = section->start;
6828 unsigned char *limit = phdr + section->size;
6829 unsigned char *phash;
6830 unsigned char *pindex;
6831 unsigned char *ppool;
6832 unsigned int version;
6833 unsigned int ncols = 0;
6835 unsigned int nslots;
6838 dwarf_vma signature_high;
6839 dwarf_vma signature_low;
6842 /* PR 17512: file: 002-168123-0.004. */
6845 warn (_("Section %s is empty\n"), section->name);
6848 /* PR 17512: file: 002-376-0.004. */
6849 if (section->size < 24)
6851 warn (_("Section %s is too small to contain a CU/TU header\n"),
6856 SAFE_BYTE_GET (version, phdr, 4, limit);
6858 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6859 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6860 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6863 pindex = phash + nslots * 8;
6864 ppool = pindex + nslots * 4;
6868 printf (_("Contents of the %s section:\n\n"), section->name);
6869 printf (_(" Version: %d\n"), version);
6871 printf (_(" Number of columns: %d\n"), ncols);
6872 printf (_(" Number of used entries: %d\n"), nused);
6873 printf (_(" Number of slots: %d\n\n"), nslots);
6878 warn (_("Section %s too small for %d hash table entries\n"),
6879 section->name, nslots);
6886 prealloc_cu_tu_list ((limit - ppool) / 4);
6887 for (i = 0; i < nslots; i++)
6889 unsigned char *shndx_list;
6892 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
6893 if (signature_high != 0 || signature_low != 0)
6895 SAFE_BYTE_GET (j, pindex, 4, limit);
6896 shndx_list = ppool + j * 4;
6898 printf (_(" [%3d] Signature: 0x%s Sections: "),
6899 i, dwarf_vmatoa64 (signature_high, signature_low,
6900 buf, sizeof (buf)));
6903 if (shndx_list >= limit)
6905 warn (_("Section %s too small for shndx pool\n"),
6909 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
6913 printf (" %d", shndx);
6915 add_shndx_to_cu_tu_entry (shndx);
6927 else if (version == 2)
6930 unsigned int dw_sect;
6931 unsigned char *ph = phash;
6932 unsigned char *pi = pindex;
6933 unsigned char *poffsets = ppool + ncols * 4;
6934 unsigned char *psizes = poffsets + nused * ncols * 4;
6935 unsigned char *pend = psizes + nused * ncols * 4;
6936 bfd_boolean is_tu_index;
6937 struct cu_tu_set *this_set = NULL;
6939 unsigned char *prow;
6941 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
6945 warn (_("Section %s too small for offset and size tables\n"),
6952 printf (_(" Offset table\n"));
6953 printf (" slot %-16s ",
6954 is_tu_index ? _("signature") : _("dwo_id"));
6961 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
6967 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
6974 for (j = 0; j < ncols; j++)
6976 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
6977 printf (" %8s", get_DW_SECT_short_name (dw_sect));
6982 for (i = 0; i < nslots; i++)
6984 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
6986 SAFE_BYTE_GET (row, pi, 4, limit);
6989 /* PR 17531: file: a05f6ab3. */
6992 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
6998 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7000 prow = poffsets + (row - 1) * ncols * 4;
7003 printf (_(" [%3d] 0x%s"),
7004 i, dwarf_vmatoa64 (signature_high, signature_low,
7005 buf, sizeof (buf)));
7006 for (j = 0; j < ncols; j++)
7008 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7010 printf (" %8d", val);
7013 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7015 /* PR 17531: file: 10796eb3. */
7016 if (dw_sect >= DW_SECT_MAX)
7017 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7019 this_set [row - 1].section_offsets [dw_sect] = val;
7035 printf (_(" Size table\n"));
7036 printf (" slot %-16s ",
7037 is_tu_index ? _("signature") : _("dwo_id"));
7040 for (j = 0; j < ncols; j++)
7042 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7044 printf (" %8s", get_DW_SECT_short_name (val));
7050 for (i = 0; i < nslots; i++)
7052 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7054 SAFE_BYTE_GET (row, pi, 4, limit);
7057 prow = psizes + (row - 1) * ncols * 4;
7060 printf (_(" [%3d] 0x%s"),
7061 i, dwarf_vmatoa64 (signature_high, signature_low,
7062 buf, sizeof (buf)));
7064 for (j = 0; j < ncols; j++)
7066 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7068 printf (" %8d", val);
7071 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7072 if (dw_sect >= DW_SECT_MAX)
7073 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7075 this_set [row - 1].section_sizes [dw_sect] = val;
7087 else if (do_display)
7088 printf (_(" Unsupported version (%d)\n"), version);
7096 /* Load the CU and TU indexes if present. This will build a list of
7097 section sets that we can use to associate a .debug_info.dwo section
7098 with its associated .debug_abbrev.dwo section in a .dwp file. */
7101 load_cu_tu_indexes (void *file)
7103 /* If we have already loaded (or tried to load) the CU and TU indexes
7104 then do not bother to repeat the task. */
7105 if (cu_tu_indexes_read)
7108 if (load_debug_section (dwp_cu_index, file))
7109 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7111 if (load_debug_section (dwp_tu_index, file))
7112 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7114 cu_tu_indexes_read = 1;
7117 /* Find the set of sections that includes section SHNDX. */
7120 find_cu_tu_set (void *file, unsigned int shndx)
7124 load_cu_tu_indexes (file);
7126 /* Find SHNDX in the shndx pool. */
7127 for (i = 0; i < shndx_pool_used; i++)
7128 if (shndx_pool [i] == shndx)
7131 if (i >= shndx_pool_used)
7134 /* Now backup to find the first entry in the set. */
7135 while (i > 0 && shndx_pool [i - 1] != 0)
7138 return shndx_pool + i;
7141 /* Display a .debug_cu_index or .debug_tu_index section. */
7144 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7146 return process_cu_tu_index (section, 1);
7150 display_debug_not_supported (struct dwarf_section *section,
7151 void *file ATTRIBUTE_UNUSED)
7153 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7159 /* Like malloc, but takes two parameters like calloc.
7160 Verifies that the first parameter is not too large.
7161 Note: does *not* initialise the allocated memory to zero. */
7163 cmalloc (size_t nmemb, size_t size)
7165 /* Check for overflow. */
7166 if (nmemb >= ~(size_t) 0 / size)
7169 return xmalloc (nmemb * size);
7172 /* Like xmalloc, but takes two parameters like calloc.
7173 Verifies that the first parameter is not too large.
7174 Note: does *not* initialise the allocated memory to zero. */
7176 xcmalloc (size_t nmemb, size_t size)
7178 /* Check for overflow. */
7179 if (nmemb >= ~(size_t) 0 / size)
7182 return xmalloc (nmemb * size);
7185 /* Like xrealloc, but takes three parameters.
7186 Verifies that the second parameter is not too large.
7187 Note: does *not* initialise any new memory to zero. */
7189 xcrealloc (void *ptr, size_t nmemb, size_t size)
7191 /* Check for overflow. */
7192 if (nmemb >= ~(size_t) 0 / size)
7195 return xrealloc (ptr, nmemb * size);
7198 /* Like xcalloc, but verifies that the first parameter is not too large. */
7200 xcalloc2 (size_t nmemb, size_t size)
7202 /* Check for overflow. */
7203 if (nmemb >= ~(size_t) 0 / size)
7206 return xcalloc (nmemb, size);
7210 free_debug_memory (void)
7216 for (i = 0; i < max; i++)
7217 free_debug_section ((enum dwarf_section_display_enum) i);
7219 if (debug_information != NULL)
7221 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7223 for (i = 0; i < num_debug_info_entries; i++)
7225 if (!debug_information [i].max_loc_offsets)
7227 free (debug_information [i].loc_offsets);
7228 free (debug_information [i].have_frame_base);
7230 if (!debug_information [i].max_range_lists)
7231 free (debug_information [i].range_lists);
7234 free (debug_information);
7235 debug_information = NULL;
7236 alloc_num_debug_info_entries = num_debug_info_entries = 0;
7241 dwarf_select_sections_by_names (const char *names)
7245 const char * option;
7249 debug_dump_long_opts;
7251 static const debug_dump_long_opts opts_table [] =
7253 /* Please keep this table alpha- sorted. */
7254 { "Ranges", & do_debug_ranges, 1 },
7255 { "abbrev", & do_debug_abbrevs, 1 },
7256 { "addr", & do_debug_addr, 1 },
7257 { "aranges", & do_debug_aranges, 1 },
7258 { "cu_index", & do_debug_cu_index, 1 },
7259 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7260 { "frames", & do_debug_frames, 1 },
7261 { "frames-interp", & do_debug_frames_interp, 1 },
7262 /* The special .gdb_index section. */
7263 { "gdb_index", & do_gdb_index, 1 },
7264 { "info", & do_debug_info, 1 },
7265 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
7266 { "loc", & do_debug_loc, 1 },
7267 { "macro", & do_debug_macinfo, 1 },
7268 { "pubnames", & do_debug_pubnames, 1 },
7269 { "pubtypes", & do_debug_pubtypes, 1 },
7270 /* This entry is for compatability
7271 with earlier versions of readelf. */
7272 { "ranges", & do_debug_aranges, 1 },
7273 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7274 { "str", & do_debug_str, 1 },
7275 /* These trace_* sections are used by Itanium VMS. */
7276 { "trace_abbrev", & do_trace_abbrevs, 1 },
7277 { "trace_aranges", & do_trace_aranges, 1 },
7278 { "trace_info", & do_trace_info, 1 },
7287 const debug_dump_long_opts * entry;
7289 for (entry = opts_table; entry->option; entry++)
7291 size_t len = strlen (entry->option);
7293 if (strncmp (p, entry->option, len) == 0
7294 && (p[len] == ',' || p[len] == '\0'))
7296 * entry->variable |= entry->val;
7298 /* The --debug-dump=frames-interp option also
7299 enables the --debug-dump=frames option. */
7300 if (do_debug_frames_interp)
7301 do_debug_frames = 1;
7308 if (entry->option == NULL)
7310 warn (_("Unrecognized debug option '%s'\n"), p);
7311 p = strchr (p, ',');
7322 dwarf_select_sections_by_letters (const char *letters)
7324 unsigned int lindex = 0;
7326 while (letters[lindex])
7327 switch (letters[lindex++])
7334 do_debug_abbrevs = 1;
7338 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7342 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7346 do_debug_pubnames = 1;
7350 do_debug_pubtypes = 1;
7354 do_debug_aranges = 1;
7358 do_debug_ranges = 1;
7362 do_debug_frames_interp = 1;
7364 do_debug_frames = 1;
7368 do_debug_macinfo = 1;
7380 warn (_("Unrecognized debug option '%s'\n"), optarg);
7386 dwarf_select_sections_all (void)
7389 do_debug_abbrevs = 1;
7390 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7391 do_debug_pubnames = 1;
7392 do_debug_pubtypes = 1;
7393 do_debug_aranges = 1;
7394 do_debug_ranges = 1;
7395 do_debug_frames = 1;
7396 do_debug_macinfo = 1;
7401 do_trace_abbrevs = 1;
7402 do_trace_aranges = 1;
7404 do_debug_cu_index = 1;
7407 struct dwarf_section_display debug_displays[] =
7409 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL },
7410 display_debug_abbrev, &do_debug_abbrevs, 0 },
7411 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL },
7412 display_debug_aranges, &do_debug_aranges, 1 },
7413 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL },
7414 display_debug_frames, &do_debug_frames, 1 },
7415 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL },
7416 display_debug_info, &do_debug_info, 1 },
7417 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL },
7418 display_debug_lines, &do_debug_lines, 1 },
7419 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
7420 display_debug_pubnames, &do_debug_pubnames, 0 },
7421 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
7422 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7423 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL },
7424 display_debug_frames, &do_debug_frames, 1 },
7425 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL },
7426 display_debug_macinfo, &do_debug_macinfo, 0 },
7427 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL },
7428 display_debug_macro, &do_debug_macinfo, 1 },
7429 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL },
7430 display_debug_str, &do_debug_str, 0 },
7431 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL },
7432 display_debug_loc, &do_debug_loc, 1 },
7433 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7434 display_debug_pubnames, &do_debug_pubtypes, 0 },
7435 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7436 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7437 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL },
7438 display_debug_ranges, &do_debug_ranges, 1 },
7439 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
7440 display_debug_not_supported, NULL, 0 },
7441 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
7442 display_debug_not_supported, NULL, 0 },
7443 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL },
7444 display_debug_types, &do_debug_info, 1 },
7445 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
7446 display_debug_not_supported, NULL, 0 },
7447 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL },
7448 display_gdb_index, &do_gdb_index, 0 },
7449 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL },
7450 display_trace_info, &do_trace_info, 1 },
7451 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL },
7452 display_debug_abbrev, &do_trace_abbrevs, 0 },
7453 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL },
7454 display_debug_aranges, &do_trace_aranges, 0 },
7455 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7456 display_debug_info, &do_debug_info, 1 },
7457 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
7458 display_debug_abbrev, &do_debug_abbrevs, 0 },
7459 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7460 display_debug_types, &do_debug_info, 1 },
7461 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
7462 display_debug_lines, &do_debug_lines, 1 },
7463 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL },
7464 display_debug_loc, &do_debug_loc, 1 },
7465 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
7466 display_debug_macro, &do_debug_macinfo, 1 },
7467 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
7468 display_debug_macinfo, &do_debug_macinfo, 0 },
7469 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL },
7470 display_debug_str, &do_debug_str, 1 },
7471 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
7472 display_debug_str_offsets, NULL, 0 },
7473 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
7474 display_debug_str_offsets, NULL, 0 },
7475 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL },
7476 display_debug_addr, &do_debug_addr, 1 },
7477 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL },
7478 display_cu_index, &do_debug_cu_index, 0 },
7479 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL },
7480 display_cu_index, &do_debug_cu_index, 0 },