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
47 unsigned int eh_addr_size;
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)
285 /* PR 17512: file: 0ca183b8.
286 FIXME: Should we signal this error somehow ? */
287 if (shift >= sizeof (result) * 8)
291 if (length_return != NULL)
292 *length_return = num_read;
294 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
295 result |= (dwarf_vma) -1 << shift;
300 /* Create a signed version to avoid painful typecasts. */
301 static inline dwarf_signed_vma
302 read_sleb128 (unsigned char * data,
303 unsigned int * length_return,
304 const unsigned char * const end)
306 return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
309 static inline dwarf_vma
310 read_uleb128 (unsigned char * data,
311 unsigned int * length_return,
312 const unsigned char * const end)
314 return read_leb128 (data, length_return, FALSE, end);
317 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
320 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
321 unsigned int amount = (AMOUNT); \
322 if (((PTR) + amount) >= (END)) \
325 amount = (END) - (PTR); \
329 if (amount == 0 || amount > 8) \
332 VAL = byte_get ((PTR), amount); \
336 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
339 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
344 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
347 unsigned int amount = (AMOUNT); \
348 if (((PTR) + amount) >= (END)) \
351 amount = (END) - (PTR); \
356 VAL = byte_get_signed ((PTR), amount); \
362 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
365 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
370 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
373 if (((PTR) + 8) <= (END)) \
375 byte_get_64 ((PTR), (HIGH), (LOW)); \
379 * (LOW) = * (HIGH) = 0; \
384 typedef struct State_Machine_Registers
392 unsigned char op_index;
393 unsigned char end_sequence;
394 /* This variable hold the number of the last entry seen
395 in the File Table. */
396 unsigned int last_file_entry;
399 static SMR state_machine_regs;
402 reset_state_machine (int is_stmt)
404 state_machine_regs.address = 0;
405 state_machine_regs.op_index = 0;
406 state_machine_regs.file = 1;
407 state_machine_regs.line = 1;
408 state_machine_regs.column = 0;
409 state_machine_regs.is_stmt = is_stmt;
410 state_machine_regs.basic_block = 0;
411 state_machine_regs.end_sequence = 0;
412 state_machine_regs.last_file_entry = 0;
415 /* Handled an extend line op.
416 Returns the number of bytes read. */
419 process_extended_line_op (unsigned char * data,
423 unsigned char op_code;
424 unsigned int bytes_read;
427 unsigned char *orig_data = data;
430 len = read_uleb128 (data, & bytes_read, end);
433 if (len == 0 || data == end || len > (uintptr_t) (end - data))
435 warn (_("Badly formed extended line op encountered!\n"));
442 printf (_(" Extended opcode %d: "), op_code);
446 case DW_LNE_end_sequence:
447 printf (_("End of Sequence\n\n"));
448 reset_state_machine (is_stmt);
451 case DW_LNE_set_address:
452 /* PR 17512: file: 002-100480-0.004. */
453 if (len - bytes_read - 1 > 8)
455 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
456 len - bytes_read - 1);
460 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
461 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
462 state_machine_regs.address = adr;
463 state_machine_regs.op_index = 0;
466 case DW_LNE_define_file:
467 printf (_("define new File Table entry\n"));
468 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
469 printf (" %d\t", ++state_machine_regs.last_file_entry);
472 data += strnlen ((char *) data, end - data) + 1;
473 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
475 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
477 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
479 printf ("%s\n\n", name);
481 if (((unsigned int) (data - orig_data) != len) || data == end)
482 warn (_("DW_LNE_define_file: Bad opcode length\n"));
485 case DW_LNE_set_discriminator:
486 printf (_("set Discriminator to %s\n"),
487 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
491 case DW_LNE_HP_negate_is_UV_update:
492 printf ("DW_LNE_HP_negate_is_UV_update\n");
494 case DW_LNE_HP_push_context:
495 printf ("DW_LNE_HP_push_context\n");
497 case DW_LNE_HP_pop_context:
498 printf ("DW_LNE_HP_pop_context\n");
500 case DW_LNE_HP_set_file_line_column:
501 printf ("DW_LNE_HP_set_file_line_column\n");
503 case DW_LNE_HP_set_routine_name:
504 printf ("DW_LNE_HP_set_routine_name\n");
506 case DW_LNE_HP_set_sequence:
507 printf ("DW_LNE_HP_set_sequence\n");
509 case DW_LNE_HP_negate_post_semantics:
510 printf ("DW_LNE_HP_negate_post_semantics\n");
512 case DW_LNE_HP_negate_function_exit:
513 printf ("DW_LNE_HP_negate_function_exit\n");
515 case DW_LNE_HP_negate_front_end_logical:
516 printf ("DW_LNE_HP_negate_front_end_logical\n");
518 case DW_LNE_HP_define_proc:
519 printf ("DW_LNE_HP_define_proc\n");
521 case DW_LNE_HP_source_file_correlation:
523 unsigned char *edata = data + len - bytes_read - 1;
525 printf ("DW_LNE_HP_source_file_correlation\n");
531 opc = read_uleb128 (data, & bytes_read, edata);
536 case DW_LNE_HP_SFC_formfeed:
537 printf (" DW_LNE_HP_SFC_formfeed\n");
539 case DW_LNE_HP_SFC_set_listing_line:
540 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
542 read_uleb128 (data, & bytes_read, edata)));
545 case DW_LNE_HP_SFC_associate:
546 printf (" DW_LNE_HP_SFC_associate ");
549 read_uleb128 (data, & bytes_read, edata)));
553 read_uleb128 (data, & bytes_read, edata)));
557 read_uleb128 (data, & bytes_read, edata)));
561 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
571 unsigned int rlen = len - bytes_read - 1;
573 if (op_code >= DW_LNE_lo_user
574 /* The test against DW_LNW_hi_user is redundant due to
575 the limited range of the unsigned char data type used
577 /*&& op_code <= DW_LNE_hi_user*/)
578 printf (_("user defined: "));
580 printf (_("UNKNOWN: "));
581 printf (_("length %d ["), rlen);
583 printf (" %02x", *data++);
592 static const unsigned char *
593 fetch_indirect_string (dwarf_vma offset)
595 struct dwarf_section *section = &debug_displays [str].section;
597 if (section->start == NULL)
598 return (const unsigned char *) _("<no .debug_str section>");
600 if (offset > section->size)
602 warn (_("DW_FORM_strp offset too big: %s\n"),
603 dwarf_vmatoa ("x", offset));
604 return (const unsigned char *) _("<offset is too big>");
607 return (const unsigned char *) section->start + offset;
611 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
612 dwarf_vma offset_size, int dwo)
614 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
615 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
616 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
617 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
618 dwarf_vma index_offset = idx * offset_size;
619 dwarf_vma str_offset;
621 if (index_section->start == NULL)
622 return (dwo ? _("<no .debug_str_offsets.dwo section>")
623 : _("<no .debug_str_offsets section>"));
625 if (this_set != NULL)
626 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
627 if (index_offset > index_section->size)
629 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
630 dwarf_vmatoa ("x", index_offset));
631 return _("<index offset is too big>");
634 if (str_section->start == NULL)
635 return (dwo ? _("<no .debug_str.dwo section>")
636 : _("<no .debug_str section>"));
638 str_offset = byte_get (index_section->start + index_offset, offset_size);
639 str_offset -= str_section->address;
640 if (str_offset > str_section->size)
642 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
643 dwarf_vmatoa ("x", str_offset));
644 return _("<indirect index offset is too big>");
647 return (const char *) str_section->start + str_offset;
651 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
653 struct dwarf_section *section = &debug_displays [debug_addr].section;
655 if (section->start == NULL)
656 return (_("<no .debug_addr section>"));
658 if (offset + bytes > section->size)
660 warn (_("Offset into section %s too big: %s\n"),
661 section->name, dwarf_vmatoa ("x", offset));
662 return "<offset too big>";
665 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
669 /* FIXME: There are better and more efficient ways to handle
670 these structures. For now though, I just want something that
671 is simple to implement. */
672 typedef struct abbrev_attr
674 unsigned long attribute;
676 struct abbrev_attr *next;
680 typedef struct abbrev_entry
685 struct abbrev_attr *first_attr;
686 struct abbrev_attr *last_attr;
687 struct abbrev_entry *next;
691 static abbrev_entry *first_abbrev = NULL;
692 static abbrev_entry *last_abbrev = NULL;
699 for (abbrv = first_abbrev; abbrv;)
701 abbrev_entry *next_abbrev = abbrv->next;
704 for (attr = abbrv->first_attr; attr;)
706 abbrev_attr *next_attr = attr->next;
716 last_abbrev = first_abbrev = NULL;
720 add_abbrev (unsigned long number, unsigned long tag, int children)
724 entry = (abbrev_entry *) malloc (sizeof (*entry));
729 entry->entry = number;
731 entry->children = children;
732 entry->first_attr = NULL;
733 entry->last_attr = NULL;
736 if (first_abbrev == NULL)
737 first_abbrev = entry;
739 last_abbrev->next = entry;
745 add_abbrev_attr (unsigned long attribute, unsigned long form)
749 attr = (abbrev_attr *) malloc (sizeof (*attr));
754 attr->attribute = attribute;
758 if (last_abbrev->first_attr == NULL)
759 last_abbrev->first_attr = attr;
761 last_abbrev->last_attr->next = attr;
763 last_abbrev->last_attr = attr;
766 /* Processes the (partial) contents of a .debug_abbrev section.
767 Returns NULL if the end of the section was encountered.
768 Returns the address after the last byte read if the end of
769 an abbreviation set was found. */
771 static unsigned char *
772 process_abbrev_section (unsigned char *start, unsigned char *end)
774 if (first_abbrev != NULL)
779 unsigned int bytes_read;
782 unsigned long attribute;
785 entry = read_uleb128 (start, & bytes_read, end);
788 /* A single zero is supposed to end the section according
789 to the standard. If there's more, then signal that to
796 tag = read_uleb128 (start, & bytes_read, end);
803 add_abbrev (entry, tag, children);
809 attribute = read_uleb128 (start, & bytes_read, end);
814 form = read_uleb128 (start, & bytes_read, end);
819 add_abbrev_attr (attribute, form);
821 while (attribute != 0);
824 /* Report the missing single zero which ends the section. */
825 error (_(".debug_abbrev section not zero terminated\n"));
831 get_TAG_name (unsigned long tag)
833 const char *name = get_DW_TAG_name ((unsigned int)tag);
837 static char buffer[100];
839 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
847 get_FORM_name (unsigned long form)
852 return "DW_FORM value: 0";
854 name = get_DW_FORM_name (form);
857 static char buffer[100];
859 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
866 static unsigned char *
867 display_block (unsigned char *data,
869 const unsigned char * const end)
873 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
875 return (unsigned char *) end;
877 maxlen = (dwarf_vma) (end - data);
878 length = length > maxlen ? maxlen : length;
881 printf ("%lx ", (unsigned long) byte_get (data++, 1));
887 decode_location_expression (unsigned char * data,
888 unsigned int pointer_size,
889 unsigned int offset_size,
893 struct dwarf_section * section)
896 unsigned int bytes_read;
898 dwarf_signed_vma svalue;
899 unsigned char *end = data + length;
900 int need_frame_base = 0;
909 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
910 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
913 printf ("DW_OP_deref");
916 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
917 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
920 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
921 printf ("DW_OP_const1s: %ld", (long) svalue);
924 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
925 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
928 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
929 printf ("DW_OP_const2s: %ld", (long) svalue);
932 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
933 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
936 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
937 printf ("DW_OP_const4s: %ld", (long) svalue);
940 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
941 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
942 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
943 printf ("%lu", (unsigned long) uvalue);
946 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
947 printf ("DW_OP_const8s: %ld ", (long) svalue);
948 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
949 printf ("%ld", (long) svalue);
952 printf ("DW_OP_constu: %s",
953 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
957 printf ("DW_OP_consts: %s",
958 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
962 printf ("DW_OP_dup");
965 printf ("DW_OP_drop");
968 printf ("DW_OP_over");
971 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
972 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
975 printf ("DW_OP_swap");
978 printf ("DW_OP_rot");
981 printf ("DW_OP_xderef");
984 printf ("DW_OP_abs");
987 printf ("DW_OP_and");
990 printf ("DW_OP_div");
993 printf ("DW_OP_minus");
996 printf ("DW_OP_mod");
999 printf ("DW_OP_mul");
1002 printf ("DW_OP_neg");
1005 printf ("DW_OP_not");
1008 printf ("DW_OP_or");
1011 printf ("DW_OP_plus");
1013 case DW_OP_plus_uconst:
1014 printf ("DW_OP_plus_uconst: %s",
1015 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1019 printf ("DW_OP_shl");
1022 printf ("DW_OP_shr");
1025 printf ("DW_OP_shra");
1028 printf ("DW_OP_xor");
1031 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1032 printf ("DW_OP_bra: %ld", (long) svalue);
1035 printf ("DW_OP_eq");
1038 printf ("DW_OP_ge");
1041 printf ("DW_OP_gt");
1044 printf ("DW_OP_le");
1047 printf ("DW_OP_lt");
1050 printf ("DW_OP_ne");
1053 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1054 printf ("DW_OP_skip: %ld", (long) svalue);
1089 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1124 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1125 regname (op - DW_OP_reg0, 1));
1160 printf ("DW_OP_breg%d (%s): %s",
1162 regname (op - DW_OP_breg0, 1),
1163 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1168 uvalue = read_uleb128 (data, &bytes_read, end);
1170 printf ("DW_OP_regx: %s (%s)",
1171 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1174 need_frame_base = 1;
1175 printf ("DW_OP_fbreg: %s",
1176 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1180 uvalue = read_uleb128 (data, &bytes_read, end);
1182 printf ("DW_OP_bregx: %s (%s) %s",
1183 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1184 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1188 printf ("DW_OP_piece: %s",
1189 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1192 case DW_OP_deref_size:
1193 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1194 printf ("DW_OP_deref_size: %ld", (long) uvalue);
1196 case DW_OP_xderef_size:
1197 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1198 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1201 printf ("DW_OP_nop");
1204 /* DWARF 3 extensions. */
1205 case DW_OP_push_object_address:
1206 printf ("DW_OP_push_object_address");
1209 /* XXX: Strictly speaking for 64-bit DWARF3 files
1210 this ought to be an 8-byte wide computation. */
1211 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1212 printf ("DW_OP_call2: <0x%s>",
1213 dwarf_vmatoa ("x", svalue + cu_offset));
1216 /* XXX: Strictly speaking for 64-bit DWARF3 files
1217 this ought to be an 8-byte wide computation. */
1218 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1219 printf ("DW_OP_call4: <0x%s>",
1220 dwarf_vmatoa ("x", svalue + cu_offset));
1222 case DW_OP_call_ref:
1223 /* XXX: Strictly speaking for 64-bit DWARF3 files
1224 this ought to be an 8-byte wide computation. */
1225 if (dwarf_version == -1)
1227 printf (_("(DW_OP_call_ref in frame info)"));
1228 /* No way to tell where the next op is, so just bail. */
1229 return need_frame_base;
1231 if (dwarf_version == 2)
1233 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1237 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1239 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1241 case DW_OP_form_tls_address:
1242 printf ("DW_OP_form_tls_address");
1244 case DW_OP_call_frame_cfa:
1245 printf ("DW_OP_call_frame_cfa");
1247 case DW_OP_bit_piece:
1248 printf ("DW_OP_bit_piece: ");
1249 printf (_("size: %s "),
1250 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1252 printf (_("offset: %s "),
1253 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1257 /* DWARF 4 extensions. */
1258 case DW_OP_stack_value:
1259 printf ("DW_OP_stack_value");
1262 case DW_OP_implicit_value:
1263 printf ("DW_OP_implicit_value");
1264 uvalue = read_uleb128 (data, &bytes_read, end);
1266 data = display_block (data, uvalue, end);
1269 /* GNU extensions. */
1270 case DW_OP_GNU_push_tls_address:
1271 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1273 case DW_OP_GNU_uninit:
1274 printf ("DW_OP_GNU_uninit");
1275 /* FIXME: Is there data associated with this OP ? */
1277 case DW_OP_GNU_encoded_addr:
1284 addr = get_encoded_value (&data, encoding, section, end);
1286 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1287 print_dwarf_vma (addr, pointer_size);
1290 case DW_OP_GNU_implicit_pointer:
1291 /* XXX: Strictly speaking for 64-bit DWARF3 files
1292 this ought to be an 8-byte wide computation. */
1293 if (dwarf_version == -1)
1295 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1296 /* No way to tell where the next op is, so just bail. */
1297 return need_frame_base;
1299 if (dwarf_version == 2)
1301 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1305 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1307 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1308 dwarf_vmatoa ("x", uvalue),
1309 dwarf_vmatoa ("d", read_sleb128 (data,
1310 &bytes_read, end)));
1313 case DW_OP_GNU_entry_value:
1314 uvalue = read_uleb128 (data, &bytes_read, end);
1316 /* PR 17531: file: 0cc9cd00. */
1317 if (uvalue > (dwarf_vma) (end - data))
1318 uvalue = end - data;
1319 printf ("DW_OP_GNU_entry_value: (");
1320 if (decode_location_expression (data, pointer_size, offset_size,
1321 dwarf_version, uvalue,
1322 cu_offset, section))
1323 need_frame_base = 1;
1329 case DW_OP_GNU_const_type:
1330 uvalue = read_uleb128 (data, &bytes_read, end);
1332 printf ("DW_OP_GNU_const_type: <0x%s> ",
1333 dwarf_vmatoa ("x", cu_offset + uvalue));
1334 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1335 data = display_block (data, uvalue, end);
1337 case DW_OP_GNU_regval_type:
1338 uvalue = read_uleb128 (data, &bytes_read, end);
1340 printf ("DW_OP_GNU_regval_type: %s (%s)",
1341 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1342 uvalue = read_uleb128 (data, &bytes_read, end);
1344 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1346 case DW_OP_GNU_deref_type:
1347 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1348 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue);
1349 uvalue = read_uleb128 (data, &bytes_read, end);
1351 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1353 case DW_OP_GNU_convert:
1354 uvalue = read_uleb128 (data, &bytes_read, end);
1356 printf ("DW_OP_GNU_convert <0x%s>",
1357 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1359 case DW_OP_GNU_reinterpret:
1360 uvalue = read_uleb128 (data, &bytes_read, end);
1362 printf ("DW_OP_GNU_reinterpret <0x%s>",
1363 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1365 case DW_OP_GNU_parameter_ref:
1366 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1367 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1368 dwarf_vmatoa ("x", cu_offset + uvalue));
1370 case DW_OP_GNU_addr_index:
1371 uvalue = read_uleb128 (data, &bytes_read, end);
1373 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1375 case DW_OP_GNU_const_index:
1376 uvalue = read_uleb128 (data, &bytes_read, end);
1378 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1381 /* HP extensions. */
1382 case DW_OP_HP_is_value:
1383 printf ("DW_OP_HP_is_value");
1384 /* FIXME: Is there data associated with this OP ? */
1386 case DW_OP_HP_fltconst4:
1387 printf ("DW_OP_HP_fltconst4");
1388 /* FIXME: Is there data associated with this OP ? */
1390 case DW_OP_HP_fltconst8:
1391 printf ("DW_OP_HP_fltconst8");
1392 /* FIXME: Is there data associated with this OP ? */
1394 case DW_OP_HP_mod_range:
1395 printf ("DW_OP_HP_mod_range");
1396 /* FIXME: Is there data associated with this OP ? */
1398 case DW_OP_HP_unmod_range:
1399 printf ("DW_OP_HP_unmod_range");
1400 /* FIXME: Is there data associated with this OP ? */
1403 printf ("DW_OP_HP_tls");
1404 /* FIXME: Is there data associated with this OP ? */
1407 /* PGI (STMicroelectronics) extensions. */
1408 case DW_OP_PGI_omp_thread_num:
1409 /* Pushes the thread number for the current thread as it would be
1410 returned by the standard OpenMP library function:
1411 omp_get_thread_num(). The "current thread" is the thread for
1412 which the expression is being evaluated. */
1413 printf ("DW_OP_PGI_omp_thread_num");
1417 if (op >= DW_OP_lo_user
1418 && op <= DW_OP_hi_user)
1419 printf (_("(User defined location op)"));
1421 printf (_("(Unknown location op)"));
1422 /* No way to tell where the next op is, so just bail. */
1423 return need_frame_base;
1426 /* Separate the ops. */
1431 return need_frame_base;
1434 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1435 This is used for DWARF package files. */
1437 static struct cu_tu_set *
1438 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1440 struct cu_tu_set *p;
1442 unsigned int dw_sect;
1448 dw_sect = DW_SECT_TYPES;
1454 dw_sect = DW_SECT_INFO;
1458 if (p->section_offsets [dw_sect] == cu_offset)
1466 /* Add INC to HIGH_BITS:LOW_BITS. */
1468 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1470 dwarf_vma tmp = * low_bits;
1474 /* FIXME: There is probably a better way of handling this:
1476 We need to cope with dwarf_vma being a 32-bit or 64-bit
1477 type. Plus regardless of its size LOW_BITS is meant to
1478 only hold 32-bits, so if there is overflow or wrap around
1479 we must propagate into HIGH_BITS. */
1480 if (tmp < * low_bits)
1484 else if (sizeof (tmp) > 8
1494 static unsigned char *
1495 read_and_display_attr_value (unsigned long attribute,
1497 unsigned char * data,
1498 unsigned char * end,
1499 dwarf_vma cu_offset,
1500 dwarf_vma pointer_size,
1501 dwarf_vma offset_size,
1503 debug_info * debug_info_p,
1505 struct dwarf_section * section,
1506 struct cu_tu_set * this_set)
1508 dwarf_vma uvalue = 0;
1509 unsigned char *block_start = NULL;
1510 unsigned char * orig_data = data;
1511 unsigned int bytes_read;
1513 if (data > end || (data == end && form != DW_FORM_flag_present))
1515 warn (_("Corrupt attribute\n"));
1524 case DW_FORM_ref_addr:
1525 if (dwarf_version == 2)
1526 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1527 else if (dwarf_version == 3 || dwarf_version == 4)
1528 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1530 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1535 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1539 case DW_FORM_sec_offset:
1540 case DW_FORM_GNU_ref_alt:
1541 case DW_FORM_GNU_strp_alt:
1542 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1545 case DW_FORM_flag_present:
1552 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1557 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1562 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1566 uvalue = read_sleb128 (data, & bytes_read, end);
1570 case DW_FORM_GNU_str_index:
1571 uvalue = read_uleb128 (data, & bytes_read, end);
1575 case DW_FORM_ref_udata:
1577 uvalue = read_uleb128 (data, & bytes_read, end);
1581 case DW_FORM_indirect:
1582 form = read_uleb128 (data, & bytes_read, end);
1585 printf (" %s", get_FORM_name (form));
1586 return read_and_display_attr_value (attribute, form, data, end,
1587 cu_offset, pointer_size,
1588 offset_size, dwarf_version,
1589 debug_info_p, do_loc,
1591 case DW_FORM_GNU_addr_index:
1592 uvalue = read_uleb128 (data, & bytes_read, end);
1599 case DW_FORM_ref_addr:
1601 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1604 case DW_FORM_GNU_ref_alt:
1606 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue));
1612 case DW_FORM_ref_udata:
1614 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1619 case DW_FORM_sec_offset:
1621 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1624 case DW_FORM_flag_present:
1631 printf (" %s", dwarf_vmatoa ("d", uvalue));
1638 dwarf_vma high_bits;
1642 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1644 if (form == DW_FORM_ref8)
1645 add64 (& high_bits, & utmp, cu_offset);
1647 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1650 if ((do_loc || do_debug_loc || do_debug_ranges)
1651 && num_debug_info_entries == 0)
1653 if (sizeof (uvalue) == 8)
1654 SAFE_BYTE_GET (uvalue, data, 8, end);
1656 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1662 case DW_FORM_string:
1664 printf (" %.*s", (int) (end - data), data);
1665 data += strnlen ((char *) data, end - data) + 1;
1669 case DW_FORM_exprloc:
1670 uvalue = read_uleb128 (data, & bytes_read, end);
1671 block_start = data + bytes_read;
1672 if (block_start >= end)
1674 warn (_("Block ends prematurely\n"));
1678 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1679 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1680 block_start + uvalue here. */
1681 data = block_start + uvalue;
1682 /* PR 17512: file: 008-103549-0.001:0.1. */
1683 if (block_start + uvalue > end || data < block_start)
1685 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1686 uvalue = end - block_start;
1689 data = block_start + uvalue;
1691 data = display_block (block_start, uvalue, end);
1694 case DW_FORM_block1:
1695 SAFE_BYTE_GET (uvalue, data, 1, end);
1696 block_start = data + 1;
1697 if (block_start >= end)
1699 warn (_("Block ends prematurely\n"));
1703 data = block_start + uvalue;
1704 if (block_start + uvalue > end || data < block_start)
1706 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1707 uvalue = end - block_start;
1710 data = block_start + uvalue;
1712 data = display_block (block_start, uvalue, end);
1715 case DW_FORM_block2:
1716 SAFE_BYTE_GET (uvalue, data, 2, end);
1717 block_start = data + 2;
1718 if (block_start >= end)
1720 warn (_("Block ends prematurely\n"));
1724 data = block_start + uvalue;
1725 if (block_start + uvalue > end || data < block_start)
1727 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1728 uvalue = end - block_start;
1731 data = block_start + uvalue;
1733 data = display_block (block_start, uvalue, end);
1736 case DW_FORM_block4:
1737 SAFE_BYTE_GET (uvalue, data, 4, end);
1738 block_start = data + 4;
1739 /* PR 17512: file: 3371-3907-0.004. */
1740 if (block_start >= end)
1742 warn (_("Block ends prematurely\n"));
1746 data = block_start + uvalue;
1747 if (block_start + uvalue > end
1748 /* PR 17531: file: 5b5f0592. */
1749 || data < block_start)
1751 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1752 uvalue = end - block_start;
1755 data = block_start + uvalue;
1757 data = display_block (block_start, uvalue, end);
1762 printf (_(" (indirect string, offset: 0x%s): %s"),
1763 dwarf_vmatoa ("x", uvalue),
1764 fetch_indirect_string (uvalue));
1767 case DW_FORM_GNU_str_index:
1770 const char *suffix = strrchr (section->name, '.');
1771 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1773 printf (_(" (indexed string: 0x%s): %s"),
1774 dwarf_vmatoa ("x", uvalue),
1775 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1779 case DW_FORM_GNU_strp_alt:
1781 printf (_(" (alt indirect string, offset: 0x%s)"),
1782 dwarf_vmatoa ("x", uvalue));
1785 case DW_FORM_indirect:
1786 /* Handled above. */
1789 case DW_FORM_ref_sig8:
1792 dwarf_vma high_bits;
1795 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1796 printf (" signature: 0x%s",
1797 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
1802 case DW_FORM_GNU_addr_index:
1804 printf (_(" (addr_index: 0x%s): %s"),
1805 dwarf_vmatoa ("x", uvalue),
1806 fetch_indexed_value (uvalue * pointer_size, pointer_size));
1810 warn (_("Unrecognized form: %lu\n"), form);
1814 if ((do_loc || do_debug_loc || do_debug_ranges)
1815 && num_debug_info_entries == 0
1816 && debug_info_p != NULL)
1820 case DW_AT_frame_base:
1821 have_frame_base = 1;
1822 case DW_AT_location:
1823 case DW_AT_string_length:
1824 case DW_AT_return_addr:
1825 case DW_AT_data_member_location:
1826 case DW_AT_vtable_elem_location:
1828 case DW_AT_static_link:
1829 case DW_AT_use_location:
1830 case DW_AT_GNU_call_site_value:
1831 case DW_AT_GNU_call_site_data_value:
1832 case DW_AT_GNU_call_site_target:
1833 case DW_AT_GNU_call_site_target_clobbered:
1834 if ((dwarf_version < 4
1835 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1836 || form == DW_FORM_sec_offset)
1838 /* Process location list. */
1839 unsigned int lmax = debug_info_p->max_loc_offsets;
1840 unsigned int num = debug_info_p->num_loc_offsets;
1842 if (lmax == 0 || num >= lmax)
1845 debug_info_p->loc_offsets = (dwarf_vma *)
1846 xcrealloc (debug_info_p->loc_offsets,
1847 lmax, sizeof (*debug_info_p->loc_offsets));
1848 debug_info_p->have_frame_base = (int *)
1849 xcrealloc (debug_info_p->have_frame_base,
1850 lmax, sizeof (*debug_info_p->have_frame_base));
1851 debug_info_p->max_loc_offsets = lmax;
1853 if (this_set != NULL)
1854 uvalue += this_set->section_offsets [DW_SECT_LOC];
1855 debug_info_p->loc_offsets [num] = uvalue;
1856 debug_info_p->have_frame_base [num] = have_frame_base;
1857 debug_info_p->num_loc_offsets++;
1862 if (need_base_address)
1863 debug_info_p->base_address = uvalue;
1866 case DW_AT_GNU_addr_base:
1867 debug_info_p->addr_base = uvalue;
1870 case DW_AT_GNU_ranges_base:
1871 debug_info_p->ranges_base = uvalue;
1875 if ((dwarf_version < 4
1876 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1877 || form == DW_FORM_sec_offset)
1879 /* Process range list. */
1880 unsigned int lmax = debug_info_p->max_range_lists;
1881 unsigned int num = debug_info_p->num_range_lists;
1883 if (lmax == 0 || num >= lmax)
1886 debug_info_p->range_lists = (dwarf_vma *)
1887 xcrealloc (debug_info_p->range_lists,
1888 lmax, sizeof (*debug_info_p->range_lists));
1889 debug_info_p->max_range_lists = lmax;
1891 debug_info_p->range_lists [num] = uvalue;
1892 debug_info_p->num_range_lists++;
1901 if (do_loc || attribute == 0)
1904 /* For some attributes we can display further information. */
1911 case DW_INL_not_inlined:
1912 printf (_("(not inlined)"));
1914 case DW_INL_inlined:
1915 printf (_("(inlined)"));
1917 case DW_INL_declared_not_inlined:
1918 printf (_("(declared as inline but ignored)"));
1920 case DW_INL_declared_inlined:
1921 printf (_("(declared as inline and inlined)"));
1924 printf (_(" (Unknown inline attribute value: %s)"),
1925 dwarf_vmatoa ("x", uvalue));
1930 case DW_AT_language:
1934 /* Ordered by the numeric value of these constants. */
1935 case DW_LANG_C89: printf ("(ANSI C)"); break;
1936 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1937 case DW_LANG_Ada83: printf ("(Ada)"); break;
1938 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1939 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1940 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1941 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1942 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1943 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1944 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1945 /* DWARF 2.1 values. */
1946 case DW_LANG_Java: printf ("(Java)"); break;
1947 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1948 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1949 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1950 /* DWARF 3 values. */
1951 case DW_LANG_PLI: printf ("(PLI)"); break;
1952 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1953 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1954 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1955 case DW_LANG_D: printf ("(D)"); break;
1956 /* DWARF 4 values. */
1957 case DW_LANG_Python: printf ("(Python)"); break;
1958 /* DWARF 5 values. */
1959 case DW_LANG_Go: printf ("(Go)"); break;
1960 case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break;
1961 case DW_LANG_C11: printf ("(C11)"); break;
1962 case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break;
1963 case DW_LANG_Fortran03: printf ("(Fortran 03)"); break;
1964 case DW_LANG_Fortran08: printf ("(Fortran 08)"); break;
1965 /* MIPS extension. */
1966 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1967 /* UPC extension. */
1968 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1970 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1971 printf (_("(implementation defined: %s)"),
1972 dwarf_vmatoa ("x", uvalue));
1974 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
1979 case DW_AT_encoding:
1983 case DW_ATE_void: printf ("(void)"); break;
1984 case DW_ATE_address: printf ("(machine address)"); break;
1985 case DW_ATE_boolean: printf ("(boolean)"); break;
1986 case DW_ATE_complex_float: printf ("(complex float)"); break;
1987 case DW_ATE_float: printf ("(float)"); break;
1988 case DW_ATE_signed: printf ("(signed)"); break;
1989 case DW_ATE_signed_char: printf ("(signed char)"); break;
1990 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1991 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1992 /* DWARF 2.1 values: */
1993 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1994 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1995 /* DWARF 3 values: */
1996 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1997 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1998 case DW_ATE_edited: printf ("(edited)"); break;
1999 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
2000 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
2001 /* HP extensions: */
2002 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
2003 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
2004 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
2005 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
2006 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
2007 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
2008 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
2011 if (uvalue >= DW_ATE_lo_user
2012 && uvalue <= DW_ATE_hi_user)
2013 printf (_("(user defined type)"));
2015 printf (_("(unknown type)"));
2020 case DW_AT_accessibility:
2024 case DW_ACCESS_public: printf ("(public)"); break;
2025 case DW_ACCESS_protected: printf ("(protected)"); break;
2026 case DW_ACCESS_private: printf ("(private)"); break;
2028 printf (_("(unknown accessibility)"));
2033 case DW_AT_visibility:
2037 case DW_VIS_local: printf ("(local)"); break;
2038 case DW_VIS_exported: printf ("(exported)"); break;
2039 case DW_VIS_qualified: printf ("(qualified)"); break;
2040 default: printf (_("(unknown visibility)")); break;
2044 case DW_AT_virtuality:
2048 case DW_VIRTUALITY_none: printf ("(none)"); break;
2049 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2050 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2051 default: printf (_("(unknown virtuality)")); break;
2055 case DW_AT_identifier_case:
2059 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2060 case DW_ID_up_case: printf ("(up_case)"); break;
2061 case DW_ID_down_case: printf ("(down_case)"); break;
2062 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
2063 default: printf (_("(unknown case)")); break;
2067 case DW_AT_calling_convention:
2071 case DW_CC_normal: printf ("(normal)"); break;
2072 case DW_CC_program: printf ("(program)"); break;
2073 case DW_CC_nocall: printf ("(nocall)"); break;
2075 if (uvalue >= DW_CC_lo_user
2076 && uvalue <= DW_CC_hi_user)
2077 printf (_("(user defined)"));
2079 printf (_("(unknown convention)"));
2083 case DW_AT_ordering:
2087 case -1: printf (_("(undefined)")); break;
2088 case 0: printf ("(row major)"); break;
2089 case 1: printf ("(column major)"); break;
2093 case DW_AT_frame_base:
2094 have_frame_base = 1;
2095 case DW_AT_location:
2096 case DW_AT_string_length:
2097 case DW_AT_return_addr:
2098 case DW_AT_data_member_location:
2099 case DW_AT_vtable_elem_location:
2101 case DW_AT_static_link:
2102 case DW_AT_use_location:
2103 case DW_AT_GNU_call_site_value:
2104 case DW_AT_GNU_call_site_data_value:
2105 case DW_AT_GNU_call_site_target:
2106 case DW_AT_GNU_call_site_target_clobbered:
2107 if ((dwarf_version < 4
2108 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2109 || form == DW_FORM_sec_offset)
2110 printf (_(" (location list)"));
2112 case DW_AT_allocated:
2113 case DW_AT_associated:
2114 case DW_AT_data_location:
2116 case DW_AT_upper_bound:
2117 case DW_AT_lower_bound:
2120 int need_frame_base;
2123 need_frame_base = decode_location_expression (block_start,
2128 cu_offset, section);
2130 if (need_frame_base && !have_frame_base)
2131 printf (_(" [without DW_AT_frame_base]"));
2137 if (form == DW_FORM_ref_sig8
2138 || form == DW_FORM_GNU_ref_alt)
2141 if (form == DW_FORM_ref1
2142 || form == DW_FORM_ref2
2143 || form == DW_FORM_ref4
2144 || form == DW_FORM_ref_udata)
2145 uvalue += cu_offset;
2147 if (uvalue >= section->size)
2148 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2149 dwarf_vmatoa ("x", uvalue),
2150 (unsigned long) (orig_data - section->start));
2153 unsigned long abbrev_number;
2154 abbrev_entry * entry;
2156 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2158 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2159 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2160 use different abbrev table, and we don't track .debug_info chunks
2162 if (form != DW_FORM_ref_addr)
2164 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2165 if (entry->entry == abbrev_number)
2168 printf (" (%s)", get_TAG_name (entry->tag));
2183 get_AT_name (unsigned long attribute)
2188 return "DW_AT value: 0";
2190 /* One value is shared by the MIPS and HP extensions: */
2191 if (attribute == DW_AT_MIPS_fde)
2192 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2194 name = get_DW_AT_name (attribute);
2198 static char buffer[100];
2200 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2208 static unsigned char *
2209 read_and_display_attr (unsigned long attribute,
2211 unsigned char * data,
2212 unsigned char * end,
2213 dwarf_vma cu_offset,
2214 dwarf_vma pointer_size,
2215 dwarf_vma offset_size,
2217 debug_info * debug_info_p,
2219 struct dwarf_section * section,
2220 struct cu_tu_set * this_set)
2223 printf (" %-18s:", get_AT_name (attribute));
2224 data = read_and_display_attr_value (attribute, form, data, end,
2225 cu_offset, pointer_size, offset_size,
2226 dwarf_version, debug_info_p,
2227 do_loc, section, this_set);
2233 /* Process the contents of a .debug_info section. If do_loc is non-zero
2234 then we are scanning for location lists and we do not want to display
2235 anything to the user. If do_types is non-zero, we are processing
2236 a .debug_types section instead of a .debug_info section. */
2239 process_debug_info (struct dwarf_section *section,
2241 enum dwarf_section_display_enum abbrev_sec,
2245 unsigned char *start = section->start;
2246 unsigned char *end = start + section->size;
2247 unsigned char *section_begin;
2249 unsigned int num_units = 0;
2251 if ((do_loc || do_debug_loc || do_debug_ranges)
2252 && num_debug_info_entries == 0
2257 /* First scan the section to get the number of comp units. */
2258 for (section_begin = start, num_units = 0; section_begin < end;
2261 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2262 will be the length. For a 64-bit DWARF section, it'll be
2263 the escape code 0xffffffff followed by an 8 byte length. */
2264 SAFE_BYTE_GET (length, section_begin, 4, end);
2266 if (length == 0xffffffff)
2268 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2269 section_begin += length + 12;
2271 else if (length >= 0xfffffff0 && length < 0xffffffff)
2273 warn (_("Reserved length value (0x%s) found in section %s\n"),
2274 dwarf_vmatoa ("x", length), section->name);
2278 section_begin += length + 4;
2280 /* Negative values are illegal, they may even cause infinite
2281 looping. This can happen if we can't accurately apply
2282 relocations to an object file, or if the file is corrupt. */
2283 if ((signed long) length <= 0 || section_begin < start)
2285 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2286 dwarf_vmatoa ("x", length), section->name);
2293 error (_("No comp units in %s section ?\n"), section->name);
2297 /* Then allocate an array to hold the information. */
2298 debug_information = (debug_info *) cmalloc (num_units,
2299 sizeof (* debug_information));
2300 if (debug_information == NULL)
2302 error (_("Not enough memory for a debug info array of %u entries\n"),
2304 alloc_num_debug_info_entries = num_debug_info_entries = 0;
2307 /* PR 17531: file: 92ca3797.
2308 We cannot rely upon the debug_information array being initialised
2309 before it is used. A corrupt file could easily contain references
2310 to a unit for which information has not been made available. So
2311 we ensure that the array is zeroed here. */
2312 memset (debug_information, 0, num_units * sizeof (*debug_information));
2314 alloc_num_debug_info_entries = num_units;
2319 if (dwarf_start_die == 0)
2320 printf (_("Contents of the %s section:\n\n"), section->name);
2322 load_debug_section (str, file);
2323 load_debug_section (str_dwo, file);
2324 load_debug_section (str_index, file);
2325 load_debug_section (str_index_dwo, file);
2326 load_debug_section (debug_addr, file);
2329 load_debug_section (abbrev_sec, file);
2330 if (debug_displays [abbrev_sec].section.start == NULL)
2332 warn (_("Unable to locate %s section!\n"),
2333 debug_displays [abbrev_sec].section.name);
2337 for (section_begin = start, unit = 0; start < end; unit++)
2339 DWARF2_Internal_CompUnit compunit;
2340 unsigned char *hdrptr;
2341 unsigned char *tags;
2342 int level, last_level, saved_level;
2343 dwarf_vma cu_offset;
2344 unsigned int offset_size;
2345 int initial_length_size;
2346 dwarf_vma signature_high = 0;
2347 dwarf_vma signature_low = 0;
2348 dwarf_vma type_offset = 0;
2349 struct cu_tu_set *this_set;
2350 dwarf_vma abbrev_base;
2355 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2357 if (compunit.cu_length == 0xffffffff)
2359 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2361 initial_length_size = 12;
2366 initial_length_size = 4;
2369 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2371 cu_offset = start - section_begin;
2373 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2375 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2377 if (this_set == NULL)
2380 abbrev_size = debug_displays [abbrev_sec].section.size;
2384 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2385 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2388 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2389 /* PR 17512: file: 001-108546-0.001:0.1. */
2390 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2392 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2393 compunit.cu_pointer_size, offset_size);
2394 compunit.cu_pointer_size = offset_size;
2399 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2401 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2404 if ((do_loc || do_debug_loc || do_debug_ranges)
2405 && num_debug_info_entries == 0
2408 debug_information [unit].cu_offset = cu_offset;
2409 debug_information [unit].pointer_size
2410 = compunit.cu_pointer_size;
2411 debug_information [unit].offset_size = offset_size;
2412 debug_information [unit].dwarf_version = compunit.cu_version;
2413 debug_information [unit].base_address = 0;
2414 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2415 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2416 debug_information [unit].loc_offsets = NULL;
2417 debug_information [unit].have_frame_base = NULL;
2418 debug_information [unit].max_loc_offsets = 0;
2419 debug_information [unit].num_loc_offsets = 0;
2420 debug_information [unit].range_lists = NULL;
2421 debug_information [unit].max_range_lists= 0;
2422 debug_information [unit].num_range_lists = 0;
2425 if (!do_loc && dwarf_start_die == 0)
2427 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2428 dwarf_vmatoa ("x", cu_offset));
2429 printf (_(" Length: 0x%s (%s)\n"),
2430 dwarf_vmatoa ("x", compunit.cu_length),
2431 offset_size == 8 ? "64-bit" : "32-bit");
2432 printf (_(" Version: %d\n"), compunit.cu_version);
2433 printf (_(" Abbrev Offset: 0x%s\n"),
2434 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2435 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2440 printf (_(" Signature: 0x%s\n"),
2441 dwarf_vmatoa64 (signature_high, signature_low,
2442 buf, sizeof (buf)));
2443 printf (_(" Type Offset: 0x%s\n"),
2444 dwarf_vmatoa ("x", type_offset));
2446 if (this_set != NULL)
2448 dwarf_vma *offsets = this_set->section_offsets;
2449 size_t *sizes = this_set->section_sizes;
2451 printf (_(" Section contributions:\n"));
2452 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2453 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2454 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2455 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2456 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2457 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2458 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2459 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2460 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2461 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2462 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2463 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2467 if (cu_offset + compunit.cu_length + initial_length_size
2470 warn (_("Debug info is corrupted, length of CU at %s"
2471 " extends beyond end of section (length = %s)\n"),
2472 dwarf_vmatoa ("x", cu_offset),
2473 dwarf_vmatoa ("x", compunit.cu_length));
2478 start += compunit.cu_length + initial_length_size;
2482 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2483 dwarf_vmatoa ("x", cu_offset));
2487 if (compunit.cu_version != 2
2488 && compunit.cu_version != 3
2489 && compunit.cu_version != 4)
2491 warn (_("CU at offset %s contains corrupt or "
2492 "unsupported version number: %d.\n"),
2493 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2499 /* Process the abbrevs used by this compilation unit. */
2500 if (compunit.cu_abbrev_offset >= abbrev_size)
2501 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2502 (unsigned long) compunit.cu_abbrev_offset,
2503 (unsigned long) abbrev_size);
2504 /* PR 17531: file:4bcd9ce9. */
2505 else if ((abbrev_base + abbrev_size)
2506 > debug_displays [abbrev_sec].section.size)
2507 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2508 (unsigned long) abbrev_base + abbrev_size,
2509 (unsigned long) debug_displays [abbrev_sec].section.size);
2511 process_abbrev_section
2512 (((unsigned char *) debug_displays [abbrev_sec].section.start
2513 + abbrev_base + compunit.cu_abbrev_offset),
2514 ((unsigned char *) debug_displays [abbrev_sec].section.start
2515 + abbrev_base + abbrev_size));
2520 while (tags < start)
2522 unsigned int bytes_read;
2523 unsigned long abbrev_number;
2524 unsigned long die_offset;
2525 abbrev_entry *entry;
2527 int do_printing = 1;
2529 die_offset = tags - section_begin;
2531 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2534 /* A null DIE marks the end of a list of siblings or it may also be
2535 a section padding. */
2536 if (abbrev_number == 0)
2538 /* Check if it can be a section padding for the last CU. */
2539 if (level == 0 && start == end)
2543 for (chk = tags; chk < start; chk++)
2550 if (!do_loc && die_offset >= dwarf_start_die
2551 && (dwarf_cutoff_level == -1
2552 || level < dwarf_cutoff_level))
2553 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2559 static unsigned num_bogus_warns = 0;
2561 if (num_bogus_warns < 3)
2563 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2564 die_offset, section->name);
2566 if (num_bogus_warns == 3)
2567 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2570 if (dwarf_start_die != 0 && level < saved_level)
2577 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2581 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2582 saved_level = level;
2583 do_printing = (dwarf_cutoff_level == -1
2584 || level < dwarf_cutoff_level);
2586 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2587 level, die_offset, abbrev_number);
2588 else if (dwarf_cutoff_level == -1
2589 || last_level < dwarf_cutoff_level)
2590 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2595 /* Scan through the abbreviation list until we reach the
2597 for (entry = first_abbrev;
2598 entry && entry->entry != abbrev_number;
2599 entry = entry->next)
2604 if (!do_loc && do_printing)
2609 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2610 die_offset, abbrev_number);
2614 if (!do_loc && do_printing)
2615 printf (" (%s)\n", get_TAG_name (entry->tag));
2620 need_base_address = 0;
2622 case DW_TAG_compile_unit:
2623 need_base_address = 1;
2625 case DW_TAG_entry_point:
2626 case DW_TAG_subprogram:
2627 need_base_address = 0;
2628 /* Assuming that there is no DW_AT_frame_base. */
2629 have_frame_base = 0;
2633 for (attr = entry->first_attr;
2634 attr && attr->attribute;
2639 if (! do_loc && do_printing)
2640 /* Show the offset from where the tag was extracted. */
2641 printf (" <%lx>", (unsigned long)(tags - section_begin));
2643 if (debug_information && unit < alloc_num_debug_info_entries)
2644 arg = debug_information + unit;
2648 tags = read_and_display_attr (attr->attribute,
2653 compunit.cu_pointer_size,
2655 compunit.cu_version,
2657 do_loc || ! do_printing,
2662 if (entry->children)
2667 /* Set num_debug_info_entries here so that it can be used to check if
2668 we need to process .debug_loc and .debug_ranges sections. */
2669 if ((do_loc || do_debug_loc || do_debug_ranges)
2670 && num_debug_info_entries == 0
2673 if (num_units > alloc_num_debug_info_entries)
2674 num_debug_info_entries = alloc_num_debug_info_entries;
2676 num_debug_info_entries = num_units;
2685 /* Locate and scan the .debug_info section in the file and record the pointer
2686 sizes and offsets for the compilation units in it. Usually an executable
2687 will have just one pointer size, but this is not guaranteed, and so we try
2688 not to make any assumptions. Returns zero upon failure, or the number of
2689 compilation units upon success. */
2692 load_debug_info (void * file)
2694 /* Reset the last pointer size so that we can issue correct error
2695 messages if we are displaying the contents of more than one section. */
2696 last_pointer_size = 0;
2697 warned_about_missing_comp_units = FALSE;
2699 /* If we have already tried and failed to load the .debug_info
2700 section then do not bother to repeat the task. */
2701 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2704 /* If we already have the information there is nothing else to do. */
2705 if (num_debug_info_entries > 0)
2706 return num_debug_info_entries;
2708 /* If this is a DWARF package file, load the CU and TU indexes. */
2709 load_cu_tu_indexes (file);
2711 if (load_debug_section (info, file)
2712 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2713 return num_debug_info_entries;
2715 if (load_debug_section (info_dwo, file)
2716 && process_debug_info (&debug_displays [info_dwo].section, file,
2718 return num_debug_info_entries;
2720 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2724 /* Read a DWARF .debug_line section header starting at DATA.
2725 Upon success returns an updated DATA pointer and the LINFO
2726 structure and the END_OF_SEQUENCE pointer will be filled in.
2727 Otherwise returns NULL. */
2729 static unsigned char *
2730 read_debug_line_header (struct dwarf_section * section,
2731 unsigned char * data,
2732 unsigned char * end,
2733 DWARF2_Internal_LineInfo * linfo,
2734 unsigned char ** end_of_sequence)
2736 unsigned char *hdrptr;
2737 unsigned int offset_size;
2738 unsigned int initial_length_size;
2740 /* Extract information from the Line Number Program Header.
2741 (section 6.2.4 in the Dwarf3 doc). */
2744 /* Get and check the length of the block. */
2745 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2747 if (linfo->li_length == 0xffffffff)
2749 /* This section is 64-bit DWARF 3. */
2750 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2752 initial_length_size = 12;
2757 initial_length_size = 4;
2760 if (linfo->li_length + initial_length_size > section->size)
2762 /* If the length is just a bias against the initial_length_size then
2763 this means that the field has a relocation against it which has not
2764 been applied. (Ie we are dealing with an object file, not a linked
2765 binary). Do not complain but instead assume that the rest of the
2766 section applies to this particular header. */
2767 if (linfo->li_length == - initial_length_size)
2769 linfo->li_length = section->size - initial_length_size;
2773 warn (_("The line info appears to be corrupt - the section is too small\n"));
2778 /* Get and check the version number. */
2779 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2781 if (linfo->li_version != 2
2782 && linfo->li_version != 3
2783 && linfo->li_version != 4)
2785 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2789 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2790 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2792 if (linfo->li_version >= 4)
2794 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2796 if (linfo->li_max_ops_per_insn == 0)
2798 warn (_("Invalid maximum operations per insn.\n"));
2803 linfo->li_max_ops_per_insn = 1;
2805 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2806 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2807 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2808 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2810 * end_of_sequence = data + linfo->li_length + initial_length_size;
2811 /* PR 17512: file:002-117414-0.004. */
2812 if (* end_of_sequence > end)
2814 warn (_("Line length %s extends beyond end of section\n"),
2815 dwarf_vmatoa ("u", linfo->li_length));
2816 * end_of_sequence = end;
2824 display_debug_lines_raw (struct dwarf_section *section,
2825 unsigned char *data,
2828 unsigned char *start = section->start;
2830 printf (_("Raw dump of debug contents of section %s:\n\n"),
2835 static DWARF2_Internal_LineInfo saved_linfo;
2836 DWARF2_Internal_LineInfo linfo;
2837 unsigned char *standard_opcodes;
2838 unsigned char *end_of_sequence;
2839 unsigned int last_dir_entry = 0;
2842 if (const_strneq (section->name, ".debug_line.")
2843 /* Note: the following does not apply to .debug_line.dwo sections.
2844 These are full debug_line sections. */
2845 && strcmp (section->name, ".debug_line.dwo") != 0)
2847 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2848 section containing just the Line Number Statements. They are
2849 created by the assembler and intended to be used alongside gcc's
2850 -ffunction-sections command line option. When the linker's
2851 garbage collection decides to discard a .text.<foo> section it
2852 can then also discard the line number information in .debug_line.<foo>.
2854 Since the section is a fragment it does not have the details
2855 needed to fill out a LineInfo structure, so instead we use the
2856 details from the last full debug_line section that we processed. */
2857 end_of_sequence = end;
2858 standard_opcodes = NULL;
2859 linfo = saved_linfo;
2860 /* PR 17531: file: 0522b371. */
2861 if (linfo.li_line_range == 0)
2863 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2866 reset_state_machine (linfo.li_default_is_stmt);
2870 unsigned char * hdrptr;
2872 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2873 & end_of_sequence)) == NULL)
2876 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
2877 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2878 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2879 printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length);
2880 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2881 if (linfo.li_version >= 4)
2882 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2883 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2884 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2885 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2886 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2888 /* PR 17512: file: 1665-6428-0.004. */
2889 if (linfo.li_line_range == 0)
2891 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2892 linfo.li_line_range = 1;
2895 reset_state_machine (linfo.li_default_is_stmt);
2897 /* Display the contents of the Opcodes table. */
2898 standard_opcodes = hdrptr;
2900 /* PR 17512: file: 002-417945-0.004. */
2901 if (standard_opcodes + linfo.li_opcode_base >= end)
2903 warn (_("Line Base extends beyond end of section\n"));
2907 printf (_("\n Opcodes:\n"));
2909 for (i = 1; i < linfo.li_opcode_base; i++)
2910 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2912 /* Display the contents of the Directory table. */
2913 data = standard_opcodes + linfo.li_opcode_base - 1;
2916 printf (_("\n The Directory Table is empty.\n"));
2919 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2920 (long)(data - start));
2922 while (data < end && *data != 0)
2924 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2926 data += strnlen ((char *) data, end - data) + 1;
2929 /* PR 17512: file: 002-132094-0.004. */
2930 if (data >= end - 1)
2934 /* Skip the NUL at the end of the table. */
2937 /* Display the contents of the File Name table. */
2939 printf (_("\n The File Name Table is empty.\n"));
2942 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2943 (long)(data - start));
2944 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2946 while (data < end && *data != 0)
2948 unsigned char *name;
2949 unsigned int bytes_read;
2951 printf (" %d\t", ++state_machine_regs.last_file_entry);
2953 data += strnlen ((char *) data, end - data) + 1;
2956 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2959 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2962 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2964 printf ("%.*s\n", (int)(end - name), name);
2968 warn (_("Corrupt file name table entry\n"));
2974 /* Skip the NUL at the end of the table. */
2977 saved_linfo = linfo;
2980 /* Now display the statements. */
2981 if (data >= end_of_sequence)
2982 printf (_(" No Line Number Statements.\n"));
2985 printf (_(" Line Number Statements:\n"));
2987 while (data < end_of_sequence)
2989 unsigned char op_code;
2990 dwarf_signed_vma adv;
2992 unsigned int bytes_read;
2994 printf (" [0x%08lx]", (long)(data - start));
2998 if (op_code >= linfo.li_opcode_base)
3000 op_code -= linfo.li_opcode_base;
3001 uladv = (op_code / linfo.li_line_range);
3002 if (linfo.li_max_ops_per_insn == 1)
3004 uladv *= linfo.li_min_insn_length;
3005 state_machine_regs.address += uladv;
3006 printf (_(" Special opcode %d: "
3007 "advance Address by %s to 0x%s"),
3008 op_code, dwarf_vmatoa ("u", uladv),
3009 dwarf_vmatoa ("x", state_machine_regs.address));
3013 state_machine_regs.address
3014 += ((state_machine_regs.op_index + uladv)
3015 / linfo.li_max_ops_per_insn)
3016 * linfo.li_min_insn_length;
3017 state_machine_regs.op_index
3018 = (state_machine_regs.op_index + uladv)
3019 % linfo.li_max_ops_per_insn;
3020 printf (_(" Special opcode %d: "
3021 "advance Address by %s to 0x%s[%d]"),
3022 op_code, dwarf_vmatoa ("u", uladv),
3023 dwarf_vmatoa ("x", state_machine_regs.address),
3024 state_machine_regs.op_index);
3026 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3027 state_machine_regs.line += adv;
3028 printf (_(" and Line by %s to %d\n"),
3029 dwarf_vmatoa ("d", adv), state_machine_regs.line);
3031 else switch (op_code)
3033 case DW_LNS_extended_op:
3034 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3038 printf (_(" Copy\n"));
3041 case DW_LNS_advance_pc:
3042 uladv = read_uleb128 (data, & bytes_read, end);
3044 if (linfo.li_max_ops_per_insn == 1)
3046 uladv *= linfo.li_min_insn_length;
3047 state_machine_regs.address += uladv;
3048 printf (_(" Advance PC by %s to 0x%s\n"),
3049 dwarf_vmatoa ("u", uladv),
3050 dwarf_vmatoa ("x", state_machine_regs.address));
3054 state_machine_regs.address
3055 += ((state_machine_regs.op_index + uladv)
3056 / linfo.li_max_ops_per_insn)
3057 * linfo.li_min_insn_length;
3058 state_machine_regs.op_index
3059 = (state_machine_regs.op_index + uladv)
3060 % linfo.li_max_ops_per_insn;
3061 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3062 dwarf_vmatoa ("u", uladv),
3063 dwarf_vmatoa ("x", state_machine_regs.address),
3064 state_machine_regs.op_index);
3068 case DW_LNS_advance_line:
3069 adv = read_sleb128 (data, & bytes_read, end);
3071 state_machine_regs.line += adv;
3072 printf (_(" Advance Line by %s to %d\n"),
3073 dwarf_vmatoa ("d", adv),
3074 state_machine_regs.line);
3077 case DW_LNS_set_file:
3078 adv = read_uleb128 (data, & bytes_read, end);
3080 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3081 dwarf_vmatoa ("d", adv));
3082 state_machine_regs.file = adv;
3085 case DW_LNS_set_column:
3086 uladv = read_uleb128 (data, & bytes_read, end);
3088 printf (_(" Set column to %s\n"),
3089 dwarf_vmatoa ("u", uladv));
3090 state_machine_regs.column = uladv;
3093 case DW_LNS_negate_stmt:
3094 adv = state_machine_regs.is_stmt;
3096 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3097 state_machine_regs.is_stmt = adv;
3100 case DW_LNS_set_basic_block:
3101 printf (_(" Set basic block\n"));
3102 state_machine_regs.basic_block = 1;
3105 case DW_LNS_const_add_pc:
3106 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3107 if (linfo.li_max_ops_per_insn)
3109 uladv *= linfo.li_min_insn_length;
3110 state_machine_regs.address += uladv;
3111 printf (_(" Advance PC by constant %s to 0x%s\n"),
3112 dwarf_vmatoa ("u", uladv),
3113 dwarf_vmatoa ("x", state_machine_regs.address));
3117 state_machine_regs.address
3118 += ((state_machine_regs.op_index + uladv)
3119 / linfo.li_max_ops_per_insn)
3120 * linfo.li_min_insn_length;
3121 state_machine_regs.op_index
3122 = (state_machine_regs.op_index + uladv)
3123 % linfo.li_max_ops_per_insn;
3124 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3125 dwarf_vmatoa ("u", uladv),
3126 dwarf_vmatoa ("x", state_machine_regs.address),
3127 state_machine_regs.op_index);
3131 case DW_LNS_fixed_advance_pc:
3132 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3133 state_machine_regs.address += uladv;
3134 state_machine_regs.op_index = 0;
3135 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3136 dwarf_vmatoa ("u", uladv),
3137 dwarf_vmatoa ("x", state_machine_regs.address));
3140 case DW_LNS_set_prologue_end:
3141 printf (_(" Set prologue_end to true\n"));
3144 case DW_LNS_set_epilogue_begin:
3145 printf (_(" Set epilogue_begin to true\n"));
3148 case DW_LNS_set_isa:
3149 uladv = read_uleb128 (data, & bytes_read, end);
3151 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3155 printf (_(" Unknown opcode %d with operands: "), op_code);
3157 if (standard_opcodes != NULL)
3158 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3160 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3162 i == 1 ? "" : ", ");
3178 unsigned char *name;
3179 unsigned int directory_index;
3180 unsigned int modification_date;
3181 unsigned int length;
3184 /* Output a decoded representation of the .debug_line section. */
3187 display_debug_lines_decoded (struct dwarf_section *section,
3188 unsigned char *data,
3191 static DWARF2_Internal_LineInfo saved_linfo;
3193 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3198 /* This loop amounts to one iteration per compilation unit. */
3199 DWARF2_Internal_LineInfo linfo;
3200 unsigned char *standard_opcodes;
3201 unsigned char *end_of_sequence;
3203 File_Entry *file_table = NULL;
3204 unsigned int n_files = 0;
3205 unsigned char **directory_table = NULL;
3206 unsigned int n_directories = 0;
3208 if (const_strneq (section->name, ".debug_line.")
3209 /* Note: the following does not apply to .debug_line.dwo sections.
3210 These are full debug_line sections. */
3211 && strcmp (section->name, ".debug_line.dwo") != 0)
3213 /* See comment in display_debug_lines_raw(). */
3214 end_of_sequence = end;
3215 standard_opcodes = NULL;
3216 linfo = saved_linfo;
3217 /* PR 17531: file: 0522b371. */
3218 if (linfo.li_line_range == 0)
3220 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3223 reset_state_machine (linfo.li_default_is_stmt);
3227 unsigned char *hdrptr;
3229 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3230 & end_of_sequence)) == NULL)
3233 /* PR 17531: file: 0522b371. */
3234 if (linfo.li_line_range == 0)
3236 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3237 linfo.li_line_range = 1;
3239 reset_state_machine (linfo.li_default_is_stmt);
3241 /* Save a pointer to the contents of the Opcodes table. */
3242 standard_opcodes = hdrptr;
3244 /* Traverse the Directory table just to count entries. */
3245 data = standard_opcodes + linfo.li_opcode_base - 1;
3248 unsigned char *ptr_directory_table = data;
3252 data += strnlen ((char *) data, end - data) + 1;
3256 /* Go through the directory table again to save the directories. */
3257 directory_table = (unsigned char **)
3258 xmalloc (n_directories * sizeof (unsigned char *));
3261 while (*ptr_directory_table != 0)
3263 directory_table[i] = ptr_directory_table;
3264 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3265 ptr_directory_table - end) + 1;
3269 /* Skip the NUL at the end of the table. */
3272 /* Traverse the File Name table just to count the entries. */
3275 unsigned char *ptr_file_name_table = data;
3279 unsigned int bytes_read;
3281 /* Skip Name, directory index, last modification time and length
3283 data += strnlen ((char *) data, end - data) + 1;
3284 read_uleb128 (data, & bytes_read, end);
3286 read_uleb128 (data, & bytes_read, end);
3288 read_uleb128 (data, & bytes_read, end);
3294 /* Go through the file table again to save the strings. */
3295 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3298 while (*ptr_file_name_table != 0)
3300 unsigned int bytes_read;
3302 file_table[i].name = ptr_file_name_table;
3303 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3304 end - ptr_file_name_table) + 1;
3306 /* We are not interested in directory, time or size. */
3307 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3309 ptr_file_name_table += bytes_read;
3310 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3312 ptr_file_name_table += bytes_read;
3313 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3314 ptr_file_name_table += bytes_read;
3319 /* Print the Compilation Unit's name and a header. */
3320 if (directory_table == NULL)
3322 printf (_("CU: %s:\n"), file_table[0].name);
3323 printf (_("File name Line number Starting address\n"));
3327 unsigned int ix = file_table[0].directory_index;
3328 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3330 if (do_wide || strlen (directory) < 76)
3331 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3333 printf ("%s:\n", file_table[0].name);
3335 printf (_("File name Line number Starting address\n"));
3339 /* Skip the NUL at the end of the table. */
3342 saved_linfo = linfo;
3345 /* This loop iterates through the Dwarf Line Number Program. */
3346 while (data < end_of_sequence)
3348 unsigned char op_code;
3350 unsigned long int uladv;
3351 unsigned int bytes_read;
3352 int is_special_opcode = 0;
3356 if (op_code >= linfo.li_opcode_base)
3358 op_code -= linfo.li_opcode_base;
3359 uladv = (op_code / linfo.li_line_range);
3360 if (linfo.li_max_ops_per_insn == 1)
3362 uladv *= linfo.li_min_insn_length;
3363 state_machine_regs.address += uladv;
3367 state_machine_regs.address
3368 += ((state_machine_regs.op_index + uladv)
3369 / linfo.li_max_ops_per_insn)
3370 * linfo.li_min_insn_length;
3371 state_machine_regs.op_index
3372 = (state_machine_regs.op_index + uladv)
3373 % linfo.li_max_ops_per_insn;
3376 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3377 state_machine_regs.line += adv;
3378 is_special_opcode = 1;
3380 else switch (op_code)
3382 case DW_LNS_extended_op:
3384 unsigned int ext_op_code_len;
3385 unsigned char ext_op_code;
3386 unsigned char *op_code_data = data;
3388 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3390 op_code_data += bytes_read;
3392 if (ext_op_code_len == 0)
3394 warn (_("Badly formed extended line op encountered!\n"));
3397 ext_op_code_len += bytes_read;
3398 ext_op_code = *op_code_data++;
3400 switch (ext_op_code)
3402 case DW_LNE_end_sequence:
3403 reset_state_machine (linfo.li_default_is_stmt);
3405 case DW_LNE_set_address:
3406 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3408 ext_op_code_len - bytes_read - 1,
3410 state_machine_regs.op_index = 0;
3412 case DW_LNE_define_file:
3414 file_table = (File_Entry *) xrealloc
3415 (file_table, (n_files + 1) * sizeof (File_Entry));
3417 ++state_machine_regs.last_file_entry;
3418 /* Source file name. */
3419 file_table[n_files].name = op_code_data;
3420 op_code_data += strlen ((char *) op_code_data) + 1;
3421 /* Directory index. */
3422 file_table[n_files].directory_index =
3423 read_uleb128 (op_code_data, & bytes_read,
3425 op_code_data += bytes_read;
3426 /* Last modification time. */
3427 file_table[n_files].modification_date =
3428 read_uleb128 (op_code_data, & bytes_read,
3430 op_code_data += bytes_read;
3432 file_table[n_files].length =
3433 read_uleb128 (op_code_data, & bytes_read,
3439 case DW_LNE_set_discriminator:
3440 case DW_LNE_HP_set_sequence:
3441 /* Simply ignored. */
3445 printf (_("UNKNOWN (%u): length %d\n"),
3446 ext_op_code, ext_op_code_len - bytes_read);
3449 data += ext_op_code_len;
3455 case DW_LNS_advance_pc:
3456 uladv = read_uleb128 (data, & bytes_read, end);
3458 if (linfo.li_max_ops_per_insn == 1)
3460 uladv *= linfo.li_min_insn_length;
3461 state_machine_regs.address += uladv;
3465 state_machine_regs.address
3466 += ((state_machine_regs.op_index + uladv)
3467 / linfo.li_max_ops_per_insn)
3468 * linfo.li_min_insn_length;
3469 state_machine_regs.op_index
3470 = (state_machine_regs.op_index + uladv)
3471 % linfo.li_max_ops_per_insn;
3475 case DW_LNS_advance_line:
3476 adv = read_sleb128 (data, & bytes_read, end);
3478 state_machine_regs.line += adv;
3481 case DW_LNS_set_file:
3482 adv = read_uleb128 (data, & bytes_read, end);
3484 state_machine_regs.file = adv;
3486 if (file_table == NULL)
3487 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3488 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3489 /* If directory index is 0, that means current directory. */
3490 printf ("\n./%s:[++]\n",
3491 file_table[state_machine_regs.file - 1].name);
3492 else if (directory_table == NULL)
3493 printf (_("\n [Use directory table entry %d]\n"),
3494 file_table[state_machine_regs.file - 1].directory_index - 1);
3496 /* The directory index starts counting at 1. */
3497 printf ("\n%s/%s:\n",
3498 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3499 file_table[state_machine_regs.file - 1].name);
3502 case DW_LNS_set_column:
3503 uladv = read_uleb128 (data, & bytes_read, end);
3505 state_machine_regs.column = uladv;
3508 case DW_LNS_negate_stmt:
3509 adv = state_machine_regs.is_stmt;
3511 state_machine_regs.is_stmt = adv;
3514 case DW_LNS_set_basic_block:
3515 state_machine_regs.basic_block = 1;
3518 case DW_LNS_const_add_pc:
3519 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3520 if (linfo.li_max_ops_per_insn == 1)
3522 uladv *= linfo.li_min_insn_length;
3523 state_machine_regs.address += uladv;
3527 state_machine_regs.address
3528 += ((state_machine_regs.op_index + uladv)
3529 / linfo.li_max_ops_per_insn)
3530 * linfo.li_min_insn_length;
3531 state_machine_regs.op_index
3532 = (state_machine_regs.op_index + uladv)
3533 % linfo.li_max_ops_per_insn;
3537 case DW_LNS_fixed_advance_pc:
3538 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3539 state_machine_regs.address += uladv;
3540 state_machine_regs.op_index = 0;
3543 case DW_LNS_set_prologue_end:
3546 case DW_LNS_set_epilogue_begin:
3549 case DW_LNS_set_isa:
3550 uladv = read_uleb128 (data, & bytes_read, end);
3552 printf (_(" Set ISA to %lu\n"), uladv);
3556 printf (_(" Unknown opcode %d with operands: "), op_code);
3558 if (standard_opcodes != NULL)
3559 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3561 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3563 i == 1 ? "" : ", ");
3570 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3571 to the DWARF address/line matrix. */
3572 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3573 || (op_code == DW_LNS_copy))
3575 const unsigned int MAX_FILENAME_LENGTH = 35;
3577 char *newFileName = NULL;
3578 size_t fileNameLength;
3581 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3583 fileName = "<unknown>";
3585 fileNameLength = strlen (fileName);
3587 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3589 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3590 /* Truncate file name */
3591 strncpy (newFileName,
3592 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3593 MAX_FILENAME_LENGTH + 1);
3597 newFileName = (char *) xmalloc (fileNameLength + 1);
3598 strncpy (newFileName, fileName, fileNameLength + 1);
3601 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3603 if (linfo.li_max_ops_per_insn == 1)
3604 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3605 newFileName, state_machine_regs.line,
3606 state_machine_regs.address);
3608 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3609 newFileName, state_machine_regs.line,
3610 state_machine_regs.address,
3611 state_machine_regs.op_index);
3615 if (linfo.li_max_ops_per_insn == 1)
3616 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3617 newFileName, state_machine_regs.line,
3618 state_machine_regs.address);
3620 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3621 newFileName, state_machine_regs.line,
3622 state_machine_regs.address,
3623 state_machine_regs.op_index);
3626 if (op_code == DW_LNE_end_sequence)
3640 if (directory_table)
3642 free (directory_table);
3643 directory_table = NULL;
3654 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3656 unsigned char *data = section->start;
3657 unsigned char *end = data + section->size;
3659 int retValDecoded = 1;
3661 if (do_debug_lines == 0)
3662 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3664 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3665 retValRaw = display_debug_lines_raw (section, data, end);
3667 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3668 retValDecoded = display_debug_lines_decoded (section, data, end);
3670 if (!retValRaw || !retValDecoded)
3677 find_debug_info_for_offset (unsigned long offset)
3681 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3684 for (i = 0; i < num_debug_info_entries; i++)
3685 if (debug_information[i].cu_offset == offset)
3686 return debug_information + i;
3692 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3694 /* See gdb/gdb-index.h. */
3695 static const char * const kinds[] =
3707 return _ (kinds[kind]);
3711 display_debug_pubnames_worker (struct dwarf_section *section,
3712 void *file ATTRIBUTE_UNUSED,
3715 DWARF2_Internal_PubNames names;
3716 unsigned char *start = section->start;
3717 unsigned char *end = start + section->size;
3719 /* It does not matter if this load fails,
3720 we test for that later on. */
3721 load_debug_info (file);
3723 printf (_("Contents of the %s section:\n\n"), section->name);
3727 unsigned char *data;
3730 unsigned int offset_size, initial_length_size;
3734 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3735 if (names.pn_length == 0xffffffff)
3737 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3739 initial_length_size = 12;
3744 initial_length_size = 4;
3747 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3748 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3750 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3751 && num_debug_info_entries > 0
3752 && find_debug_info_for_offset (names.pn_offset) == NULL)
3753 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3754 (unsigned long) names.pn_offset, section->name);
3756 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3758 adr = start + names.pn_length + initial_length_size;
3759 /* PR 17531: file: 7615b6b2. */
3760 if ((dwarf_signed_vma) names.pn_length < 0
3761 /* PR 17531: file: a5dbeaa7. */
3764 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3770 printf (_(" Length: %ld\n"),
3771 (long) names.pn_length);
3772 printf (_(" Version: %d\n"),
3774 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3775 (unsigned long) names.pn_offset);
3776 printf (_(" Size of area in .debug_info section: %ld\n"),
3777 (long) names.pn_size);
3779 if (names.pn_version != 2 && names.pn_version != 3)
3781 static int warned = 0;
3785 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3793 printf (_("\n Offset Kind Name\n"));
3795 printf (_("\n Offset\tName\n"));
3799 bfd_size_type maxprint;
3801 SAFE_BYTE_GET (offset, data, offset_size, end);
3805 data += offset_size;
3808 maxprint = (end - data) - 1;
3812 unsigned int kind_data;
3813 gdb_index_symbol_kind kind;
3814 const char *kind_name;
3817 SAFE_BYTE_GET (kind_data, data, 1, end);
3820 /* GCC computes the kind as the upper byte in the CU index
3821 word, and then right shifts it by the CU index size.
3822 Left shift KIND to where the gdb-index.h accessor macros
3824 kind_data <<= GDB_INDEX_CU_BITSIZE;
3825 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3826 kind_name = get_gdb_index_symbol_kind_name (kind);
3827 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3828 printf (" %-6lx %s,%-10s %.*s\n",
3829 (unsigned long) offset, is_static ? _("s") : _("g"),
3830 kind_name, (int) maxprint, data);
3833 printf (" %-6lx\t%.*s\n",
3834 (unsigned long) offset, (int) maxprint, data);
3836 data += strnlen ((char *) data, maxprint) + 1;
3841 while (offset != 0);
3849 display_debug_pubnames (struct dwarf_section *section, void *file)
3851 return display_debug_pubnames_worker (section, file, 0);
3855 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3857 return display_debug_pubnames_worker (section, file, 1);
3861 display_debug_macinfo (struct dwarf_section *section,
3862 void *file ATTRIBUTE_UNUSED)
3864 unsigned char *start = section->start;
3865 unsigned char *end = start + section->size;
3866 unsigned char *curr = start;
3867 unsigned int bytes_read;
3868 enum dwarf_macinfo_record_type op;
3870 printf (_("Contents of the %s section:\n\n"), section->name);
3874 unsigned int lineno;
3875 const unsigned char *string;
3877 op = (enum dwarf_macinfo_record_type) *curr;
3882 case DW_MACINFO_start_file:
3884 unsigned int filenum;
3886 lineno = read_uleb128 (curr, & bytes_read, end);
3888 filenum = read_uleb128 (curr, & bytes_read, end);
3891 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3896 case DW_MACINFO_end_file:
3897 printf (_(" DW_MACINFO_end_file\n"));
3900 case DW_MACINFO_define:
3901 lineno = read_uleb128 (curr, & bytes_read, end);
3904 curr += strnlen ((char *) string, end - string) + 1;
3905 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3909 case DW_MACINFO_undef:
3910 lineno = read_uleb128 (curr, & bytes_read, end);
3913 curr += strnlen ((char *) string, end - string) + 1;
3914 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3918 case DW_MACINFO_vendor_ext:
3920 unsigned int constant;
3922 constant = read_uleb128 (curr, & bytes_read, end);
3925 curr += strnlen ((char *) string, end - string) + 1;
3926 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3936 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3937 filename and dirname corresponding to file name table entry with index
3938 FILEIDX. Return NULL on failure. */
3940 static unsigned char *
3941 get_line_filename_and_dirname (dwarf_vma line_offset,
3943 unsigned char **dir_name)
3945 struct dwarf_section *section = &debug_displays [line].section;
3946 unsigned char *hdrptr, *dirtable, *file_name;
3947 unsigned int offset_size, initial_length_size;
3948 unsigned int version, opcode_base, bytes_read;
3949 dwarf_vma length, diridx;
3950 const unsigned char * end;
3953 if (section->start == NULL
3954 || line_offset >= section->size
3958 hdrptr = section->start + line_offset;
3959 end = section->start + section->size;
3961 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3962 if (length == 0xffffffff)
3964 /* This section is 64-bit DWARF 3. */
3965 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3967 initial_length_size = 12;
3972 initial_length_size = 4;
3974 if (length + initial_length_size > section->size)
3977 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3978 if (version != 2 && version != 3 && version != 4)
3980 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3982 hdrptr++; /* Skip max_ops_per_insn. */
3983 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3985 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3986 if (opcode_base == 0)
3989 hdrptr += opcode_base - 1;
3991 /* Skip over dirname table. */
3992 while (*hdrptr != '\0')
3993 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3994 hdrptr++; /* Skip the NUL at the end of the table. */
3995 /* Now skip over preceding filename table entries. */
3996 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3998 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3999 read_uleb128 (hdrptr, &bytes_read, end);
4000 hdrptr += bytes_read;
4001 read_uleb128 (hdrptr, &bytes_read, end);
4002 hdrptr += bytes_read;
4003 read_uleb128 (hdrptr, &bytes_read, end);
4004 hdrptr += bytes_read;
4006 if (hdrptr == end || *hdrptr == '\0')
4009 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4010 diridx = read_uleb128 (hdrptr, &bytes_read, end);
4013 for (; *dirtable != '\0' && diridx > 1; diridx--)
4014 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4015 if (*dirtable == '\0')
4017 *dir_name = dirtable;
4022 display_debug_macro (struct dwarf_section *section,
4025 unsigned char *start = section->start;
4026 unsigned char *end = start + section->size;
4027 unsigned char *curr = start;
4028 unsigned char *extended_op_buf[256];
4029 unsigned int bytes_read;
4031 load_debug_section (str, file);
4032 load_debug_section (line, file);
4034 printf (_("Contents of the %s section:\n\n"), section->name);
4038 unsigned int lineno, version, flags;
4039 unsigned int offset_size = 4;
4040 const unsigned char *string;
4041 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4042 unsigned char **extended_ops = NULL;
4044 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4047 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4052 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4055 printf (_(" Offset: 0x%lx\n"),
4056 (unsigned long) sec_offset);
4057 printf (_(" Version: %d\n"), version);
4058 printf (_(" Offset size: %d\n"), offset_size);
4061 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4062 printf (_(" Offset into .debug_line: 0x%lx\n"),
4063 (unsigned long) line_offset);
4067 unsigned int i, count, op;
4070 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4072 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4073 extended_ops = extended_op_buf;
4076 printf (_(" Extension opcode arguments:\n"));
4077 for (i = 0; i < count; i++)
4079 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4080 extended_ops[op] = curr;
4081 nargs = read_uleb128 (curr, &bytes_read, end);
4084 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
4087 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
4088 for (n = 0; n < nargs; n++)
4092 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4093 printf ("%s%s", get_FORM_name (form),
4094 n == nargs - 1 ? "\n" : ", ");
4104 case DW_FORM_block1:
4105 case DW_FORM_block2:
4106 case DW_FORM_block4:
4108 case DW_FORM_string:
4110 case DW_FORM_sec_offset:
4113 error (_("Invalid extension opcode form %s\n"),
4114 get_FORM_name (form));
4130 error (_(".debug_macro section not zero terminated\n"));
4134 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4140 case DW_MACRO_GNU_start_file:
4142 unsigned int filenum;
4143 unsigned char *file_name = NULL, *dir_name = NULL;
4145 lineno = read_uleb128 (curr, &bytes_read, end);
4147 filenum = read_uleb128 (curr, &bytes_read, end);
4150 if ((flags & 2) == 0)
4151 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4154 = get_line_filename_and_dirname (line_offset, filenum,
4156 if (file_name == NULL)
4157 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4160 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4162 dir_name != NULL ? (const char *) dir_name : "",
4163 dir_name != NULL ? "/" : "", file_name);
4167 case DW_MACRO_GNU_end_file:
4168 printf (_(" DW_MACRO_GNU_end_file\n"));
4171 case DW_MACRO_GNU_define:
4172 lineno = read_uleb128 (curr, &bytes_read, end);
4175 curr += strnlen ((char *) string, end - string) + 1;
4176 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4180 case DW_MACRO_GNU_undef:
4181 lineno = read_uleb128 (curr, &bytes_read, end);
4184 curr += strnlen ((char *) string, end - string) + 1;
4185 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4189 case DW_MACRO_GNU_define_indirect:
4190 lineno = read_uleb128 (curr, &bytes_read, end);
4192 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4193 string = fetch_indirect_string (offset);
4194 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4198 case DW_MACRO_GNU_undef_indirect:
4199 lineno = read_uleb128 (curr, &bytes_read, end);
4201 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4202 string = fetch_indirect_string (offset);
4203 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4207 case DW_MACRO_GNU_transparent_include:
4208 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4209 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4210 (unsigned long) offset);
4213 case DW_MACRO_GNU_define_indirect_alt:
4214 lineno = read_uleb128 (curr, &bytes_read, end);
4216 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4217 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4218 lineno, (unsigned long) offset);
4221 case DW_MACRO_GNU_undef_indirect_alt:
4222 lineno = read_uleb128 (curr, &bytes_read, end);
4224 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4225 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4226 lineno, (unsigned long) offset);
4229 case DW_MACRO_GNU_transparent_include_alt:
4230 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4231 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4232 (unsigned long) offset);
4236 if (extended_ops == NULL || extended_ops[op] == NULL)
4238 error (_(" Unknown macro opcode %02x seen\n"), op);
4243 /* Skip over unhandled opcodes. */
4245 unsigned char *desc = extended_ops[op];
4246 nargs = read_uleb128 (desc, &bytes_read, end);
4250 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4253 printf (_(" DW_MACRO_GNU_%02x -"), op);
4254 for (n = 0; n < nargs; n++)
4258 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4260 = read_and_display_attr_value (0, val,
4261 curr, end, 0, 0, offset_size,
4262 version, NULL, 0, NULL,
4280 display_debug_abbrev (struct dwarf_section *section,
4281 void *file ATTRIBUTE_UNUSED)
4283 abbrev_entry *entry;
4284 unsigned char *start = section->start;
4285 unsigned char *end = start + section->size;
4287 printf (_("Contents of the %s section:\n\n"), section->name);
4291 unsigned char *last;
4296 start = process_abbrev_section (start, end);
4298 if (first_abbrev == NULL)
4301 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
4303 for (entry = first_abbrev; entry; entry = entry->next)
4307 printf (" %ld %s [%s]\n",
4309 get_TAG_name (entry->tag),
4310 entry->children ? _("has children") : _("no children"));
4312 for (attr = entry->first_attr; attr; attr = attr->next)
4313 printf (" %-18s %s\n",
4314 get_AT_name (attr->attribute),
4315 get_FORM_name (attr->form));
4325 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4328 display_loc_list (struct dwarf_section *section,
4329 unsigned char **start_ptr,
4330 unsigned int debug_info_entry,
4331 unsigned long offset,
4332 unsigned long base_address,
4335 unsigned char *start = *start_ptr;
4336 unsigned char *section_end = section->start + section->size;
4337 unsigned long cu_offset;
4338 unsigned int pointer_size;
4339 unsigned int offset_size;
4344 unsigned short length;
4345 int need_frame_base;
4347 if (debug_info_entry >= num_debug_info_entries)
4349 warn (_("No debug information available for loc lists of entry: %u\n"),
4354 cu_offset = debug_information [debug_info_entry].cu_offset;
4355 pointer_size = debug_information [debug_info_entry].pointer_size;
4356 offset_size = debug_information [debug_info_entry].offset_size;
4357 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4359 if (pointer_size < 2 || pointer_size > 8)
4361 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4362 pointer_size, debug_info_entry);
4368 if (start + 2 * pointer_size > section_end)
4370 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4375 printf (" %8.8lx ", offset + (start - *start_ptr));
4377 /* Note: we use sign extension here in order to be sure that we can detect
4378 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4379 address will not affect the values that we display since we always show
4380 hex values, and always the bottom 32-bits. */
4381 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4382 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4384 if (begin == 0 && end == 0)
4386 printf (_("<End of list>\n"));
4390 /* Check base address specifiers. */
4391 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4394 print_dwarf_vma (begin, pointer_size);
4395 print_dwarf_vma (end, pointer_size);
4396 printf (_("(base address)\n"));
4400 if (start + 2 > section_end)
4402 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4407 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4409 if (start + length > section_end)
4411 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4416 print_dwarf_vma (begin + base_address, pointer_size);
4417 print_dwarf_vma (end + base_address, pointer_size);
4420 need_frame_base = decode_location_expression (start,
4425 cu_offset, section);
4428 if (need_frame_base && !has_frame_base)
4429 printf (_(" [without DW_AT_frame_base]"));
4432 fputs (_(" (start == end)"), stdout);
4433 else if (begin > end)
4434 fputs (_(" (start > end)"), stdout);
4444 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4445 right-adjusted in a field of length LEN, and followed by a space. */
4448 print_addr_index (unsigned int idx, unsigned int len)
4450 static char buf[15];
4451 snprintf (buf, sizeof (buf), "[%d]", idx);
4452 printf ("%*s ", len, buf);
4455 /* Display a location list from a .dwo section. It uses address indexes rather
4456 than embedded addresses. This code closely follows display_loc_list, but the
4457 two are sufficiently different that combining things is very ugly. */
4460 display_loc_list_dwo (struct dwarf_section *section,
4461 unsigned char **start_ptr,
4462 unsigned int debug_info_entry,
4463 unsigned long offset,
4466 unsigned char *start = *start_ptr;
4467 unsigned char *section_end = section->start + section->size;
4468 unsigned long cu_offset;
4469 unsigned int pointer_size;
4470 unsigned int offset_size;
4473 unsigned short length;
4474 int need_frame_base;
4476 unsigned int bytes_read;
4478 if (debug_info_entry >= num_debug_info_entries)
4480 warn (_("No debug information for loc lists of entry: %u\n"),
4485 cu_offset = debug_information [debug_info_entry].cu_offset;
4486 pointer_size = debug_information [debug_info_entry].pointer_size;
4487 offset_size = debug_information [debug_info_entry].offset_size;
4488 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4490 if (pointer_size < 2 || pointer_size > 8)
4492 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4493 pointer_size, debug_info_entry);
4499 printf (" %8.8lx ", offset + (start - *start_ptr));
4501 if (start >= section_end)
4503 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4508 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4511 case 0: /* A terminating entry. */
4513 printf (_("<End of list>\n"));
4515 case 1: /* A base-address entry. */
4516 idx = read_uleb128 (start, &bytes_read, section_end);
4517 start += bytes_read;
4518 print_addr_index (idx, 8);
4520 printf (_("(base address selection entry)\n"));
4522 case 2: /* A start/end entry. */
4523 idx = read_uleb128 (start, &bytes_read, section_end);
4524 start += bytes_read;
4525 print_addr_index (idx, 8);
4526 idx = read_uleb128 (start, &bytes_read, section_end);
4527 start += bytes_read;
4528 print_addr_index (idx, 8);
4530 case 3: /* A start/length entry. */
4531 idx = read_uleb128 (start, &bytes_read, section_end);
4532 start += bytes_read;
4533 print_addr_index (idx, 8);
4534 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4535 printf ("%08x ", idx);
4537 case 4: /* An offset pair entry. */
4538 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4539 printf ("%08x ", idx);
4540 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4541 printf ("%08x ", idx);
4544 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4549 if (start + 2 > section_end)
4551 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4556 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4557 if (start + length > section_end)
4559 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4565 need_frame_base = decode_location_expression (start,
4570 cu_offset, section);
4573 if (need_frame_base && !has_frame_base)
4574 printf (_(" [without DW_AT_frame_base]"));
4584 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4586 static dwarf_vma *loc_offsets;
4589 loc_offsets_compar (const void *ap, const void *bp)
4591 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4592 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4594 return (a > b) - (b > a);
4598 display_debug_loc (struct dwarf_section *section, void *file)
4600 unsigned char *start = section->start;
4601 unsigned long bytes;
4602 unsigned char *section_begin = start;
4603 unsigned int num_loc_list = 0;
4604 unsigned long last_offset = 0;
4605 unsigned int first = 0;
4609 int seen_first_offset = 0;
4610 int locs_sorted = 1;
4611 unsigned char *next;
4612 unsigned int *array = NULL;
4613 const char *suffix = strrchr (section->name, '.');
4616 if (suffix && strcmp (suffix, ".dwo") == 0)
4619 bytes = section->size;
4623 printf (_("\nThe %s section is empty.\n"), section->name);
4627 if (load_debug_info (file) == 0)
4629 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4634 /* Check the order of location list in .debug_info section. If
4635 offsets of location lists are in the ascending order, we can
4636 use `debug_information' directly. */
4637 for (i = 0; i < num_debug_info_entries; i++)
4641 num = debug_information [i].num_loc_offsets;
4642 if (num > num_loc_list)
4645 /* Check if we can use `debug_information' directly. */
4646 if (locs_sorted && num != 0)
4648 if (!seen_first_offset)
4650 /* This is the first location list. */
4651 last_offset = debug_information [i].loc_offsets [0];
4653 seen_first_offset = 1;
4659 for (; j < num; j++)
4662 debug_information [i].loc_offsets [j])
4667 last_offset = debug_information [i].loc_offsets [j];
4672 if (!seen_first_offset)
4673 error (_("No location lists in .debug_info section!\n"));
4675 if (debug_information [first].num_loc_offsets > 0
4676 && debug_information [first].loc_offsets [0] != 0)
4677 warn (_("Location lists in %s section start at 0x%s\n"),
4679 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4682 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4683 printf (_("Contents of the %s section:\n\n"), section->name);
4684 printf (_(" Offset Begin End Expression\n"));
4686 seen_first_offset = 0;
4687 for (i = first; i < num_debug_info_entries; i++)
4689 unsigned long offset;
4690 unsigned long base_address;
4695 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4697 loc_offsets = debug_information [i].loc_offsets;
4698 qsort (array, debug_information [i].num_loc_offsets,
4699 sizeof (*array), loc_offsets_compar);
4702 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4704 j = locs_sorted ? k : array[k];
4706 && debug_information [i].loc_offsets [locs_sorted
4707 ? k - 1 : array [k - 1]]
4708 == debug_information [i].loc_offsets [j])
4710 has_frame_base = debug_information [i].have_frame_base [j];
4711 offset = debug_information [i].loc_offsets [j];
4712 next = section_begin + offset;
4713 base_address = debug_information [i].base_address;
4715 if (!seen_first_offset)
4716 seen_first_offset = 1;
4720 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4721 (unsigned long) (start - section_begin),
4722 (unsigned long) offset);
4723 else if (start > next)
4724 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4725 (unsigned long) (start - section_begin),
4726 (unsigned long) offset);
4730 if (offset >= bytes)
4732 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4738 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4740 display_loc_list (section, &start, i, offset, base_address,
4745 if (start < section->start + section->size)
4746 warn (_("There are %ld unused bytes at the end of section %s\n"),
4747 (long) (section->start + section->size - start), section->name);
4754 display_debug_str (struct dwarf_section *section,
4755 void *file ATTRIBUTE_UNUSED)
4757 unsigned char *start = section->start;
4758 unsigned long bytes = section->size;
4759 dwarf_vma addr = section->address;
4763 printf (_("\nThe %s section is empty.\n"), section->name);
4767 printf (_("Contents of the %s section:\n\n"), section->name);
4775 lbytes = (bytes > 16 ? 16 : bytes);
4777 printf (" 0x%8.8lx ", (unsigned long) addr);
4779 for (j = 0; j < 16; j++)
4782 printf ("%2.2x", start[j]);
4790 for (j = 0; j < lbytes; j++)
4793 if (k >= ' ' && k < 0x80)
4812 display_debug_info (struct dwarf_section *section, void *file)
4814 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4818 display_debug_types (struct dwarf_section *section, void *file)
4820 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4824 display_trace_info (struct dwarf_section *section, void *file)
4826 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4830 display_debug_aranges (struct dwarf_section *section,
4831 void *file ATTRIBUTE_UNUSED)
4833 unsigned char *start = section->start;
4834 unsigned char *end = start + section->size;
4836 printf (_("Contents of the %s section:\n\n"), section->name);
4838 /* It does not matter if this load fails,
4839 we test for that later on. */
4840 load_debug_info (file);
4844 unsigned char *hdrptr;
4845 DWARF2_Internal_ARange arange;
4846 unsigned char *addr_ranges;
4849 unsigned char address_size;
4851 unsigned int offset_size;
4852 unsigned int initial_length_size;
4856 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4857 if (arange.ar_length == 0xffffffff)
4859 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4861 initial_length_size = 12;
4866 initial_length_size = 4;
4869 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4870 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4872 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4873 && num_debug_info_entries > 0
4874 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4875 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4876 (unsigned long) arange.ar_info_offset, section->name);
4878 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4879 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4881 if (arange.ar_version != 2 && arange.ar_version != 3)
4883 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4887 printf (_(" Length: %ld\n"),
4888 (long) arange.ar_length);
4889 printf (_(" Version: %d\n"), arange.ar_version);
4890 printf (_(" Offset into .debug_info: 0x%lx\n"),
4891 (unsigned long) arange.ar_info_offset);
4892 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4893 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4895 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4897 /* PR 17512: file: 001-108546-0.001:0.1. */
4898 if (address_size == 0 || address_size > 8)
4900 error (_("Invalid address size in %s section!\n"),
4905 /* The DWARF spec does not require that the address size be a power
4906 of two, but we do. This will have to change if we ever encounter
4907 an uneven architecture. */
4908 if ((address_size & (address_size - 1)) != 0)
4910 warn (_("Pointer size + Segment size is not a power of two.\n"));
4914 if (address_size > 4)
4915 printf (_("\n Address Length\n"));
4917 printf (_("\n Address Length\n"));
4919 addr_ranges = hdrptr;
4921 /* Must pad to an alignment boundary that is twice the address size. */
4922 excess = (hdrptr - start) % (2 * address_size);
4924 addr_ranges += (2 * address_size) - excess;
4926 hdrptr = start + arange.ar_length + initial_length_size;
4927 if (hdrptr < start || hdrptr > end)
4929 error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
4934 while (addr_ranges + 2 * address_size <= start)
4936 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4937 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4940 print_dwarf_vma (address, address_size);
4941 print_dwarf_vma (length, address_size);
4951 /* Comparison function for qsort. */
4953 comp_addr_base (const void * v0, const void * v1)
4955 debug_info * info0 = (debug_info *) v0;
4956 debug_info * info1 = (debug_info *) v1;
4957 return info0->addr_base - info1->addr_base;
4960 /* Display the debug_addr section. */
4962 display_debug_addr (struct dwarf_section *section,
4965 debug_info **debug_addr_info;
4966 unsigned char *entry;
4971 if (section->size == 0)
4973 printf (_("\nThe %s section is empty.\n"), section->name);
4977 if (load_debug_info (file) == 0)
4979 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4984 printf (_("Contents of the %s section:\n\n"), section->name);
4986 /* PR 17531: file: cf38d01b.
4987 We use xcalloc because a corrupt file may not have initialised all of the
4988 fields in the debug_info structure, which means that the sort below might
4989 try to move uninitialised data. */
4990 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
4991 sizeof (debug_info *));
4994 for (i = 0; i < num_debug_info_entries; i++)
4995 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4997 /* PR 17531: file: cf38d01b. */
4998 if (debug_information[i].addr_base >= section->size)
4999 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5000 (unsigned long) debug_information[i].addr_base, i);
5002 debug_addr_info [count++] = debug_information + i;
5005 /* Add a sentinel to make iteration convenient. */
5006 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5007 debug_addr_info [count]->addr_base = section->size;
5008 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
5010 for (i = 0; i < count; i++)
5013 unsigned int address_size = debug_addr_info [i]->pointer_size;
5015 printf (_(" For compilation unit at offset 0x%s:\n"),
5016 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5018 printf (_("\tIndex\tAddress\n"));
5019 entry = section->start + debug_addr_info [i]->addr_base;
5020 end = section->start + debug_addr_info [i + 1]->addr_base;
5024 dwarf_vma base = byte_get (entry, address_size);
5025 printf (_("\t%d:\t"), idx);
5026 print_dwarf_vma (base, address_size);
5028 entry += address_size;
5034 free (debug_addr_info);
5038 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5040 display_debug_str_offsets (struct dwarf_section *section,
5041 void *file ATTRIBUTE_UNUSED)
5043 if (section->size == 0)
5045 printf (_("\nThe %s section is empty.\n"), section->name);
5048 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5049 what the offset size is for this section. */
5053 /* Each debug_information[x].range_lists[y] gets this representation for
5054 sorting purposes. */
5058 /* The debug_information[x].range_lists[y] value. */
5059 unsigned long ranges_offset;
5061 /* Original debug_information to find parameters of the data. */
5062 debug_info *debug_info_p;
5065 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5068 range_entry_compar (const void *ap, const void *bp)
5070 const struct range_entry *a_re = (const struct range_entry *) ap;
5071 const struct range_entry *b_re = (const struct range_entry *) bp;
5072 const unsigned long a = a_re->ranges_offset;
5073 const unsigned long b = b_re->ranges_offset;
5075 return (a > b) - (b > a);
5079 display_debug_ranges (struct dwarf_section *section,
5080 void *file ATTRIBUTE_UNUSED)
5082 unsigned char *start = section->start;
5083 unsigned char *last_start = start;
5084 unsigned long bytes = section->size;
5085 unsigned char *section_begin = start;
5086 unsigned char *finish = start + bytes;
5087 unsigned int num_range_list, i;
5088 struct range_entry *range_entries, *range_entry_fill;
5092 printf (_("\nThe %s section is empty.\n"), section->name);
5096 if (load_debug_info (file) == 0)
5098 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5104 for (i = 0; i < num_debug_info_entries; i++)
5105 num_range_list += debug_information [i].num_range_lists;
5107 if (num_range_list == 0)
5109 /* This can happen when the file was compiled with -gsplit-debug
5110 which removes references to range lists from the primary .o file. */
5111 printf (_("No range lists in .debug_info section.\n"));
5115 range_entries = (struct range_entry *)
5116 xmalloc (sizeof (*range_entries) * num_range_list);
5117 range_entry_fill = range_entries;
5119 for (i = 0; i < num_debug_info_entries; i++)
5121 debug_info *debug_info_p = &debug_information[i];
5124 for (j = 0; j < debug_info_p->num_range_lists; j++)
5126 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5127 range_entry_fill->debug_info_p = debug_info_p;
5132 qsort (range_entries, num_range_list, sizeof (*range_entries),
5133 range_entry_compar);
5135 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5136 warn (_("Range lists in %s section start at 0x%lx\n"),
5137 section->name, range_entries[0].ranges_offset);
5139 printf (_("Contents of the %s section:\n\n"), section->name);
5140 printf (_(" Offset Begin End\n"));
5142 for (i = 0; i < num_range_list; i++)
5144 struct range_entry *range_entry = &range_entries[i];
5145 debug_info *debug_info_p = range_entry->debug_info_p;
5146 unsigned int pointer_size;
5147 unsigned long offset;
5148 unsigned char *next;
5149 unsigned long base_address;
5151 pointer_size = debug_info_p->pointer_size;
5152 offset = range_entry->ranges_offset;
5153 next = section_begin + offset;
5154 base_address = debug_info_p->base_address;
5156 /* PR 17512: file: 001-101485-0.001:0.1. */
5157 if (pointer_size < 2 || pointer_size > 8)
5159 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5160 pointer_size, offset);
5164 if (dwarf_check != 0 && i > 0)
5167 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5168 (unsigned long) (start - section_begin),
5169 (unsigned long) (next - section_begin), section->name);
5170 else if (start > next)
5172 if (next == last_start)
5174 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5175 (unsigned long) (start - section_begin),
5176 (unsigned long) (next - section_begin), section->name);
5182 while (start < finish)
5187 /* Note: we use sign extension here in order to be sure that
5188 we can detect the -1 escape value. Sign extension into the
5189 top 32 bits of a 32-bit address will not affect the values
5190 that we display since we always show hex values, and always
5191 the bottom 32-bits. */
5192 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5193 if (start >= finish)
5195 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5197 printf (" %8.8lx ", offset);
5199 if (begin == 0 && end == 0)
5201 printf (_("<End of list>\n"));
5205 /* Check base address specifiers. */
5206 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5209 print_dwarf_vma (begin, pointer_size);
5210 print_dwarf_vma (end, pointer_size);
5211 printf ("(base address)\n");
5215 print_dwarf_vma (begin + base_address, pointer_size);
5216 print_dwarf_vma (end + base_address, pointer_size);
5219 fputs (_("(start == end)"), stdout);
5220 else if (begin > end)
5221 fputs (_("(start > end)"), stdout);
5228 free (range_entries);
5233 typedef struct Frame_Chunk
5235 struct Frame_Chunk *next;
5236 unsigned char *chunk_start;
5238 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5239 short int *col_type;
5242 unsigned int code_factor;
5247 dwarf_vma cfa_offset;
5249 unsigned char fde_encoding;
5250 unsigned char cfa_exp;
5251 unsigned char ptr_size;
5252 unsigned char segment_size;
5256 static const char *const *dwarf_regnames;
5257 static unsigned int dwarf_regnames_count;
5259 /* A marker for a col_type that means this column was never referenced
5260 in the frame info. */
5261 #define DW_CFA_unreferenced (-1)
5263 /* Return 0 if no more space is needed, 1 if more space is needed,
5264 -1 for invalid reg. */
5267 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5269 unsigned int prev = fc->ncols;
5271 if (reg < (unsigned int) fc->ncols)
5274 if (dwarf_regnames_count
5275 && reg > dwarf_regnames_count)
5278 fc->ncols = reg + 1;
5279 /* PR 17512: file: 10450-2643-0.004.
5280 If reg == -1 then this can happen... */
5284 /* PR 17512: file: 2844a11d. */
5285 if (fc->ncols > 1024)
5287 error (_("Unfeasibly large register number: %u\n"), reg);
5289 /* FIXME: 1024 is an arbitrary limit. Increase it if
5290 we ever encounter a valid binary that exceeds it. */
5294 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5295 sizeof (short int));
5296 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5297 /* PR 17512: file:002-10025-0.005. */
5298 if (fc->col_type == NULL || fc->col_offset == NULL)
5300 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5306 while (prev < fc->ncols)
5308 fc->col_type[prev] = DW_CFA_unreferenced;
5309 fc->col_offset[prev] = 0;
5315 static const char *const dwarf_regnames_i386[] =
5317 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5318 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5319 "eip", "eflags", NULL, /* 8 - 10 */
5320 "st0", "st1", "st2", "st3", /* 11 - 14 */
5321 "st4", "st5", "st6", "st7", /* 15 - 18 */
5322 NULL, NULL, /* 19 - 20 */
5323 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5324 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5325 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5326 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5327 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5328 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5329 "tr", "ldtr", /* 48 - 49 */
5330 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5331 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5332 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5333 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5334 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5335 NULL, NULL, NULL, /* 90 - 92 */
5336 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5340 init_dwarf_regnames_i386 (void)
5342 dwarf_regnames = dwarf_regnames_i386;
5343 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5346 static const char *const dwarf_regnames_x86_64[] =
5348 "rax", "rdx", "rcx", "rbx",
5349 "rsi", "rdi", "rbp", "rsp",
5350 "r8", "r9", "r10", "r11",
5351 "r12", "r13", "r14", "r15",
5353 "xmm0", "xmm1", "xmm2", "xmm3",
5354 "xmm4", "xmm5", "xmm6", "xmm7",
5355 "xmm8", "xmm9", "xmm10", "xmm11",
5356 "xmm12", "xmm13", "xmm14", "xmm15",
5357 "st0", "st1", "st2", "st3",
5358 "st4", "st5", "st6", "st7",
5359 "mm0", "mm1", "mm2", "mm3",
5360 "mm4", "mm5", "mm6", "mm7",
5362 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5363 "fs.base", "gs.base", NULL, NULL,
5365 "mxcsr", "fcw", "fsw",
5366 "xmm16", "xmm17", "xmm18", "xmm19",
5367 "xmm20", "xmm21", "xmm22", "xmm23",
5368 "xmm24", "xmm25", "xmm26", "xmm27",
5369 "xmm28", "xmm29", "xmm30", "xmm31",
5370 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5371 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5372 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5373 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5374 NULL, NULL, NULL, /* 115 - 117 */
5375 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5379 init_dwarf_regnames_x86_64 (void)
5381 dwarf_regnames = dwarf_regnames_x86_64;
5382 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5385 static const char *const dwarf_regnames_aarch64[] =
5387 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5388 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5389 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5390 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5391 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5392 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5393 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5394 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5395 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5396 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5397 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5398 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5402 init_dwarf_regnames_aarch64 (void)
5404 dwarf_regnames = dwarf_regnames_aarch64;
5405 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5409 init_dwarf_regnames (unsigned int e_machine)
5415 init_dwarf_regnames_i386 ();
5421 init_dwarf_regnames_x86_64 ();
5425 init_dwarf_regnames_aarch64 ();
5434 regname (unsigned int regno, int row)
5436 static char reg[64];
5438 && regno < dwarf_regnames_count
5439 && dwarf_regnames [regno] != NULL)
5442 return dwarf_regnames [regno];
5443 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5444 dwarf_regnames [regno]);
5447 snprintf (reg, sizeof (reg), "r%d", regno);
5452 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5457 if (*max_regs < fc->ncols)
5458 *max_regs = fc->ncols;
5460 if (*need_col_headers)
5462 static const char *sloc = " LOC";
5464 *need_col_headers = 0;
5466 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5468 for (r = 0; r < *max_regs; r++)
5469 if (fc->col_type[r] != DW_CFA_unreferenced)
5474 printf ("%-5s ", regname (r, 1));
5480 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5482 strcpy (tmp, "exp");
5484 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
5485 printf ("%-8s ", tmp);
5487 for (r = 0; r < fc->ncols; r++)
5489 if (fc->col_type[r] != DW_CFA_unreferenced)
5491 switch (fc->col_type[r])
5493 case DW_CFA_undefined:
5496 case DW_CFA_same_value:
5500 sprintf (tmp, "c%+d", fc->col_offset[r]);
5502 case DW_CFA_val_offset:
5503 sprintf (tmp, "v%+d", fc->col_offset[r]);
5505 case DW_CFA_register:
5506 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5508 case DW_CFA_expression:
5509 strcpy (tmp, "exp");
5511 case DW_CFA_val_expression:
5512 strcpy (tmp, "vexp");
5515 strcpy (tmp, "n/a");
5518 printf ("%-5s ", tmp);
5524 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5525 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5526 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5528 static unsigned char *
5529 read_cie (unsigned char *start, unsigned char *end,
5530 Frame_Chunk **p_cie, int *p_version,
5531 unsigned long *p_aug_len, unsigned char **p_aug)
5535 unsigned int length_return;
5536 unsigned char *augmentation_data = NULL;
5537 unsigned long augmentation_data_len = 0;
5540 /* PR 17512: file: 001-228113-0.004. */
5544 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5545 memset (fc, 0, sizeof (Frame_Chunk));
5547 fc->col_type = (short int *) xmalloc (sizeof (short int));
5548 fc->col_offset = (int *) xmalloc (sizeof (int));
5552 fc->augmentation = (char *) start;
5553 /* PR 17512: file: 001-228113-0.004.
5554 Skip past augmentation name, but avoid running off the end of the data. */
5556 if (* start ++ == '\0')
5560 warn (_("No terminator for augmentation name\n"));
5564 if (strcmp (fc->augmentation, "eh") == 0)
5565 start += eh_addr_size;
5569 GET (fc->ptr_size, 1);
5570 if (fc->ptr_size < 1 || fc->ptr_size > 8)
5572 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5576 GET (fc->segment_size, 1);
5577 /* PR 17512: file: e99d2804. */
5578 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5580 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5584 eh_addr_size = fc->ptr_size;
5588 fc->ptr_size = eh_addr_size;
5589 fc->segment_size = 0;
5591 fc->code_factor = LEB ();
5592 fc->data_factor = SLEB ();
5602 if (fc->augmentation[0] == 'z')
5604 augmentation_data_len = LEB ();
5605 augmentation_data = start;
5606 start += augmentation_data_len;
5607 /* PR 17512: file: 11042-2589-0.004. */
5610 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5615 if (augmentation_data_len)
5619 unsigned char *qend;
5621 p = (unsigned char *) fc->augmentation + 1;
5622 q = augmentation_data;
5623 qend = q + augmentation_data_len;
5625 /* PR 17531: file: 015adfaa. */
5628 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5629 augmentation_data_len = 0;
5632 while (p < end && q < augmentation_data + augmentation_data_len)
5637 q += 1 + size_of_encoded_value (*q);
5639 fc->fde_encoding = *q++;
5646 /* Note - it is OK if this loop terminates with q < qend.
5647 Padding may have been inserted to align the end of the CIE. */
5652 *p_version = version;
5655 *p_aug_len = augmentation_data_len;
5656 *p_aug = augmentation_data;
5662 display_debug_frames (struct dwarf_section *section,
5663 void *file ATTRIBUTE_UNUSED)
5665 unsigned char *start = section->start;
5666 unsigned char *end = start + section->size;
5667 unsigned char *section_start = start;
5668 Frame_Chunk *chunks = 0, *forward_refs = 0;
5669 Frame_Chunk *remembered_state = 0;
5671 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5672 unsigned int length_return;
5673 unsigned int max_regs = 0;
5674 const char *bad_reg = _("bad register: ");
5675 unsigned int saved_eh_addr_size = eh_addr_size;
5677 printf (_("Contents of the %s section:\n"), section->name);
5681 unsigned char *saved_start;
5682 unsigned char *block_end;
5687 int need_col_headers = 1;
5688 unsigned char *augmentation_data = NULL;
5689 unsigned long augmentation_data_len = 0;
5690 unsigned int encoded_ptr_size = saved_eh_addr_size;
5691 unsigned int offset_size;
5692 unsigned int initial_length_size;
5694 saved_start = start;
5696 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5700 printf ("\n%08lx ZERO terminator\n\n",
5701 (unsigned long)(saved_start - section_start));
5702 /* Skip any zero terminators that directly follow.
5703 A corrupt section size could have loaded a whole
5704 slew of zero filled memory bytes. eg
5705 PR 17512: file: 070-19381-0.004. */
5706 while (start < end && * start == 0)
5711 if (length == 0xffffffff)
5713 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5715 initial_length_size = 12;
5720 initial_length_size = 4;
5723 block_end = saved_start + length + initial_length_size;
5724 if (block_end > end || block_end < start)
5726 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5727 dwarf_vmatoa_1 (NULL, length, offset_size),
5728 (unsigned long) (saved_start - section_start));
5732 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5734 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5735 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5740 start = read_cie (start, end, &cie, &version,
5741 &augmentation_data_len, &augmentation_data);
5742 /* PR 17512: file: 027-135133-0.005. */
5749 fc->chunk_start = saved_start;
5750 mreg = max_regs > 0 ? max_regs - 1 : 0;
5753 if (frame_need_space (fc, mreg) < 0)
5755 if (fc->fde_encoding)
5756 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5758 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5759 print_dwarf_vma (length, fc->ptr_size);
5760 print_dwarf_vma (cie_id, offset_size);
5762 if (do_debug_frames_interp)
5764 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5765 fc->code_factor, fc->data_factor, fc->ra);
5770 printf (" Version: %d\n", version);
5771 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5774 printf (" Pointer Size: %u\n", fc->ptr_size);
5775 printf (" Segment Size: %u\n", fc->segment_size);
5777 printf (" Code alignment factor: %u\n", fc->code_factor);
5778 printf (" Data alignment factor: %d\n", fc->data_factor);
5779 printf (" Return address column: %d\n", fc->ra);
5781 if (augmentation_data_len)
5785 printf (" Augmentation data: ");
5786 for (i = 0; i < augmentation_data_len; ++i)
5787 /* FIXME: If do_wide is FALSE, then we should
5788 add carriage returns at 80 columns... */
5789 printf (" %02x", augmentation_data[i]);
5797 unsigned char *look_for;
5798 static Frame_Chunk fde_fc;
5799 unsigned long segment_selector;
5803 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5804 look_for = start - 4 - ((cie_id ^ sign) - sign);
5807 look_for = section_start + cie_id;
5809 if (look_for <= saved_start)
5811 for (cie = chunks; cie ; cie = cie->next)
5812 if (cie->chunk_start == look_for)
5817 for (cie = forward_refs; cie ; cie = cie->next)
5818 if (cie->chunk_start == look_for)
5822 unsigned int off_size;
5823 unsigned char *cie_scan;
5825 cie_scan = look_for;
5827 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5828 if (length == 0xffffffff)
5830 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5837 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5840 : ((off_size == 4 && c_id == DW_CIE_ID)
5841 || (off_size == 8 && c_id == DW64_CIE_ID)))
5846 read_cie (cie_scan, end, &cie, &version,
5847 &augmentation_data_len, &augmentation_data);
5848 /* PR 17512: file: 3450-2098-0.004. */
5851 warn (_("Failed to read CIE information\n"));
5854 cie->next = forward_refs;
5856 cie->chunk_start = look_for;
5857 mreg = max_regs > 0 ? max_regs - 1 : 0;
5860 if (frame_need_space (cie, mreg) < 0)
5862 warn (_("Invalid max register\n"));
5865 if (cie->fde_encoding)
5867 = size_of_encoded_value (cie->fde_encoding);
5874 memset (fc, 0, sizeof (Frame_Chunk));
5878 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5879 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5880 (unsigned long) (saved_start - section_start));
5882 fc->col_type = (short int *) xmalloc (sizeof (short int));
5883 fc->col_offset = (int *) xmalloc (sizeof (int));
5884 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5886 warn (_("Invalid max register\n"));
5890 fc->augmentation = "";
5891 fc->fde_encoding = 0;
5892 fc->ptr_size = eh_addr_size;
5893 fc->segment_size = 0;
5897 fc->ncols = cie->ncols;
5898 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5899 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
5900 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5901 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5902 fc->augmentation = cie->augmentation;
5903 fc->ptr_size = cie->ptr_size;
5904 eh_addr_size = cie->ptr_size;
5905 fc->segment_size = cie->segment_size;
5906 fc->code_factor = cie->code_factor;
5907 fc->data_factor = cie->data_factor;
5908 fc->cfa_reg = cie->cfa_reg;
5909 fc->cfa_offset = cie->cfa_offset;
5911 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5913 warn (_("Invalid max register\n"));
5916 fc->fde_encoding = cie->fde_encoding;
5919 if (fc->fde_encoding)
5920 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5922 segment_selector = 0;
5923 if (fc->segment_size)
5925 if (fc->segment_size > sizeof (segment_selector))
5927 /* PR 17512: file: 9e196b3e. */
5928 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
5929 fc->segment_size = 4;
5931 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5934 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
5936 /* FIXME: It appears that sometimes the final pc_range value is
5937 encoded in less than encoded_ptr_size bytes. See the x86_64
5938 run of the "objcopy on compressed debug sections" test for an
5940 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5942 if (cie->augmentation[0] == 'z')
5944 augmentation_data_len = LEB ();
5945 augmentation_data = start;
5946 start += augmentation_data_len;
5947 /* PR 17512: file: 722-8446-0.004. */
5948 if (start >= end || ((signed long) augmentation_data_len) < 0)
5950 warn (_("Corrupt augmentation data length: %lx\n"),
5951 augmentation_data_len);
5953 augmentation_data = NULL;
5954 augmentation_data_len = 0;
5958 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5959 (unsigned long)(saved_start - section_start),
5960 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5961 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5962 (unsigned long)(cie->chunk_start - section_start));
5964 if (fc->segment_size)
5965 printf ("%04lx:", segment_selector);
5968 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5969 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5971 if (! do_debug_frames_interp && augmentation_data_len)
5975 printf (" Augmentation data: ");
5976 for (i = 0; i < augmentation_data_len; ++i)
5977 printf (" %02x", augmentation_data[i]);
5983 /* At this point, fc is the current chunk, cie (if any) is set, and
5984 we're about to interpret instructions for the chunk. */
5985 /* ??? At present we need to do this always, since this sizes the
5986 fc->col_type and fc->col_offset arrays, which we write into always.
5987 We should probably split the interpreted and non-interpreted bits
5988 into two different routines, since there's so much that doesn't
5989 really overlap between them. */
5990 if (1 || do_debug_frames_interp)
5992 /* Start by making a pass over the chunk, allocating storage
5993 and taking note of what registers are used. */
5994 unsigned char *tmp = start;
5996 while (start < block_end)
5998 unsigned int reg, op, opa;
6000 unsigned char * new_start;
6007 /* Warning: if you add any more cases to this switch, be
6008 sure to add them to the corresponding switch below. */
6011 case DW_CFA_advance_loc:
6015 if (frame_need_space (fc, opa) >= 0)
6016 fc->col_type[opa] = DW_CFA_undefined;
6018 case DW_CFA_restore:
6019 if (frame_need_space (fc, opa) >= 0)
6020 fc->col_type[opa] = DW_CFA_undefined;
6022 case DW_CFA_set_loc:
6023 start += encoded_ptr_size;
6025 case DW_CFA_advance_loc1:
6028 case DW_CFA_advance_loc2:
6031 case DW_CFA_advance_loc4:
6034 case DW_CFA_offset_extended:
6035 case DW_CFA_val_offset:
6036 reg = LEB (); LEB ();
6037 if (frame_need_space (fc, reg) >= 0)
6038 fc->col_type[reg] = DW_CFA_undefined;
6040 case DW_CFA_restore_extended:
6042 if (frame_need_space (fc, reg) >= 0)
6043 fc->col_type[reg] = DW_CFA_undefined;
6045 case DW_CFA_undefined:
6047 if (frame_need_space (fc, reg) >= 0)
6048 fc->col_type[reg] = DW_CFA_undefined;
6050 case DW_CFA_same_value:
6052 if (frame_need_space (fc, reg) >= 0)
6053 fc->col_type[reg] = DW_CFA_undefined;
6055 case DW_CFA_register:
6056 reg = LEB (); LEB ();
6057 if (frame_need_space (fc, reg) >= 0)
6058 fc->col_type[reg] = DW_CFA_undefined;
6060 case DW_CFA_def_cfa:
6063 case DW_CFA_def_cfa_register:
6066 case DW_CFA_def_cfa_offset:
6069 case DW_CFA_def_cfa_expression:
6071 new_start = start + temp;
6072 if (new_start < start)
6074 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6080 case DW_CFA_expression:
6081 case DW_CFA_val_expression:
6084 new_start = start + temp;
6085 if (new_start < start)
6087 /* PR 17512: file:306-192417-0.005. */
6088 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6093 if (frame_need_space (fc, reg) >= 0)
6094 fc->col_type[reg] = DW_CFA_undefined;
6096 case DW_CFA_offset_extended_sf:
6097 case DW_CFA_val_offset_sf:
6098 reg = LEB (); SLEB ();
6099 if (frame_need_space (fc, reg) >= 0)
6100 fc->col_type[reg] = DW_CFA_undefined;
6102 case DW_CFA_def_cfa_sf:
6105 case DW_CFA_def_cfa_offset_sf:
6108 case DW_CFA_MIPS_advance_loc8:
6111 case DW_CFA_GNU_args_size:
6114 case DW_CFA_GNU_negative_offset_extended:
6115 reg = LEB (); LEB ();
6116 if (frame_need_space (fc, reg) >= 0)
6117 fc->col_type[reg] = DW_CFA_undefined;
6126 /* Now we know what registers are used, make a second pass over
6127 the chunk, this time actually printing out the info. */
6129 while (start < block_end)
6131 unsigned char * tmp;
6133 unsigned long ul, reg, roffs;
6137 const char *reg_prefix = "";
6144 /* Warning: if you add any more cases to this switch, be
6145 sure to add them to the corresponding switch above. */
6148 case DW_CFA_advance_loc:
6149 if (do_debug_frames_interp)
6150 frame_display_row (fc, &need_col_headers, &max_regs);
6152 printf (" DW_CFA_advance_loc: %d to %s\n",
6153 opa * fc->code_factor,
6154 dwarf_vmatoa_1 (NULL,
6155 fc->pc_begin + opa * fc->code_factor,
6157 fc->pc_begin += opa * fc->code_factor;
6162 if (opa >= (unsigned int) fc->ncols)
6163 reg_prefix = bad_reg;
6164 if (! do_debug_frames_interp || *reg_prefix != '\0')
6165 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6166 reg_prefix, regname (opa, 0),
6167 roffs * fc->data_factor);
6168 if (*reg_prefix == '\0')
6170 fc->col_type[opa] = DW_CFA_offset;
6171 fc->col_offset[opa] = roffs * fc->data_factor;
6175 case DW_CFA_restore:
6176 if (opa >= (unsigned int) cie->ncols
6177 || opa >= (unsigned int) fc->ncols)
6178 reg_prefix = bad_reg;
6179 if (! do_debug_frames_interp || *reg_prefix != '\0')
6180 printf (" DW_CFA_restore: %s%s\n",
6181 reg_prefix, regname (opa, 0));
6182 if (*reg_prefix == '\0')
6184 fc->col_type[opa] = cie->col_type[opa];
6185 fc->col_offset[opa] = cie->col_offset[opa];
6186 if (do_debug_frames_interp
6187 && fc->col_type[opa] == DW_CFA_unreferenced)
6188 fc->col_type[opa] = DW_CFA_undefined;
6192 case DW_CFA_set_loc:
6193 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6194 if (do_debug_frames_interp)
6195 frame_display_row (fc, &need_col_headers, &max_regs);
6197 printf (" DW_CFA_set_loc: %s\n",
6198 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6202 case DW_CFA_advance_loc1:
6203 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6204 if (do_debug_frames_interp)
6205 frame_display_row (fc, &need_col_headers, &max_regs);
6207 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6208 (unsigned long) (ofs * fc->code_factor),
6209 dwarf_vmatoa_1 (NULL,
6210 fc->pc_begin + ofs * fc->code_factor,
6212 fc->pc_begin += ofs * fc->code_factor;
6215 case DW_CFA_advance_loc2:
6216 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6217 if (do_debug_frames_interp)
6218 frame_display_row (fc, &need_col_headers, &max_regs);
6220 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6221 (unsigned long) (ofs * fc->code_factor),
6222 dwarf_vmatoa_1 (NULL,
6223 fc->pc_begin + ofs * fc->code_factor,
6225 fc->pc_begin += ofs * fc->code_factor;
6228 case DW_CFA_advance_loc4:
6229 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6230 if (do_debug_frames_interp)
6231 frame_display_row (fc, &need_col_headers, &max_regs);
6233 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6234 (unsigned long) (ofs * fc->code_factor),
6235 dwarf_vmatoa_1 (NULL,
6236 fc->pc_begin + ofs * fc->code_factor,
6238 fc->pc_begin += ofs * fc->code_factor;
6241 case DW_CFA_offset_extended:
6244 if (reg >= (unsigned int) fc->ncols)
6245 reg_prefix = bad_reg;
6246 if (! do_debug_frames_interp || *reg_prefix != '\0')
6247 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6248 reg_prefix, regname (reg, 0),
6249 roffs * fc->data_factor);
6250 if (*reg_prefix == '\0')
6252 fc->col_type[reg] = DW_CFA_offset;
6253 fc->col_offset[reg] = roffs * fc->data_factor;
6257 case DW_CFA_val_offset:
6260 if (reg >= (unsigned int) fc->ncols)
6261 reg_prefix = bad_reg;
6262 if (! do_debug_frames_interp || *reg_prefix != '\0')
6263 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6264 reg_prefix, regname (reg, 0),
6265 roffs * fc->data_factor);
6266 if (*reg_prefix == '\0')
6268 fc->col_type[reg] = DW_CFA_val_offset;
6269 fc->col_offset[reg] = roffs * fc->data_factor;
6273 case DW_CFA_restore_extended:
6275 if (reg >= (unsigned int) cie->ncols
6276 || reg >= (unsigned int) fc->ncols)
6277 reg_prefix = bad_reg;
6278 if (! do_debug_frames_interp || *reg_prefix != '\0')
6279 printf (" DW_CFA_restore_extended: %s%s\n",
6280 reg_prefix, regname (reg, 0));
6281 if (*reg_prefix == '\0')
6283 fc->col_type[reg] = cie->col_type[reg];
6284 fc->col_offset[reg] = cie->col_offset[reg];
6288 case DW_CFA_undefined:
6290 if (reg >= (unsigned int) fc->ncols)
6291 reg_prefix = bad_reg;
6292 if (! do_debug_frames_interp || *reg_prefix != '\0')
6293 printf (" DW_CFA_undefined: %s%s\n",
6294 reg_prefix, regname (reg, 0));
6295 if (*reg_prefix == '\0')
6297 fc->col_type[reg] = DW_CFA_undefined;
6298 fc->col_offset[reg] = 0;
6302 case DW_CFA_same_value:
6304 if (reg >= (unsigned int) fc->ncols)
6305 reg_prefix = bad_reg;
6306 if (! do_debug_frames_interp || *reg_prefix != '\0')
6307 printf (" DW_CFA_same_value: %s%s\n",
6308 reg_prefix, regname (reg, 0));
6309 if (*reg_prefix == '\0')
6311 fc->col_type[reg] = DW_CFA_same_value;
6312 fc->col_offset[reg] = 0;
6316 case DW_CFA_register:
6319 if (reg >= (unsigned int) fc->ncols)
6320 reg_prefix = bad_reg;
6321 if (! do_debug_frames_interp || *reg_prefix != '\0')
6323 printf (" DW_CFA_register: %s%s in ",
6324 reg_prefix, regname (reg, 0));
6325 puts (regname (roffs, 0));
6327 if (*reg_prefix == '\0')
6329 fc->col_type[reg] = DW_CFA_register;
6330 fc->col_offset[reg] = roffs;
6334 case DW_CFA_remember_state:
6335 if (! do_debug_frames_interp)
6336 printf (" DW_CFA_remember_state\n");
6337 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6338 rs->cfa_offset = fc->cfa_offset;
6339 rs->cfa_reg = fc->cfa_reg;
6341 rs->cfa_exp = fc->cfa_exp;
6342 rs->ncols = fc->ncols;
6343 rs->col_type = (short int *) xcmalloc (rs->ncols,
6344 sizeof (* rs->col_type));
6345 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6346 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6347 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6348 rs->next = remembered_state;
6349 remembered_state = rs;
6352 case DW_CFA_restore_state:
6353 if (! do_debug_frames_interp)
6354 printf (" DW_CFA_restore_state\n");
6355 rs = remembered_state;
6358 remembered_state = rs->next;
6359 fc->cfa_offset = rs->cfa_offset;
6360 fc->cfa_reg = rs->cfa_reg;
6362 fc->cfa_exp = rs->cfa_exp;
6363 if (frame_need_space (fc, rs->ncols - 1) < 0)
6365 warn (_("Invalid column number in saved frame state\n"));
6369 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6370 memcpy (fc->col_offset, rs->col_offset,
6371 rs->ncols * sizeof (* rs->col_offset));
6372 free (rs->col_type);
6373 free (rs->col_offset);
6376 else if (do_debug_frames_interp)
6377 printf ("Mismatched DW_CFA_restore_state\n");
6380 case DW_CFA_def_cfa:
6381 fc->cfa_reg = LEB ();
6382 fc->cfa_offset = LEB ();
6384 if (! do_debug_frames_interp)
6385 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6386 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6389 case DW_CFA_def_cfa_register:
6390 fc->cfa_reg = LEB ();
6392 if (! do_debug_frames_interp)
6393 printf (" DW_CFA_def_cfa_register: %s\n",
6394 regname (fc->cfa_reg, 0));
6397 case DW_CFA_def_cfa_offset:
6398 fc->cfa_offset = LEB ();
6399 if (! do_debug_frames_interp)
6400 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
6404 if (! do_debug_frames_interp)
6405 printf (" DW_CFA_nop\n");
6408 case DW_CFA_def_cfa_expression:
6410 if (start >= block_end || start + ul > block_end || start + ul < start)
6412 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6415 if (! do_debug_frames_interp)
6417 printf (" DW_CFA_def_cfa_expression (");
6418 decode_location_expression (start, eh_addr_size, 0, -1,
6426 case DW_CFA_expression:
6429 if (reg >= (unsigned int) fc->ncols)
6430 reg_prefix = bad_reg;
6431 /* PR 17512: file: 069-133014-0.006. */
6432 /* PR 17512: file: 98c02eb4. */
6434 if (start >= block_end || tmp > block_end || tmp < start)
6436 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6439 if (! do_debug_frames_interp || *reg_prefix != '\0')
6441 printf (" DW_CFA_expression: %s%s (",
6442 reg_prefix, regname (reg, 0));
6443 decode_location_expression (start, eh_addr_size, 0, -1,
6447 if (*reg_prefix == '\0')
6448 fc->col_type[reg] = DW_CFA_expression;
6452 case DW_CFA_val_expression:
6455 if (reg >= (unsigned int) fc->ncols)
6456 reg_prefix = bad_reg;
6458 if (start >= block_end || tmp > block_end || tmp < start)
6460 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6463 if (! do_debug_frames_interp || *reg_prefix != '\0')
6465 printf (" DW_CFA_val_expression: %s%s (",
6466 reg_prefix, regname (reg, 0));
6467 decode_location_expression (start, eh_addr_size, 0, -1,
6471 if (*reg_prefix == '\0')
6472 fc->col_type[reg] = DW_CFA_val_expression;
6476 case DW_CFA_offset_extended_sf:
6479 if (frame_need_space (fc, reg) < 0)
6480 reg_prefix = bad_reg;
6481 if (! do_debug_frames_interp || *reg_prefix != '\0')
6482 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6483 reg_prefix, regname (reg, 0),
6484 (long)(l * fc->data_factor));
6485 if (*reg_prefix == '\0')
6487 fc->col_type[reg] = DW_CFA_offset;
6488 fc->col_offset[reg] = l * fc->data_factor;
6492 case DW_CFA_val_offset_sf:
6495 if (frame_need_space (fc, reg) < 0)
6496 reg_prefix = bad_reg;
6497 if (! do_debug_frames_interp || *reg_prefix != '\0')
6498 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6499 reg_prefix, regname (reg, 0),
6500 (long)(l * fc->data_factor));
6501 if (*reg_prefix == '\0')
6503 fc->col_type[reg] = DW_CFA_val_offset;
6504 fc->col_offset[reg] = l * fc->data_factor;
6508 case DW_CFA_def_cfa_sf:
6509 fc->cfa_reg = LEB ();
6510 fc->cfa_offset = SLEB ();
6511 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6513 if (! do_debug_frames_interp)
6514 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6515 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6518 case DW_CFA_def_cfa_offset_sf:
6519 fc->cfa_offset = SLEB ();
6520 fc->cfa_offset *= fc->data_factor;
6521 if (! do_debug_frames_interp)
6522 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
6525 case DW_CFA_MIPS_advance_loc8:
6526 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6527 if (do_debug_frames_interp)
6528 frame_display_row (fc, &need_col_headers, &max_regs);
6530 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6531 (unsigned long) (ofs * fc->code_factor),
6532 dwarf_vmatoa_1 (NULL,
6533 fc->pc_begin + ofs * fc->code_factor,
6535 fc->pc_begin += ofs * fc->code_factor;
6538 case DW_CFA_GNU_window_save:
6539 if (! do_debug_frames_interp)
6540 printf (" DW_CFA_GNU_window_save\n");
6543 case DW_CFA_GNU_args_size:
6545 if (! do_debug_frames_interp)
6546 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6549 case DW_CFA_GNU_negative_offset_extended:
6552 if (frame_need_space (fc, reg) < 0)
6553 reg_prefix = bad_reg;
6554 if (! do_debug_frames_interp || *reg_prefix != '\0')
6555 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6556 reg_prefix, regname (reg, 0),
6557 (long)(l * fc->data_factor));
6558 if (*reg_prefix == '\0')
6560 fc->col_type[reg] = DW_CFA_offset;
6561 fc->col_offset[reg] = l * fc->data_factor;
6566 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6567 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6569 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6574 if (do_debug_frames_interp)
6575 frame_display_row (fc, &need_col_headers, &max_regs);
6578 eh_addr_size = saved_eh_addr_size;
6591 display_gdb_index (struct dwarf_section *section,
6592 void *file ATTRIBUTE_UNUSED)
6594 unsigned char *start = section->start;
6596 uint32_t cu_list_offset, tu_list_offset;
6597 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6598 unsigned int cu_list_elements, tu_list_elements;
6599 unsigned int address_table_size, symbol_table_slots;
6600 unsigned char *cu_list, *tu_list;
6601 unsigned char *address_table, *symbol_table, *constant_pool;
6604 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6606 printf (_("Contents of the %s section:\n"), section->name);
6608 if (section->size < 6 * sizeof (uint32_t))
6610 warn (_("Truncated header in the %s section.\n"), section->name);
6614 version = byte_get_little_endian (start, 4);
6615 printf (_("Version %ld\n"), (long) version);
6617 /* Prior versions are obsolete, and future versions may not be
6618 backwards compatible. */
6619 if (version < 3 || version > 8)
6621 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6625 warn (_("The address table data in version 3 may be wrong.\n"));
6627 warn (_("Version 4 does not support case insensitive lookups.\n"));
6629 warn (_("Version 5 does not include inlined functions.\n"));
6631 warn (_("Version 6 does not include symbol attributes.\n"));
6632 /* Version 7 indices generated by Gold have bad type unit references,
6633 PR binutils/15021. But we don't know if the index was generated by
6634 Gold or not, so to avoid worrying users with gdb-generated indices
6635 we say nothing for version 7 here. */
6637 cu_list_offset = byte_get_little_endian (start + 4, 4);
6638 tu_list_offset = byte_get_little_endian (start + 8, 4);
6639 address_table_offset = byte_get_little_endian (start + 12, 4);
6640 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6641 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6643 if (cu_list_offset > section->size
6644 || tu_list_offset > section->size
6645 || address_table_offset > section->size
6646 || symbol_table_offset > section->size
6647 || constant_pool_offset > section->size)
6649 warn (_("Corrupt header in the %s section.\n"), section->name);
6653 /* PR 17531: file: 418d0a8a. */
6654 if (tu_list_offset < cu_list_offset)
6656 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6657 tu_list_offset, cu_list_offset);
6661 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6663 if (address_table_offset < tu_list_offset)
6665 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6666 address_table_offset, tu_list_offset);
6670 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6672 /* PR 17531: file: 18a47d3d. */
6673 if (symbol_table_offset < address_table_offset)
6675 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6676 symbol_table_offset, address_table_offset);
6680 address_table_size = symbol_table_offset - address_table_offset;
6682 if (constant_pool_offset < symbol_table_offset)
6684 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6685 constant_pool_offset, symbol_table_offset);
6689 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6691 cu_list = start + cu_list_offset;
6692 tu_list = start + tu_list_offset;
6693 address_table = start + address_table_offset;
6694 symbol_table = start + symbol_table_offset;
6695 constant_pool = start + constant_pool_offset;
6697 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6699 warn (_("Address table extends beyond end of section.\n"));
6703 printf (_("\nCU table:\n"));
6704 for (i = 0; i < cu_list_elements; i += 2)
6706 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6707 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6709 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6710 (unsigned long) cu_offset,
6711 (unsigned long) (cu_offset + cu_length - 1));
6714 printf (_("\nTU table:\n"));
6715 for (i = 0; i < tu_list_elements; i += 3)
6717 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6718 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6719 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6721 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6722 (unsigned long) tu_offset,
6723 (unsigned long) type_offset);
6724 print_dwarf_vma (signature, 8);
6728 printf (_("\nAddress table:\n"));
6729 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6732 uint64_t low = byte_get_little_endian (address_table + i, 8);
6733 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6734 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6736 print_dwarf_vma (low, 8);
6737 print_dwarf_vma (high, 8);
6738 printf (_("%lu\n"), (unsigned long) cu_index);
6741 printf (_("\nSymbol table:\n"));
6742 for (i = 0; i < symbol_table_slots; ++i)
6744 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6745 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6746 uint32_t num_cus, cu;
6748 if (name_offset != 0
6749 || cu_vector_offset != 0)
6752 unsigned char * adr;
6754 adr = constant_pool + name_offset;
6755 /* PR 17531: file: 5b7b07ad. */
6756 if (adr < constant_pool || adr >= section->start + section->size)
6758 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6759 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6763 printf ("[%3u] %.*s:", i,
6764 (int) (section->size - (constant_pool_offset + name_offset)),
6765 constant_pool + name_offset);
6767 adr = constant_pool + cu_vector_offset;
6768 if (adr < constant_pool || adr >= section->start + section->size - 3)
6770 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6771 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6772 cu_vector_offset, i);
6776 num_cus = byte_get_little_endian (adr, 4);
6778 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
6779 if (num_cus * 4 < num_cus
6780 || adr >= section->start + section->size
6781 || adr < constant_pool)
6783 printf ("<invalid number of CUs: %d>\n", num_cus);
6784 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6792 for (j = 0; j < num_cus; ++j)
6795 gdb_index_symbol_kind kind;
6797 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6798 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6799 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6800 cu = GDB_INDEX_CU_VALUE (cu);
6801 /* Convert to TU number if it's for a type unit. */
6802 if (cu >= cu_list_elements / 2)
6803 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6804 (unsigned long) (cu - cu_list_elements / 2));
6806 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6808 printf (" [%s, %s]",
6809 is_static ? _("static") : _("global"),
6810 get_gdb_index_symbol_kind_name (kind));
6822 /* Pre-allocate enough space for the CU/TU sets needed. */
6825 prealloc_cu_tu_list (unsigned int nshndx)
6827 if (shndx_pool == NULL)
6829 shndx_pool_size = nshndx;
6830 shndx_pool_used = 0;
6831 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6832 sizeof (unsigned int));
6836 shndx_pool_size = shndx_pool_used + nshndx;
6837 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6838 sizeof (unsigned int));
6843 add_shndx_to_cu_tu_entry (unsigned int shndx)
6845 if (shndx_pool_used >= shndx_pool_size)
6847 error (_("Internal error: out of space in the shndx pool.\n"));
6850 shndx_pool [shndx_pool_used++] = shndx;
6854 end_cu_tu_entry (void)
6856 if (shndx_pool_used >= shndx_pool_size)
6858 error (_("Internal error: out of space in the shndx pool.\n"));
6861 shndx_pool [shndx_pool_used++] = 0;
6864 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6867 get_DW_SECT_short_name (unsigned int dw_sect)
6869 static char buf[16];
6877 case DW_SECT_ABBREV:
6883 case DW_SECT_STR_OFFSETS:
6885 case DW_SECT_MACINFO:
6893 snprintf (buf, sizeof (buf), "%d", dw_sect);
6897 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6898 These sections are extensions for Fission.
6899 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6902 process_cu_tu_index (struct dwarf_section *section, int do_display)
6904 unsigned char *phdr = section->start;
6905 unsigned char *limit = phdr + section->size;
6906 unsigned char *phash;
6907 unsigned char *pindex;
6908 unsigned char *ppool;
6909 unsigned int version;
6910 unsigned int ncols = 0;
6912 unsigned int nslots;
6915 dwarf_vma signature_high;
6916 dwarf_vma signature_low;
6919 /* PR 17512: file: 002-168123-0.004. */
6922 warn (_("Section %s is empty\n"), section->name);
6925 /* PR 17512: file: 002-376-0.004. */
6926 if (section->size < 24)
6928 warn (_("Section %s is too small to contain a CU/TU header\n"),
6933 SAFE_BYTE_GET (version, phdr, 4, limit);
6935 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6936 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6937 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6940 pindex = phash + nslots * 8;
6941 ppool = pindex + nslots * 4;
6943 /* PR 17531: file: 45d69832. */
6944 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
6946 warn (_("Section %s is too small for %d slots\n"),
6947 section->name, nslots);
6953 printf (_("Contents of the %s section:\n\n"), section->name);
6954 printf (_(" Version: %d\n"), version);
6956 printf (_(" Number of columns: %d\n"), ncols);
6957 printf (_(" Number of used entries: %d\n"), nused);
6958 printf (_(" Number of slots: %d\n\n"), nslots);
6961 if (ppool > limit || ppool < phdr)
6963 warn (_("Section %s too small for %d hash table entries\n"),
6964 section->name, nslots);
6971 prealloc_cu_tu_list ((limit - ppool) / 4);
6972 for (i = 0; i < nslots; i++)
6974 unsigned char *shndx_list;
6977 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
6978 if (signature_high != 0 || signature_low != 0)
6980 SAFE_BYTE_GET (j, pindex, 4, limit);
6981 shndx_list = ppool + j * 4;
6982 /* PR 17531: file: 705e010d. */
6983 if (shndx_list < ppool)
6985 warn (_("Section index pool located before start of section\n"));
6990 printf (_(" [%3d] Signature: 0x%s Sections: "),
6991 i, dwarf_vmatoa64 (signature_high, signature_low,
6992 buf, sizeof (buf)));
6995 if (shndx_list >= limit)
6997 warn (_("Section %s too small for shndx pool\n"),
7001 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
7005 printf (" %d", shndx);
7007 add_shndx_to_cu_tu_entry (shndx);
7019 else if (version == 2)
7022 unsigned int dw_sect;
7023 unsigned char *ph = phash;
7024 unsigned char *pi = pindex;
7025 unsigned char *poffsets = ppool + ncols * 4;
7026 unsigned char *psizes = poffsets + nused * ncols * 4;
7027 unsigned char *pend = psizes + nused * ncols * 4;
7028 bfd_boolean is_tu_index;
7029 struct cu_tu_set *this_set = NULL;
7031 unsigned char *prow;
7033 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7035 /* PR 17531: file: 0dd159bf.
7036 Check for wraparound with an overlarge ncols value. */
7037 if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
7039 warn (_("Overlarge number of columns: %x\n"), ncols);
7045 warn (_("Section %s too small for offset and size tables\n"),
7052 printf (_(" Offset table\n"));
7053 printf (" slot %-16s ",
7054 is_tu_index ? _("signature") : _("dwo_id"));
7061 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7067 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7074 for (j = 0; j < ncols; j++)
7076 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7077 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7082 for (i = 0; i < nslots; i++)
7084 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7086 SAFE_BYTE_GET (row, pi, 4, limit);
7089 /* PR 17531: file: a05f6ab3. */
7092 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7098 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7100 prow = poffsets + (row - 1) * ncols * 4;
7101 /* PR 17531: file: b8ce60a8. */
7102 if (prow < poffsets || prow > limit)
7104 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7110 printf (_(" [%3d] 0x%s"),
7111 i, dwarf_vmatoa64 (signature_high, signature_low,
7112 buf, sizeof (buf)));
7113 for (j = 0; j < ncols; j++)
7115 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7117 printf (" %8d", val);
7120 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7122 /* PR 17531: file: 10796eb3. */
7123 if (dw_sect >= DW_SECT_MAX)
7124 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7126 this_set [row - 1].section_offsets [dw_sect] = val;
7142 printf (_(" Size table\n"));
7143 printf (" slot %-16s ",
7144 is_tu_index ? _("signature") : _("dwo_id"));
7147 for (j = 0; j < ncols; j++)
7149 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7151 printf (" %8s", get_DW_SECT_short_name (val));
7157 for (i = 0; i < nslots; i++)
7159 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7161 SAFE_BYTE_GET (row, pi, 4, limit);
7164 prow = psizes + (row - 1) * ncols * 4;
7167 printf (_(" [%3d] 0x%s"),
7168 i, dwarf_vmatoa64 (signature_high, signature_low,
7169 buf, sizeof (buf)));
7171 for (j = 0; j < ncols; j++)
7173 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7175 printf (" %8d", val);
7178 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7179 if (dw_sect >= DW_SECT_MAX)
7180 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7182 this_set [row - 1].section_sizes [dw_sect] = val;
7194 else if (do_display)
7195 printf (_(" Unsupported version (%d)\n"), version);
7203 /* Load the CU and TU indexes if present. This will build a list of
7204 section sets that we can use to associate a .debug_info.dwo section
7205 with its associated .debug_abbrev.dwo section in a .dwp file. */
7208 load_cu_tu_indexes (void *file)
7210 /* If we have already loaded (or tried to load) the CU and TU indexes
7211 then do not bother to repeat the task. */
7212 if (cu_tu_indexes_read)
7215 if (load_debug_section (dwp_cu_index, file))
7216 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7218 if (load_debug_section (dwp_tu_index, file))
7219 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7221 cu_tu_indexes_read = 1;
7224 /* Find the set of sections that includes section SHNDX. */
7227 find_cu_tu_set (void *file, unsigned int shndx)
7231 load_cu_tu_indexes (file);
7233 /* Find SHNDX in the shndx pool. */
7234 for (i = 0; i < shndx_pool_used; i++)
7235 if (shndx_pool [i] == shndx)
7238 if (i >= shndx_pool_used)
7241 /* Now backup to find the first entry in the set. */
7242 while (i > 0 && shndx_pool [i - 1] != 0)
7245 return shndx_pool + i;
7248 /* Display a .debug_cu_index or .debug_tu_index section. */
7251 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7253 return process_cu_tu_index (section, 1);
7257 display_debug_not_supported (struct dwarf_section *section,
7258 void *file ATTRIBUTE_UNUSED)
7260 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7266 /* Like malloc, but takes two parameters like calloc.
7267 Verifies that the first parameter is not too large.
7268 Note: does *not* initialise the allocated memory to zero. */
7270 cmalloc (size_t nmemb, size_t size)
7272 /* Check for overflow. */
7273 if (nmemb >= ~(size_t) 0 / size)
7276 return xmalloc (nmemb * size);
7279 /* Like xmalloc, but takes two parameters like calloc.
7280 Verifies that the first parameter is not too large.
7281 Note: does *not* initialise the allocated memory to zero. */
7283 xcmalloc (size_t nmemb, size_t size)
7285 /* Check for overflow. */
7286 if (nmemb >= ~(size_t) 0 / size)
7289 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7294 return xmalloc (nmemb * size);
7297 /* Like xrealloc, but takes three parameters.
7298 Verifies that the second parameter is not too large.
7299 Note: does *not* initialise any new memory to zero. */
7301 xcrealloc (void *ptr, size_t nmemb, size_t size)
7303 /* Check for overflow. */
7304 if (nmemb >= ~(size_t) 0 / size)
7307 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7312 return xrealloc (ptr, nmemb * size);
7315 /* Like xcalloc, but verifies that the first parameter is not too large. */
7317 xcalloc2 (size_t nmemb, size_t size)
7319 /* Check for overflow. */
7320 if (nmemb >= ~(size_t) 0 / size)
7323 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7328 return xcalloc (nmemb, size);
7332 free_debug_memory (void)
7338 for (i = 0; i < max; i++)
7339 free_debug_section ((enum dwarf_section_display_enum) i);
7341 if (debug_information != NULL)
7343 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7345 for (i = 0; i < num_debug_info_entries; i++)
7347 if (!debug_information [i].max_loc_offsets)
7349 free (debug_information [i].loc_offsets);
7350 free (debug_information [i].have_frame_base);
7352 if (!debug_information [i].max_range_lists)
7353 free (debug_information [i].range_lists);
7356 free (debug_information);
7357 debug_information = NULL;
7358 alloc_num_debug_info_entries = num_debug_info_entries = 0;
7363 dwarf_select_sections_by_names (const char *names)
7367 const char * option;
7371 debug_dump_long_opts;
7373 static const debug_dump_long_opts opts_table [] =
7375 /* Please keep this table alpha- sorted. */
7376 { "Ranges", & do_debug_ranges, 1 },
7377 { "abbrev", & do_debug_abbrevs, 1 },
7378 { "addr", & do_debug_addr, 1 },
7379 { "aranges", & do_debug_aranges, 1 },
7380 { "cu_index", & do_debug_cu_index, 1 },
7381 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7382 { "frames", & do_debug_frames, 1 },
7383 { "frames-interp", & do_debug_frames_interp, 1 },
7384 /* The special .gdb_index section. */
7385 { "gdb_index", & do_gdb_index, 1 },
7386 { "info", & do_debug_info, 1 },
7387 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
7388 { "loc", & do_debug_loc, 1 },
7389 { "macro", & do_debug_macinfo, 1 },
7390 { "pubnames", & do_debug_pubnames, 1 },
7391 { "pubtypes", & do_debug_pubtypes, 1 },
7392 /* This entry is for compatability
7393 with earlier versions of readelf. */
7394 { "ranges", & do_debug_aranges, 1 },
7395 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7396 { "str", & do_debug_str, 1 },
7397 /* These trace_* sections are used by Itanium VMS. */
7398 { "trace_abbrev", & do_trace_abbrevs, 1 },
7399 { "trace_aranges", & do_trace_aranges, 1 },
7400 { "trace_info", & do_trace_info, 1 },
7409 const debug_dump_long_opts * entry;
7411 for (entry = opts_table; entry->option; entry++)
7413 size_t len = strlen (entry->option);
7415 if (strncmp (p, entry->option, len) == 0
7416 && (p[len] == ',' || p[len] == '\0'))
7418 * entry->variable |= entry->val;
7420 /* The --debug-dump=frames-interp option also
7421 enables the --debug-dump=frames option. */
7422 if (do_debug_frames_interp)
7423 do_debug_frames = 1;
7430 if (entry->option == NULL)
7432 warn (_("Unrecognized debug option '%s'\n"), p);
7433 p = strchr (p, ',');
7444 dwarf_select_sections_by_letters (const char *letters)
7446 unsigned int lindex = 0;
7448 while (letters[lindex])
7449 switch (letters[lindex++])
7456 do_debug_abbrevs = 1;
7460 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7464 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7468 do_debug_pubnames = 1;
7472 do_debug_pubtypes = 1;
7476 do_debug_aranges = 1;
7480 do_debug_ranges = 1;
7484 do_debug_frames_interp = 1;
7486 do_debug_frames = 1;
7490 do_debug_macinfo = 1;
7502 warn (_("Unrecognized debug option '%s'\n"), letters);
7508 dwarf_select_sections_all (void)
7511 do_debug_abbrevs = 1;
7512 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7513 do_debug_pubnames = 1;
7514 do_debug_pubtypes = 1;
7515 do_debug_aranges = 1;
7516 do_debug_ranges = 1;
7517 do_debug_frames = 1;
7518 do_debug_macinfo = 1;
7523 do_trace_abbrevs = 1;
7524 do_trace_aranges = 1;
7526 do_debug_cu_index = 1;
7529 struct dwarf_section_display debug_displays[] =
7531 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL },
7532 display_debug_abbrev, &do_debug_abbrevs, 0 },
7533 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL },
7534 display_debug_aranges, &do_debug_aranges, 1 },
7535 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL },
7536 display_debug_frames, &do_debug_frames, 1 },
7537 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL },
7538 display_debug_info, &do_debug_info, 1 },
7539 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL },
7540 display_debug_lines, &do_debug_lines, 1 },
7541 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
7542 display_debug_pubnames, &do_debug_pubnames, 0 },
7543 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
7544 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7545 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL },
7546 display_debug_frames, &do_debug_frames, 1 },
7547 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL },
7548 display_debug_macinfo, &do_debug_macinfo, 0 },
7549 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL },
7550 display_debug_macro, &do_debug_macinfo, 1 },
7551 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL },
7552 display_debug_str, &do_debug_str, 0 },
7553 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL },
7554 display_debug_loc, &do_debug_loc, 1 },
7555 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7556 display_debug_pubnames, &do_debug_pubtypes, 0 },
7557 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7558 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7559 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL },
7560 display_debug_ranges, &do_debug_ranges, 1 },
7561 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
7562 display_debug_not_supported, NULL, 0 },
7563 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
7564 display_debug_not_supported, NULL, 0 },
7565 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL },
7566 display_debug_types, &do_debug_info, 1 },
7567 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
7568 display_debug_not_supported, NULL, 0 },
7569 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL },
7570 display_gdb_index, &do_gdb_index, 0 },
7571 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL },
7572 display_trace_info, &do_trace_info, 1 },
7573 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL },
7574 display_debug_abbrev, &do_trace_abbrevs, 0 },
7575 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL },
7576 display_debug_aranges, &do_trace_aranges, 0 },
7577 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7578 display_debug_info, &do_debug_info, 1 },
7579 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
7580 display_debug_abbrev, &do_debug_abbrevs, 0 },
7581 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7582 display_debug_types, &do_debug_info, 1 },
7583 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
7584 display_debug_lines, &do_debug_lines, 1 },
7585 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL },
7586 display_debug_loc, &do_debug_loc, 1 },
7587 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
7588 display_debug_macro, &do_debug_macinfo, 1 },
7589 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
7590 display_debug_macinfo, &do_debug_macinfo, 0 },
7591 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL },
7592 display_debug_str, &do_debug_str, 1 },
7593 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
7594 display_debug_str_offsets, NULL, 0 },
7595 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
7596 display_debug_str_offsets, NULL, 0 },
7597 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL },
7598 display_debug_addr, &do_debug_addr, 1 },
7599 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL },
7600 display_cu_index, &do_debug_cu_index, 0 },
7601 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL },
7602 display_cu_index, &do_debug_cu_index, 0 },