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) (next - section_begin));
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) (next - section_begin));
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 start += arange.ar_length + initial_length_size;
4928 while (addr_ranges + 2 * address_size <= start)
4930 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4931 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4934 print_dwarf_vma (address, address_size);
4935 print_dwarf_vma (length, address_size);
4945 /* Comparison function for qsort. */
4947 comp_addr_base (const void * v0, const void * v1)
4949 debug_info * info0 = (debug_info *) v0;
4950 debug_info * info1 = (debug_info *) v1;
4951 return info0->addr_base - info1->addr_base;
4954 /* Display the debug_addr section. */
4956 display_debug_addr (struct dwarf_section *section,
4959 debug_info **debug_addr_info;
4960 unsigned char *entry;
4965 if (section->size == 0)
4967 printf (_("\nThe %s section is empty.\n"), section->name);
4971 if (load_debug_info (file) == 0)
4973 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4978 printf (_("Contents of the %s section:\n\n"), section->name);
4980 /* PR 17531: file: cf38d01b.
4981 We use xcalloc because a corrupt file may not have initialised all of the
4982 fields in the debug_info structure, which means that the sort below might
4983 try to move uninitialised data. */
4984 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
4985 sizeof (debug_info *));
4988 for (i = 0; i < num_debug_info_entries; i++)
4989 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4991 /* PR 17531: file: cf38d01b. */
4992 if (debug_information[i].addr_base >= section->size)
4993 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
4994 (unsigned long) debug_information[i].addr_base, i);
4996 debug_addr_info [count++] = debug_information + i;
4999 /* Add a sentinel to make iteration convenient. */
5000 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5001 debug_addr_info [count]->addr_base = section->size;
5002 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
5004 for (i = 0; i < count; i++)
5007 unsigned int address_size = debug_addr_info [i]->pointer_size;
5009 printf (_(" For compilation unit at offset 0x%s:\n"),
5010 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5012 printf (_("\tIndex\tAddress\n"));
5013 entry = section->start + debug_addr_info [i]->addr_base;
5014 end = section->start + debug_addr_info [i + 1]->addr_base;
5018 dwarf_vma base = byte_get (entry, address_size);
5019 printf (_("\t%d:\t"), idx);
5020 print_dwarf_vma (base, address_size);
5022 entry += address_size;
5028 free (debug_addr_info);
5032 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5034 display_debug_str_offsets (struct dwarf_section *section,
5035 void *file ATTRIBUTE_UNUSED)
5037 if (section->size == 0)
5039 printf (_("\nThe %s section is empty.\n"), section->name);
5042 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5043 what the offset size is for this section. */
5047 /* Each debug_information[x].range_lists[y] gets this representation for
5048 sorting purposes. */
5052 /* The debug_information[x].range_lists[y] value. */
5053 unsigned long ranges_offset;
5055 /* Original debug_information to find parameters of the data. */
5056 debug_info *debug_info_p;
5059 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5062 range_entry_compar (const void *ap, const void *bp)
5064 const struct range_entry *a_re = (const struct range_entry *) ap;
5065 const struct range_entry *b_re = (const struct range_entry *) bp;
5066 const unsigned long a = a_re->ranges_offset;
5067 const unsigned long b = b_re->ranges_offset;
5069 return (a > b) - (b > a);
5073 display_debug_ranges (struct dwarf_section *section,
5074 void *file ATTRIBUTE_UNUSED)
5076 unsigned char *start = section->start;
5077 unsigned char *last_start = start;
5078 unsigned long bytes = section->size;
5079 unsigned char *section_begin = start;
5080 unsigned char *finish = start + bytes;
5081 unsigned int num_range_list, i;
5082 struct range_entry *range_entries, *range_entry_fill;
5086 printf (_("\nThe %s section is empty.\n"), section->name);
5090 if (load_debug_info (file) == 0)
5092 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5098 for (i = 0; i < num_debug_info_entries; i++)
5099 num_range_list += debug_information [i].num_range_lists;
5101 if (num_range_list == 0)
5103 /* This can happen when the file was compiled with -gsplit-debug
5104 which removes references to range lists from the primary .o file. */
5105 printf (_("No range lists in .debug_info section.\n"));
5109 range_entries = (struct range_entry *)
5110 xmalloc (sizeof (*range_entries) * num_range_list);
5111 range_entry_fill = range_entries;
5113 for (i = 0; i < num_debug_info_entries; i++)
5115 debug_info *debug_info_p = &debug_information[i];
5118 for (j = 0; j < debug_info_p->num_range_lists; j++)
5120 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5121 range_entry_fill->debug_info_p = debug_info_p;
5126 qsort (range_entries, num_range_list, sizeof (*range_entries),
5127 range_entry_compar);
5129 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5130 warn (_("Range lists in %s section start at 0x%lx\n"),
5131 section->name, range_entries[0].ranges_offset);
5133 printf (_("Contents of the %s section:\n\n"), section->name);
5134 printf (_(" Offset Begin End\n"));
5136 for (i = 0; i < num_range_list; i++)
5138 struct range_entry *range_entry = &range_entries[i];
5139 debug_info *debug_info_p = range_entry->debug_info_p;
5140 unsigned int pointer_size;
5141 unsigned long offset;
5142 unsigned char *next;
5143 unsigned long base_address;
5145 pointer_size = debug_info_p->pointer_size;
5146 offset = range_entry->ranges_offset;
5147 next = section_begin + offset;
5148 base_address = debug_info_p->base_address;
5150 /* PR 17512: file: 001-101485-0.001:0.1. */
5151 if (pointer_size < 2 || pointer_size > 8)
5153 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5154 pointer_size, offset);
5158 if (dwarf_check != 0 && i > 0)
5161 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5162 (unsigned long) (start - section_begin),
5163 (unsigned long) (next - section_begin), section->name);
5164 else if (start > next)
5166 if (next == last_start)
5168 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5169 (unsigned long) (start - section_begin),
5170 (unsigned long) (next - section_begin), section->name);
5176 while (start < finish)
5181 /* Note: we use sign extension here in order to be sure that
5182 we can detect the -1 escape value. Sign extension into the
5183 top 32 bits of a 32-bit address will not affect the values
5184 that we display since we always show hex values, and always
5185 the bottom 32-bits. */
5186 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5187 if (start >= finish)
5189 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5191 printf (" %8.8lx ", offset);
5193 if (begin == 0 && end == 0)
5195 printf (_("<End of list>\n"));
5199 /* Check base address specifiers. */
5200 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5203 print_dwarf_vma (begin, pointer_size);
5204 print_dwarf_vma (end, pointer_size);
5205 printf ("(base address)\n");
5209 print_dwarf_vma (begin + base_address, pointer_size);
5210 print_dwarf_vma (end + base_address, pointer_size);
5213 fputs (_("(start == end)"), stdout);
5214 else if (begin > end)
5215 fputs (_("(start > end)"), stdout);
5222 free (range_entries);
5227 typedef struct Frame_Chunk
5229 struct Frame_Chunk *next;
5230 unsigned char *chunk_start;
5232 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5233 short int *col_type;
5236 unsigned int code_factor;
5243 unsigned char fde_encoding;
5244 unsigned char cfa_exp;
5245 unsigned char ptr_size;
5246 unsigned char segment_size;
5250 static const char *const *dwarf_regnames;
5251 static unsigned int dwarf_regnames_count;
5253 /* A marker for a col_type that means this column was never referenced
5254 in the frame info. */
5255 #define DW_CFA_unreferenced (-1)
5257 /* Return 0 if no more space is needed, 1 if more space is needed,
5258 -1 for invalid reg. */
5261 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5263 unsigned int prev = fc->ncols;
5265 if (reg < (unsigned int) fc->ncols)
5268 if (dwarf_regnames_count
5269 && reg > dwarf_regnames_count)
5272 fc->ncols = reg + 1;
5273 /* PR 17512: file: 10450-2643-0.004.
5274 If reg == -1 then this can happen... */
5278 /* PR 17512: file: 2844a11d. */
5279 if (fc->ncols > 1024)
5281 error (_("Unfeasibly large register number: %u\n"), reg);
5283 /* FIXME: 1024 is an arbitrary limit. Increase it if
5284 we ever encounter a valid binary that exceeds it. */
5288 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5289 sizeof (short int));
5290 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5291 /* PR 17512: file:002-10025-0.005. */
5292 if (fc->col_type == NULL || fc->col_offset == NULL)
5294 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5300 while (prev < fc->ncols)
5302 fc->col_type[prev] = DW_CFA_unreferenced;
5303 fc->col_offset[prev] = 0;
5309 static const char *const dwarf_regnames_i386[] =
5311 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5312 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5313 "eip", "eflags", NULL, /* 8 - 10 */
5314 "st0", "st1", "st2", "st3", /* 11 - 14 */
5315 "st4", "st5", "st6", "st7", /* 15 - 18 */
5316 NULL, NULL, /* 19 - 20 */
5317 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5318 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5319 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5320 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5321 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5322 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5323 "tr", "ldtr", /* 48 - 49 */
5324 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5325 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5326 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5327 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5328 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5329 NULL, NULL, NULL, /* 90 - 92 */
5330 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5334 init_dwarf_regnames_i386 (void)
5336 dwarf_regnames = dwarf_regnames_i386;
5337 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5340 static const char *const dwarf_regnames_x86_64[] =
5342 "rax", "rdx", "rcx", "rbx",
5343 "rsi", "rdi", "rbp", "rsp",
5344 "r8", "r9", "r10", "r11",
5345 "r12", "r13", "r14", "r15",
5347 "xmm0", "xmm1", "xmm2", "xmm3",
5348 "xmm4", "xmm5", "xmm6", "xmm7",
5349 "xmm8", "xmm9", "xmm10", "xmm11",
5350 "xmm12", "xmm13", "xmm14", "xmm15",
5351 "st0", "st1", "st2", "st3",
5352 "st4", "st5", "st6", "st7",
5353 "mm0", "mm1", "mm2", "mm3",
5354 "mm4", "mm5", "mm6", "mm7",
5356 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5357 "fs.base", "gs.base", NULL, NULL,
5359 "mxcsr", "fcw", "fsw",
5360 "xmm16", "xmm17", "xmm18", "xmm19",
5361 "xmm20", "xmm21", "xmm22", "xmm23",
5362 "xmm24", "xmm25", "xmm26", "xmm27",
5363 "xmm28", "xmm29", "xmm30", "xmm31",
5364 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5365 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5366 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5367 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5368 NULL, NULL, NULL, /* 115 - 117 */
5369 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5373 init_dwarf_regnames_x86_64 (void)
5375 dwarf_regnames = dwarf_regnames_x86_64;
5376 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5379 static const char *const dwarf_regnames_aarch64[] =
5381 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5382 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5383 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5384 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5385 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5386 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5387 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5388 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5389 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5390 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5391 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5392 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5396 init_dwarf_regnames_aarch64 (void)
5398 dwarf_regnames = dwarf_regnames_aarch64;
5399 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5403 init_dwarf_regnames (unsigned int e_machine)
5409 init_dwarf_regnames_i386 ();
5415 init_dwarf_regnames_x86_64 ();
5419 init_dwarf_regnames_aarch64 ();
5428 regname (unsigned int regno, int row)
5430 static char reg[64];
5432 && regno < dwarf_regnames_count
5433 && dwarf_regnames [regno] != NULL)
5436 return dwarf_regnames [regno];
5437 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5438 dwarf_regnames [regno]);
5441 snprintf (reg, sizeof (reg), "r%d", regno);
5446 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5451 if (*max_regs < fc->ncols)
5452 *max_regs = fc->ncols;
5454 if (*need_col_headers)
5456 static const char *sloc = " LOC";
5458 *need_col_headers = 0;
5460 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5462 for (r = 0; r < *max_regs; r++)
5463 if (fc->col_type[r] != DW_CFA_unreferenced)
5468 printf ("%-5s ", regname (r, 1));
5474 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5476 strcpy (tmp, "exp");
5478 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5479 printf ("%-8s ", tmp);
5481 for (r = 0; r < fc->ncols; r++)
5483 if (fc->col_type[r] != DW_CFA_unreferenced)
5485 switch (fc->col_type[r])
5487 case DW_CFA_undefined:
5490 case DW_CFA_same_value:
5494 sprintf (tmp, "c%+d", fc->col_offset[r]);
5496 case DW_CFA_val_offset:
5497 sprintf (tmp, "v%+d", fc->col_offset[r]);
5499 case DW_CFA_register:
5500 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5502 case DW_CFA_expression:
5503 strcpy (tmp, "exp");
5505 case DW_CFA_val_expression:
5506 strcpy (tmp, "vexp");
5509 strcpy (tmp, "n/a");
5512 printf ("%-5s ", tmp);
5518 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5519 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5520 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5522 static unsigned char *
5523 read_cie (unsigned char *start, unsigned char *end,
5524 Frame_Chunk **p_cie, int *p_version,
5525 unsigned long *p_aug_len, unsigned char **p_aug)
5529 unsigned int length_return;
5530 unsigned char *augmentation_data = NULL;
5531 unsigned long augmentation_data_len = 0;
5534 /* PR 17512: file: 001-228113-0.004. */
5538 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5539 memset (fc, 0, sizeof (Frame_Chunk));
5541 fc->col_type = (short int *) xmalloc (sizeof (short int));
5542 fc->col_offset = (int *) xmalloc (sizeof (int));
5546 fc->augmentation = (char *) start;
5547 /* PR 17512: file: 001-228113-0.004.
5548 Skip past augmentation name, but avoid running off the end of the data. */
5550 if (* start ++ == '\0')
5554 warn (_("No terminator for augmentation name\n"));
5558 if (strcmp (fc->augmentation, "eh") == 0)
5559 start += eh_addr_size;
5563 GET (fc->ptr_size, 1);
5564 if (fc->ptr_size < 1 || fc->ptr_size > 8)
5566 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5570 GET (fc->segment_size, 1);
5571 /* PR 17512: file: e99d2804. */
5572 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5574 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5578 eh_addr_size = fc->ptr_size;
5582 fc->ptr_size = eh_addr_size;
5583 fc->segment_size = 0;
5585 fc->code_factor = LEB ();
5586 fc->data_factor = SLEB ();
5596 if (fc->augmentation[0] == 'z')
5598 augmentation_data_len = LEB ();
5599 augmentation_data = start;
5600 start += augmentation_data_len;
5601 /* PR 17512: file: 11042-2589-0.004. */
5604 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5609 if (augmentation_data_len)
5613 unsigned char *qend;
5615 p = (unsigned char *) fc->augmentation + 1;
5616 q = augmentation_data;
5617 qend = q + augmentation_data_len;
5619 /* PR 17531: file: 015adfaa. */
5622 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5623 augmentation_data_len = 0;
5626 while (p < end && q < augmentation_data + augmentation_data_len)
5631 q += 1 + size_of_encoded_value (*q);
5633 fc->fde_encoding = *q++;
5640 /* Note - it is OK if this loop terminates with q < qend.
5641 Padding may have been inserted to align the end of the CIE. */
5646 *p_version = version;
5649 *p_aug_len = augmentation_data_len;
5650 *p_aug = augmentation_data;
5656 display_debug_frames (struct dwarf_section *section,
5657 void *file ATTRIBUTE_UNUSED)
5659 unsigned char *start = section->start;
5660 unsigned char *end = start + section->size;
5661 unsigned char *section_start = start;
5662 Frame_Chunk *chunks = 0, *forward_refs = 0;
5663 Frame_Chunk *remembered_state = 0;
5665 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5666 unsigned int length_return;
5667 unsigned int max_regs = 0;
5668 const char *bad_reg = _("bad register: ");
5669 unsigned int saved_eh_addr_size = eh_addr_size;
5671 printf (_("Contents of the %s section:\n"), section->name);
5675 unsigned char *saved_start;
5676 unsigned char *block_end;
5681 int need_col_headers = 1;
5682 unsigned char *augmentation_data = NULL;
5683 unsigned long augmentation_data_len = 0;
5684 unsigned int encoded_ptr_size = saved_eh_addr_size;
5685 unsigned int offset_size;
5686 unsigned int initial_length_size;
5688 saved_start = start;
5690 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5694 printf ("\n%08lx ZERO terminator\n\n",
5695 (unsigned long)(saved_start - section_start));
5696 /* Skip any zero terminators that directly follow.
5697 A corrupt section size could have loaded a whole
5698 slew of zero filled memory bytes. eg
5699 PR 17512: file: 070-19381-0.004. */
5700 while (start < end && * start == 0)
5705 if (length == 0xffffffff)
5707 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5709 initial_length_size = 12;
5714 initial_length_size = 4;
5717 block_end = saved_start + length + initial_length_size;
5718 if (block_end > end || block_end < start)
5720 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5721 dwarf_vmatoa_1 (NULL, length, offset_size),
5722 (unsigned long) (saved_start - section_start));
5726 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5728 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5729 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5734 start = read_cie (start, end, &cie, &version,
5735 &augmentation_data_len, &augmentation_data);
5736 /* PR 17512: file: 027-135133-0.005. */
5743 fc->chunk_start = saved_start;
5744 mreg = max_regs > 0 ? max_regs - 1 : 0;
5747 if (frame_need_space (fc, mreg) < 0)
5749 if (fc->fde_encoding)
5750 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5752 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5753 print_dwarf_vma (length, fc->ptr_size);
5754 print_dwarf_vma (cie_id, offset_size);
5756 if (do_debug_frames_interp)
5758 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5759 fc->code_factor, fc->data_factor, fc->ra);
5764 printf (" Version: %d\n", version);
5765 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5768 printf (" Pointer Size: %u\n", fc->ptr_size);
5769 printf (" Segment Size: %u\n", fc->segment_size);
5771 printf (" Code alignment factor: %u\n", fc->code_factor);
5772 printf (" Data alignment factor: %d\n", fc->data_factor);
5773 printf (" Return address column: %d\n", fc->ra);
5775 if (augmentation_data_len)
5779 printf (" Augmentation data: ");
5780 for (i = 0; i < augmentation_data_len; ++i)
5781 /* FIXME: If do_wide is FALSE, then we should
5782 add carriage returns at 80 columns... */
5783 printf (" %02x", augmentation_data[i]);
5791 unsigned char *look_for;
5792 static Frame_Chunk fde_fc;
5793 unsigned long segment_selector;
5797 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5798 look_for = start - 4 - ((cie_id ^ sign) - sign);
5801 look_for = section_start + cie_id;
5803 if (look_for <= saved_start)
5805 for (cie = chunks; cie ; cie = cie->next)
5806 if (cie->chunk_start == look_for)
5811 for (cie = forward_refs; cie ; cie = cie->next)
5812 if (cie->chunk_start == look_for)
5816 unsigned int off_size;
5817 unsigned char *cie_scan;
5819 cie_scan = look_for;
5821 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5822 if (length == 0xffffffff)
5824 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5831 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5834 : ((off_size == 4 && c_id == DW_CIE_ID)
5835 || (off_size == 8 && c_id == DW64_CIE_ID)))
5840 read_cie (cie_scan, end, &cie, &version,
5841 &augmentation_data_len, &augmentation_data);
5842 /* PR 17512: file: 3450-2098-0.004. */
5845 warn (_("Failed to read CIE information\n"));
5848 cie->next = forward_refs;
5850 cie->chunk_start = look_for;
5851 mreg = max_regs > 0 ? max_regs - 1 : 0;
5854 if (frame_need_space (cie, mreg) < 0)
5856 warn (_("Invalid max register\n"));
5859 if (cie->fde_encoding)
5861 = size_of_encoded_value (cie->fde_encoding);
5868 memset (fc, 0, sizeof (Frame_Chunk));
5872 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5873 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5874 (unsigned long) (saved_start - section_start));
5876 fc->col_type = (short int *) xmalloc (sizeof (short int));
5877 fc->col_offset = (int *) xmalloc (sizeof (int));
5878 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5880 warn (_("Invalid max register\n"));
5884 fc->augmentation = "";
5885 fc->fde_encoding = 0;
5886 fc->ptr_size = eh_addr_size;
5887 fc->segment_size = 0;
5891 fc->ncols = cie->ncols;
5892 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5893 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
5894 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5895 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5896 fc->augmentation = cie->augmentation;
5897 fc->ptr_size = cie->ptr_size;
5898 eh_addr_size = cie->ptr_size;
5899 fc->segment_size = cie->segment_size;
5900 fc->code_factor = cie->code_factor;
5901 fc->data_factor = cie->data_factor;
5902 fc->cfa_reg = cie->cfa_reg;
5903 fc->cfa_offset = cie->cfa_offset;
5905 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5907 warn (_("Invalid max register\n"));
5910 fc->fde_encoding = cie->fde_encoding;
5913 if (fc->fde_encoding)
5914 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5916 segment_selector = 0;
5917 if (fc->segment_size)
5918 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5920 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
5922 /* FIXME: It appears that sometimes the final pc_range value is
5923 encoded in less than encoded_ptr_size bytes. See the x86_64
5924 run of the "objcopy on compressed debug sections" test for an
5926 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5928 if (cie->augmentation[0] == 'z')
5930 augmentation_data_len = LEB ();
5931 augmentation_data = start;
5932 start += augmentation_data_len;
5933 /* PR 17512: file: 722-8446-0.004. */
5934 if (start >= end || ((signed long) augmentation_data_len) < 0)
5936 warn (_("Corrupt augmentation data length: %lx\n"),
5937 augmentation_data_len);
5939 augmentation_data = NULL;
5940 augmentation_data_len = 0;
5944 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5945 (unsigned long)(saved_start - section_start),
5946 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5947 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5948 (unsigned long)(cie->chunk_start - section_start));
5950 if (fc->segment_size)
5951 printf ("%04lx:", segment_selector);
5954 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5955 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5957 if (! do_debug_frames_interp && augmentation_data_len)
5961 printf (" Augmentation data: ");
5962 for (i = 0; i < augmentation_data_len; ++i)
5963 printf (" %02x", augmentation_data[i]);
5969 /* At this point, fc is the current chunk, cie (if any) is set, and
5970 we're about to interpret instructions for the chunk. */
5971 /* ??? At present we need to do this always, since this sizes the
5972 fc->col_type and fc->col_offset arrays, which we write into always.
5973 We should probably split the interpreted and non-interpreted bits
5974 into two different routines, since there's so much that doesn't
5975 really overlap between them. */
5976 if (1 || do_debug_frames_interp)
5978 /* Start by making a pass over the chunk, allocating storage
5979 and taking note of what registers are used. */
5980 unsigned char *tmp = start;
5982 while (start < block_end)
5984 unsigned int reg, op, opa;
5986 unsigned char * new_start;
5993 /* Warning: if you add any more cases to this switch, be
5994 sure to add them to the corresponding switch below. */
5997 case DW_CFA_advance_loc:
6001 if (frame_need_space (fc, opa) >= 0)
6002 fc->col_type[opa] = DW_CFA_undefined;
6004 case DW_CFA_restore:
6005 if (frame_need_space (fc, opa) >= 0)
6006 fc->col_type[opa] = DW_CFA_undefined;
6008 case DW_CFA_set_loc:
6009 start += encoded_ptr_size;
6011 case DW_CFA_advance_loc1:
6014 case DW_CFA_advance_loc2:
6017 case DW_CFA_advance_loc4:
6020 case DW_CFA_offset_extended:
6021 case DW_CFA_val_offset:
6022 reg = LEB (); LEB ();
6023 if (frame_need_space (fc, reg) >= 0)
6024 fc->col_type[reg] = DW_CFA_undefined;
6026 case DW_CFA_restore_extended:
6028 if (frame_need_space (fc, reg) >= 0)
6029 fc->col_type[reg] = DW_CFA_undefined;
6031 case DW_CFA_undefined:
6033 if (frame_need_space (fc, reg) >= 0)
6034 fc->col_type[reg] = DW_CFA_undefined;
6036 case DW_CFA_same_value:
6038 if (frame_need_space (fc, reg) >= 0)
6039 fc->col_type[reg] = DW_CFA_undefined;
6041 case DW_CFA_register:
6042 reg = LEB (); LEB ();
6043 if (frame_need_space (fc, reg) >= 0)
6044 fc->col_type[reg] = DW_CFA_undefined;
6046 case DW_CFA_def_cfa:
6049 case DW_CFA_def_cfa_register:
6052 case DW_CFA_def_cfa_offset:
6055 case DW_CFA_def_cfa_expression:
6057 new_start = start + temp;
6058 if (new_start < start)
6060 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6066 case DW_CFA_expression:
6067 case DW_CFA_val_expression:
6070 new_start = start + temp;
6071 if (new_start < start)
6073 /* PR 17512: file:306-192417-0.005. */
6074 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6079 if (frame_need_space (fc, reg) >= 0)
6080 fc->col_type[reg] = DW_CFA_undefined;
6082 case DW_CFA_offset_extended_sf:
6083 case DW_CFA_val_offset_sf:
6084 reg = LEB (); SLEB ();
6085 if (frame_need_space (fc, reg) >= 0)
6086 fc->col_type[reg] = DW_CFA_undefined;
6088 case DW_CFA_def_cfa_sf:
6091 case DW_CFA_def_cfa_offset_sf:
6094 case DW_CFA_MIPS_advance_loc8:
6097 case DW_CFA_GNU_args_size:
6100 case DW_CFA_GNU_negative_offset_extended:
6101 reg = LEB (); LEB ();
6102 if (frame_need_space (fc, reg) >= 0)
6103 fc->col_type[reg] = DW_CFA_undefined;
6112 /* Now we know what registers are used, make a second pass over
6113 the chunk, this time actually printing out the info. */
6115 while (start < block_end)
6117 unsigned char * tmp;
6119 unsigned long ul, reg, roffs;
6123 const char *reg_prefix = "";
6130 /* Warning: if you add any more cases to this switch, be
6131 sure to add them to the corresponding switch above. */
6134 case DW_CFA_advance_loc:
6135 if (do_debug_frames_interp)
6136 frame_display_row (fc, &need_col_headers, &max_regs);
6138 printf (" DW_CFA_advance_loc: %d to %s\n",
6139 opa * fc->code_factor,
6140 dwarf_vmatoa_1 (NULL,
6141 fc->pc_begin + opa * fc->code_factor,
6143 fc->pc_begin += opa * fc->code_factor;
6148 if (opa >= (unsigned int) fc->ncols)
6149 reg_prefix = bad_reg;
6150 if (! do_debug_frames_interp || *reg_prefix != '\0')
6151 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6152 reg_prefix, regname (opa, 0),
6153 roffs * fc->data_factor);
6154 if (*reg_prefix == '\0')
6156 fc->col_type[opa] = DW_CFA_offset;
6157 fc->col_offset[opa] = roffs * fc->data_factor;
6161 case DW_CFA_restore:
6162 if (opa >= (unsigned int) cie->ncols
6163 || opa >= (unsigned int) fc->ncols)
6164 reg_prefix = bad_reg;
6165 if (! do_debug_frames_interp || *reg_prefix != '\0')
6166 printf (" DW_CFA_restore: %s%s\n",
6167 reg_prefix, regname (opa, 0));
6168 if (*reg_prefix == '\0')
6170 fc->col_type[opa] = cie->col_type[opa];
6171 fc->col_offset[opa] = cie->col_offset[opa];
6172 if (do_debug_frames_interp
6173 && fc->col_type[opa] == DW_CFA_unreferenced)
6174 fc->col_type[opa] = DW_CFA_undefined;
6178 case DW_CFA_set_loc:
6179 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6180 if (do_debug_frames_interp)
6181 frame_display_row (fc, &need_col_headers, &max_regs);
6183 printf (" DW_CFA_set_loc: %s\n",
6184 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6188 case DW_CFA_advance_loc1:
6189 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6190 if (do_debug_frames_interp)
6191 frame_display_row (fc, &need_col_headers, &max_regs);
6193 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6194 (unsigned long) (ofs * fc->code_factor),
6195 dwarf_vmatoa_1 (NULL,
6196 fc->pc_begin + ofs * fc->code_factor,
6198 fc->pc_begin += ofs * fc->code_factor;
6201 case DW_CFA_advance_loc2:
6202 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6203 if (do_debug_frames_interp)
6204 frame_display_row (fc, &need_col_headers, &max_regs);
6206 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6207 (unsigned long) (ofs * fc->code_factor),
6208 dwarf_vmatoa_1 (NULL,
6209 fc->pc_begin + ofs * fc->code_factor,
6211 fc->pc_begin += ofs * fc->code_factor;
6214 case DW_CFA_advance_loc4:
6215 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6216 if (do_debug_frames_interp)
6217 frame_display_row (fc, &need_col_headers, &max_regs);
6219 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6220 (unsigned long) (ofs * fc->code_factor),
6221 dwarf_vmatoa_1 (NULL,
6222 fc->pc_begin + ofs * fc->code_factor,
6224 fc->pc_begin += ofs * fc->code_factor;
6227 case DW_CFA_offset_extended:
6230 if (reg >= (unsigned int) fc->ncols)
6231 reg_prefix = bad_reg;
6232 if (! do_debug_frames_interp || *reg_prefix != '\0')
6233 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6234 reg_prefix, regname (reg, 0),
6235 roffs * fc->data_factor);
6236 if (*reg_prefix == '\0')
6238 fc->col_type[reg] = DW_CFA_offset;
6239 fc->col_offset[reg] = roffs * fc->data_factor;
6243 case DW_CFA_val_offset:
6246 if (reg >= (unsigned int) fc->ncols)
6247 reg_prefix = bad_reg;
6248 if (! do_debug_frames_interp || *reg_prefix != '\0')
6249 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6250 reg_prefix, regname (reg, 0),
6251 roffs * fc->data_factor);
6252 if (*reg_prefix == '\0')
6254 fc->col_type[reg] = DW_CFA_val_offset;
6255 fc->col_offset[reg] = roffs * fc->data_factor;
6259 case DW_CFA_restore_extended:
6261 if (reg >= (unsigned int) cie->ncols
6262 || reg >= (unsigned int) fc->ncols)
6263 reg_prefix = bad_reg;
6264 if (! do_debug_frames_interp || *reg_prefix != '\0')
6265 printf (" DW_CFA_restore_extended: %s%s\n",
6266 reg_prefix, regname (reg, 0));
6267 if (*reg_prefix == '\0')
6269 fc->col_type[reg] = cie->col_type[reg];
6270 fc->col_offset[reg] = cie->col_offset[reg];
6274 case DW_CFA_undefined:
6276 if (reg >= (unsigned int) fc->ncols)
6277 reg_prefix = bad_reg;
6278 if (! do_debug_frames_interp || *reg_prefix != '\0')
6279 printf (" DW_CFA_undefined: %s%s\n",
6280 reg_prefix, regname (reg, 0));
6281 if (*reg_prefix == '\0')
6283 fc->col_type[reg] = DW_CFA_undefined;
6284 fc->col_offset[reg] = 0;
6288 case DW_CFA_same_value:
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_same_value: %s%s\n",
6294 reg_prefix, regname (reg, 0));
6295 if (*reg_prefix == '\0')
6297 fc->col_type[reg] = DW_CFA_same_value;
6298 fc->col_offset[reg] = 0;
6302 case DW_CFA_register:
6305 if (reg >= (unsigned int) fc->ncols)
6306 reg_prefix = bad_reg;
6307 if (! do_debug_frames_interp || *reg_prefix != '\0')
6309 printf (" DW_CFA_register: %s%s in ",
6310 reg_prefix, regname (reg, 0));
6311 puts (regname (roffs, 0));
6313 if (*reg_prefix == '\0')
6315 fc->col_type[reg] = DW_CFA_register;
6316 fc->col_offset[reg] = roffs;
6320 case DW_CFA_remember_state:
6321 if (! do_debug_frames_interp)
6322 printf (" DW_CFA_remember_state\n");
6323 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6324 rs->cfa_offset = fc->cfa_offset;
6325 rs->cfa_reg = fc->cfa_reg;
6327 rs->cfa_exp = fc->cfa_exp;
6328 rs->ncols = fc->ncols;
6329 rs->col_type = (short int *) xcmalloc (rs->ncols,
6330 sizeof (* rs->col_type));
6331 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6332 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6333 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6334 rs->next = remembered_state;
6335 remembered_state = rs;
6338 case DW_CFA_restore_state:
6339 if (! do_debug_frames_interp)
6340 printf (" DW_CFA_restore_state\n");
6341 rs = remembered_state;
6344 remembered_state = rs->next;
6345 fc->cfa_offset = rs->cfa_offset;
6346 fc->cfa_reg = rs->cfa_reg;
6348 fc->cfa_exp = rs->cfa_exp;
6349 if (frame_need_space (fc, rs->ncols - 1) < 0)
6351 warn (_("Invalid column number in saved frame state\n"));
6355 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6356 memcpy (fc->col_offset, rs->col_offset,
6357 rs->ncols * sizeof (* rs->col_offset));
6358 free (rs->col_type);
6359 free (rs->col_offset);
6362 else if (do_debug_frames_interp)
6363 printf ("Mismatched DW_CFA_restore_state\n");
6366 case DW_CFA_def_cfa:
6367 fc->cfa_reg = LEB ();
6368 fc->cfa_offset = LEB ();
6370 if (! do_debug_frames_interp)
6371 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6372 regname (fc->cfa_reg, 0), fc->cfa_offset);
6375 case DW_CFA_def_cfa_register:
6376 fc->cfa_reg = LEB ();
6378 if (! do_debug_frames_interp)
6379 printf (" DW_CFA_def_cfa_register: %s\n",
6380 regname (fc->cfa_reg, 0));
6383 case DW_CFA_def_cfa_offset:
6384 fc->cfa_offset = LEB ();
6385 if (! do_debug_frames_interp)
6386 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6390 if (! do_debug_frames_interp)
6391 printf (" DW_CFA_nop\n");
6394 case DW_CFA_def_cfa_expression:
6396 if (start >= block_end || start + ul > block_end || start + ul < start)
6398 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6401 if (! do_debug_frames_interp)
6403 printf (" DW_CFA_def_cfa_expression (");
6404 decode_location_expression (start, eh_addr_size, 0, -1,
6412 case DW_CFA_expression:
6415 if (reg >= (unsigned int) fc->ncols)
6416 reg_prefix = bad_reg;
6417 /* PR 17512: file: 069-133014-0.006. */
6418 /* PR 17512: file: 98c02eb4. */
6420 if (start >= block_end || tmp > block_end || tmp < start)
6422 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6425 if (! do_debug_frames_interp || *reg_prefix != '\0')
6427 printf (" DW_CFA_expression: %s%s (",
6428 reg_prefix, regname (reg, 0));
6429 decode_location_expression (start, eh_addr_size, 0, -1,
6433 if (*reg_prefix == '\0')
6434 fc->col_type[reg] = DW_CFA_expression;
6438 case DW_CFA_val_expression:
6441 if (reg >= (unsigned int) fc->ncols)
6442 reg_prefix = bad_reg;
6444 if (start >= block_end || tmp > block_end || tmp < start)
6446 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6449 if (! do_debug_frames_interp || *reg_prefix != '\0')
6451 printf (" DW_CFA_val_expression: %s%s (",
6452 reg_prefix, regname (reg, 0));
6453 decode_location_expression (start, eh_addr_size, 0, -1,
6457 if (*reg_prefix == '\0')
6458 fc->col_type[reg] = DW_CFA_val_expression;
6462 case DW_CFA_offset_extended_sf:
6465 if (frame_need_space (fc, reg) < 0)
6466 reg_prefix = bad_reg;
6467 if (! do_debug_frames_interp || *reg_prefix != '\0')
6468 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6469 reg_prefix, regname (reg, 0),
6470 l * fc->data_factor);
6471 if (*reg_prefix == '\0')
6473 fc->col_type[reg] = DW_CFA_offset;
6474 fc->col_offset[reg] = l * fc->data_factor;
6478 case DW_CFA_val_offset_sf:
6481 if (frame_need_space (fc, reg) < 0)
6482 reg_prefix = bad_reg;
6483 if (! do_debug_frames_interp || *reg_prefix != '\0')
6484 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6485 reg_prefix, regname (reg, 0),
6486 l * fc->data_factor);
6487 if (*reg_prefix == '\0')
6489 fc->col_type[reg] = DW_CFA_val_offset;
6490 fc->col_offset[reg] = l * fc->data_factor;
6494 case DW_CFA_def_cfa_sf:
6495 fc->cfa_reg = LEB ();
6496 fc->cfa_offset = SLEB ();
6497 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6499 if (! do_debug_frames_interp)
6500 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6501 regname (fc->cfa_reg, 0), fc->cfa_offset);
6504 case DW_CFA_def_cfa_offset_sf:
6505 fc->cfa_offset = SLEB ();
6506 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6507 if (! do_debug_frames_interp)
6508 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
6511 case DW_CFA_MIPS_advance_loc8:
6512 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6513 if (do_debug_frames_interp)
6514 frame_display_row (fc, &need_col_headers, &max_regs);
6516 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6517 (unsigned long) (ofs * fc->code_factor),
6518 dwarf_vmatoa_1 (NULL,
6519 fc->pc_begin + ofs * fc->code_factor,
6521 fc->pc_begin += ofs * fc->code_factor;
6524 case DW_CFA_GNU_window_save:
6525 if (! do_debug_frames_interp)
6526 printf (" DW_CFA_GNU_window_save\n");
6529 case DW_CFA_GNU_args_size:
6531 if (! do_debug_frames_interp)
6532 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6535 case DW_CFA_GNU_negative_offset_extended:
6538 if (frame_need_space (fc, reg) < 0)
6539 reg_prefix = bad_reg;
6540 if (! do_debug_frames_interp || *reg_prefix != '\0')
6541 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6542 reg_prefix, regname (reg, 0),
6543 l * fc->data_factor);
6544 if (*reg_prefix == '\0')
6546 fc->col_type[reg] = DW_CFA_offset;
6547 fc->col_offset[reg] = l * fc->data_factor;
6552 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6553 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6555 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6560 if (do_debug_frames_interp)
6561 frame_display_row (fc, &need_col_headers, &max_regs);
6564 eh_addr_size = saved_eh_addr_size;
6577 display_gdb_index (struct dwarf_section *section,
6578 void *file ATTRIBUTE_UNUSED)
6580 unsigned char *start = section->start;
6582 uint32_t cu_list_offset, tu_list_offset;
6583 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6584 unsigned int cu_list_elements, tu_list_elements;
6585 unsigned int address_table_size, symbol_table_slots;
6586 unsigned char *cu_list, *tu_list;
6587 unsigned char *address_table, *symbol_table, *constant_pool;
6590 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6592 printf (_("Contents of the %s section:\n"), section->name);
6594 if (section->size < 6 * sizeof (uint32_t))
6596 warn (_("Truncated header in the %s section.\n"), section->name);
6600 version = byte_get_little_endian (start, 4);
6601 printf (_("Version %ld\n"), (long) version);
6603 /* Prior versions are obsolete, and future versions may not be
6604 backwards compatible. */
6605 if (version < 3 || version > 8)
6607 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6611 warn (_("The address table data in version 3 may be wrong.\n"));
6613 warn (_("Version 4 does not support case insensitive lookups.\n"));
6615 warn (_("Version 5 does not include inlined functions.\n"));
6617 warn (_("Version 6 does not include symbol attributes.\n"));
6618 /* Version 7 indices generated by Gold have bad type unit references,
6619 PR binutils/15021. But we don't know if the index was generated by
6620 Gold or not, so to avoid worrying users with gdb-generated indices
6621 we say nothing for version 7 here. */
6623 cu_list_offset = byte_get_little_endian (start + 4, 4);
6624 tu_list_offset = byte_get_little_endian (start + 8, 4);
6625 address_table_offset = byte_get_little_endian (start + 12, 4);
6626 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6627 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6629 if (cu_list_offset > section->size
6630 || tu_list_offset > section->size
6631 || address_table_offset > section->size
6632 || symbol_table_offset > section->size
6633 || constant_pool_offset > section->size)
6635 warn (_("Corrupt header in the %s section.\n"), section->name);
6639 /* PR 17531: file: 418d0a8a. */
6640 if (tu_list_offset < cu_list_offset)
6642 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6643 tu_list_offset, cu_list_offset);
6647 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6649 if (address_table_offset < tu_list_offset)
6651 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6652 address_table_offset, tu_list_offset);
6656 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6658 /* PR 17531: file: 18a47d3d. */
6659 if (symbol_table_offset < address_table_offset)
6661 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6662 symbol_table_offset, address_table_offset);
6666 address_table_size = symbol_table_offset - address_table_offset;
6668 if (constant_pool_offset < symbol_table_offset)
6670 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6671 constant_pool_offset, symbol_table_offset);
6675 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6677 cu_list = start + cu_list_offset;
6678 tu_list = start + tu_list_offset;
6679 address_table = start + address_table_offset;
6680 symbol_table = start + symbol_table_offset;
6681 constant_pool = start + constant_pool_offset;
6683 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6685 warn (_("Address table extends beyond end of section.\n"));
6689 printf (_("\nCU table:\n"));
6690 for (i = 0; i < cu_list_elements; i += 2)
6692 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6693 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6695 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6696 (unsigned long) cu_offset,
6697 (unsigned long) (cu_offset + cu_length - 1));
6700 printf (_("\nTU table:\n"));
6701 for (i = 0; i < tu_list_elements; i += 3)
6703 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6704 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6705 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6707 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6708 (unsigned long) tu_offset,
6709 (unsigned long) type_offset);
6710 print_dwarf_vma (signature, 8);
6714 printf (_("\nAddress table:\n"));
6715 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6718 uint64_t low = byte_get_little_endian (address_table + i, 8);
6719 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6720 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6722 print_dwarf_vma (low, 8);
6723 print_dwarf_vma (high, 8);
6724 printf (_("%lu\n"), (unsigned long) cu_index);
6727 printf (_("\nSymbol table:\n"));
6728 for (i = 0; i < symbol_table_slots; ++i)
6730 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6731 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6732 uint32_t num_cus, cu;
6734 if (name_offset != 0
6735 || cu_vector_offset != 0)
6738 unsigned char * adr;
6740 adr = constant_pool + name_offset;
6741 /* PR 17531: file: 5b7b07ad. */
6742 if (adr < constant_pool || adr >= section->start + section->size)
6744 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6745 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6749 printf ("[%3u] %.*s:", i,
6750 (int) (section->size - (constant_pool_offset + name_offset)),
6751 constant_pool + name_offset);
6753 adr = constant_pool + cu_vector_offset;
6754 if (adr < constant_pool || adr >= section->start + section->size - 3)
6756 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6757 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6758 cu_vector_offset, i);
6762 num_cus = byte_get_little_endian (adr, 4);
6764 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
6765 if (num_cus * 4 < num_cus
6766 || adr >= section->start + section->size
6767 || adr < constant_pool)
6769 printf ("<invalid number of CUs: %d>\n", num_cus);
6770 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6778 for (j = 0; j < num_cus; ++j)
6781 gdb_index_symbol_kind kind;
6783 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6784 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6785 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6786 cu = GDB_INDEX_CU_VALUE (cu);
6787 /* Convert to TU number if it's for a type unit. */
6788 if (cu >= cu_list_elements / 2)
6789 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6790 (unsigned long) (cu - cu_list_elements / 2));
6792 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6794 printf (" [%s, %s]",
6795 is_static ? _("static") : _("global"),
6796 get_gdb_index_symbol_kind_name (kind));
6808 /* Pre-allocate enough space for the CU/TU sets needed. */
6811 prealloc_cu_tu_list (unsigned int nshndx)
6813 if (shndx_pool == NULL)
6815 shndx_pool_size = nshndx;
6816 shndx_pool_used = 0;
6817 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6818 sizeof (unsigned int));
6822 shndx_pool_size = shndx_pool_used + nshndx;
6823 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6824 sizeof (unsigned int));
6829 add_shndx_to_cu_tu_entry (unsigned int shndx)
6831 if (shndx_pool_used >= shndx_pool_size)
6833 error (_("Internal error: out of space in the shndx pool.\n"));
6836 shndx_pool [shndx_pool_used++] = shndx;
6840 end_cu_tu_entry (void)
6842 if (shndx_pool_used >= shndx_pool_size)
6844 error (_("Internal error: out of space in the shndx pool.\n"));
6847 shndx_pool [shndx_pool_used++] = 0;
6850 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6853 get_DW_SECT_short_name (unsigned int dw_sect)
6855 static char buf[16];
6863 case DW_SECT_ABBREV:
6869 case DW_SECT_STR_OFFSETS:
6871 case DW_SECT_MACINFO:
6879 snprintf (buf, sizeof (buf), "%d", dw_sect);
6883 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6884 These sections are extensions for Fission.
6885 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6888 process_cu_tu_index (struct dwarf_section *section, int do_display)
6890 unsigned char *phdr = section->start;
6891 unsigned char *limit = phdr + section->size;
6892 unsigned char *phash;
6893 unsigned char *pindex;
6894 unsigned char *ppool;
6895 unsigned int version;
6896 unsigned int ncols = 0;
6898 unsigned int nslots;
6901 dwarf_vma signature_high;
6902 dwarf_vma signature_low;
6905 /* PR 17512: file: 002-168123-0.004. */
6908 warn (_("Section %s is empty\n"), section->name);
6911 /* PR 17512: file: 002-376-0.004. */
6912 if (section->size < 24)
6914 warn (_("Section %s is too small to contain a CU/TU header\n"),
6919 SAFE_BYTE_GET (version, phdr, 4, limit);
6921 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6922 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6923 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6926 pindex = phash + nslots * 8;
6927 ppool = pindex + nslots * 4;
6929 /* PR 17531: file: 45d69832. */
6930 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
6932 warn (_("Section %s is too small for %d slots\n"),
6933 section->name, nslots);
6939 printf (_("Contents of the %s section:\n\n"), section->name);
6940 printf (_(" Version: %d\n"), version);
6942 printf (_(" Number of columns: %d\n"), ncols);
6943 printf (_(" Number of used entries: %d\n"), nused);
6944 printf (_(" Number of slots: %d\n\n"), nslots);
6947 if (ppool > limit || ppool < phdr)
6949 warn (_("Section %s too small for %d hash table entries\n"),
6950 section->name, nslots);
6957 prealloc_cu_tu_list ((limit - ppool) / 4);
6958 for (i = 0; i < nslots; i++)
6960 unsigned char *shndx_list;
6963 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
6964 if (signature_high != 0 || signature_low != 0)
6966 SAFE_BYTE_GET (j, pindex, 4, limit);
6967 shndx_list = ppool + j * 4;
6968 /* PR 17531: file: 705e010d. */
6969 if (shndx_list < ppool)
6971 warn (_("Section index pool located before start of section\n"));
6976 printf (_(" [%3d] Signature: 0x%s Sections: "),
6977 i, dwarf_vmatoa64 (signature_high, signature_low,
6978 buf, sizeof (buf)));
6981 if (shndx_list >= limit)
6983 warn (_("Section %s too small for shndx pool\n"),
6987 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
6991 printf (" %d", shndx);
6993 add_shndx_to_cu_tu_entry (shndx);
7005 else if (version == 2)
7008 unsigned int dw_sect;
7009 unsigned char *ph = phash;
7010 unsigned char *pi = pindex;
7011 unsigned char *poffsets = ppool + ncols * 4;
7012 unsigned char *psizes = poffsets + nused * ncols * 4;
7013 unsigned char *pend = psizes + nused * ncols * 4;
7014 bfd_boolean is_tu_index;
7015 struct cu_tu_set *this_set = NULL;
7017 unsigned char *prow;
7019 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7021 /* PR 17531: file: 0dd159bf.
7022 Check for wraparound with an overlarge ncols value. */
7023 if ((unsigned int) ((poffsets - ppool) / 4) != ncols)
7025 warn (_("Overlarge number of columns: %x\n"), ncols);
7031 warn (_("Section %s too small for offset and size tables\n"),
7038 printf (_(" Offset table\n"));
7039 printf (" slot %-16s ",
7040 is_tu_index ? _("signature") : _("dwo_id"));
7047 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7053 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7060 for (j = 0; j < ncols; j++)
7062 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7063 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7068 for (i = 0; i < nslots; i++)
7070 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7072 SAFE_BYTE_GET (row, pi, 4, limit);
7075 /* PR 17531: file: a05f6ab3. */
7078 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7084 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7086 prow = poffsets + (row - 1) * ncols * 4;
7089 printf (_(" [%3d] 0x%s"),
7090 i, dwarf_vmatoa64 (signature_high, signature_low,
7091 buf, sizeof (buf)));
7092 for (j = 0; j < ncols; j++)
7094 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7096 printf (" %8d", val);
7099 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7101 /* PR 17531: file: 10796eb3. */
7102 if (dw_sect >= DW_SECT_MAX)
7103 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7105 this_set [row - 1].section_offsets [dw_sect] = val;
7121 printf (_(" Size table\n"));
7122 printf (" slot %-16s ",
7123 is_tu_index ? _("signature") : _("dwo_id"));
7126 for (j = 0; j < ncols; j++)
7128 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7130 printf (" %8s", get_DW_SECT_short_name (val));
7136 for (i = 0; i < nslots; i++)
7138 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7140 SAFE_BYTE_GET (row, pi, 4, limit);
7143 prow = psizes + (row - 1) * ncols * 4;
7146 printf (_(" [%3d] 0x%s"),
7147 i, dwarf_vmatoa64 (signature_high, signature_low,
7148 buf, sizeof (buf)));
7150 for (j = 0; j < ncols; j++)
7152 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7154 printf (" %8d", val);
7157 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7158 if (dw_sect >= DW_SECT_MAX)
7159 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7161 this_set [row - 1].section_sizes [dw_sect] = val;
7173 else if (do_display)
7174 printf (_(" Unsupported version (%d)\n"), version);
7182 /* Load the CU and TU indexes if present. This will build a list of
7183 section sets that we can use to associate a .debug_info.dwo section
7184 with its associated .debug_abbrev.dwo section in a .dwp file. */
7187 load_cu_tu_indexes (void *file)
7189 /* If we have already loaded (or tried to load) the CU and TU indexes
7190 then do not bother to repeat the task. */
7191 if (cu_tu_indexes_read)
7194 if (load_debug_section (dwp_cu_index, file))
7195 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7197 if (load_debug_section (dwp_tu_index, file))
7198 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7200 cu_tu_indexes_read = 1;
7203 /* Find the set of sections that includes section SHNDX. */
7206 find_cu_tu_set (void *file, unsigned int shndx)
7210 load_cu_tu_indexes (file);
7212 /* Find SHNDX in the shndx pool. */
7213 for (i = 0; i < shndx_pool_used; i++)
7214 if (shndx_pool [i] == shndx)
7217 if (i >= shndx_pool_used)
7220 /* Now backup to find the first entry in the set. */
7221 while (i > 0 && shndx_pool [i - 1] != 0)
7224 return shndx_pool + i;
7227 /* Display a .debug_cu_index or .debug_tu_index section. */
7230 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7232 return process_cu_tu_index (section, 1);
7236 display_debug_not_supported (struct dwarf_section *section,
7237 void *file ATTRIBUTE_UNUSED)
7239 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7245 /* Like malloc, but takes two parameters like calloc.
7246 Verifies that the first parameter is not too large.
7247 Note: does *not* initialise the allocated memory to zero. */
7249 cmalloc (size_t nmemb, size_t size)
7251 /* Check for overflow. */
7252 if (nmemb >= ~(size_t) 0 / size)
7255 return xmalloc (nmemb * size);
7258 /* Like xmalloc, but takes two parameters like calloc.
7259 Verifies that the first parameter is not too large.
7260 Note: does *not* initialise the allocated memory to zero. */
7262 xcmalloc (size_t nmemb, size_t size)
7264 /* Check for overflow. */
7265 if (nmemb >= ~(size_t) 0 / size)
7268 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7273 return xmalloc (nmemb * size);
7276 /* Like xrealloc, but takes three parameters.
7277 Verifies that the second parameter is not too large.
7278 Note: does *not* initialise any new memory to zero. */
7280 xcrealloc (void *ptr, size_t nmemb, size_t size)
7282 /* Check for overflow. */
7283 if (nmemb >= ~(size_t) 0 / size)
7286 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7291 return xrealloc (ptr, nmemb * size);
7294 /* Like xcalloc, but verifies that the first parameter is not too large. */
7296 xcalloc2 (size_t nmemb, size_t size)
7298 /* Check for overflow. */
7299 if (nmemb >= ~(size_t) 0 / size)
7302 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7307 return xcalloc (nmemb, size);
7311 free_debug_memory (void)
7317 for (i = 0; i < max; i++)
7318 free_debug_section ((enum dwarf_section_display_enum) i);
7320 if (debug_information != NULL)
7322 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7324 for (i = 0; i < num_debug_info_entries; i++)
7326 if (!debug_information [i].max_loc_offsets)
7328 free (debug_information [i].loc_offsets);
7329 free (debug_information [i].have_frame_base);
7331 if (!debug_information [i].max_range_lists)
7332 free (debug_information [i].range_lists);
7335 free (debug_information);
7336 debug_information = NULL;
7337 alloc_num_debug_info_entries = num_debug_info_entries = 0;
7342 dwarf_select_sections_by_names (const char *names)
7346 const char * option;
7350 debug_dump_long_opts;
7352 static const debug_dump_long_opts opts_table [] =
7354 /* Please keep this table alpha- sorted. */
7355 { "Ranges", & do_debug_ranges, 1 },
7356 { "abbrev", & do_debug_abbrevs, 1 },
7357 { "addr", & do_debug_addr, 1 },
7358 { "aranges", & do_debug_aranges, 1 },
7359 { "cu_index", & do_debug_cu_index, 1 },
7360 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7361 { "frames", & do_debug_frames, 1 },
7362 { "frames-interp", & do_debug_frames_interp, 1 },
7363 /* The special .gdb_index section. */
7364 { "gdb_index", & do_gdb_index, 1 },
7365 { "info", & do_debug_info, 1 },
7366 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
7367 { "loc", & do_debug_loc, 1 },
7368 { "macro", & do_debug_macinfo, 1 },
7369 { "pubnames", & do_debug_pubnames, 1 },
7370 { "pubtypes", & do_debug_pubtypes, 1 },
7371 /* This entry is for compatability
7372 with earlier versions of readelf. */
7373 { "ranges", & do_debug_aranges, 1 },
7374 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7375 { "str", & do_debug_str, 1 },
7376 /* These trace_* sections are used by Itanium VMS. */
7377 { "trace_abbrev", & do_trace_abbrevs, 1 },
7378 { "trace_aranges", & do_trace_aranges, 1 },
7379 { "trace_info", & do_trace_info, 1 },
7388 const debug_dump_long_opts * entry;
7390 for (entry = opts_table; entry->option; entry++)
7392 size_t len = strlen (entry->option);
7394 if (strncmp (p, entry->option, len) == 0
7395 && (p[len] == ',' || p[len] == '\0'))
7397 * entry->variable |= entry->val;
7399 /* The --debug-dump=frames-interp option also
7400 enables the --debug-dump=frames option. */
7401 if (do_debug_frames_interp)
7402 do_debug_frames = 1;
7409 if (entry->option == NULL)
7411 warn (_("Unrecognized debug option '%s'\n"), p);
7412 p = strchr (p, ',');
7423 dwarf_select_sections_by_letters (const char *letters)
7425 unsigned int lindex = 0;
7427 while (letters[lindex])
7428 switch (letters[lindex++])
7435 do_debug_abbrevs = 1;
7439 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7443 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7447 do_debug_pubnames = 1;
7451 do_debug_pubtypes = 1;
7455 do_debug_aranges = 1;
7459 do_debug_ranges = 1;
7463 do_debug_frames_interp = 1;
7465 do_debug_frames = 1;
7469 do_debug_macinfo = 1;
7481 warn (_("Unrecognized debug option '%s'\n"), letters);
7487 dwarf_select_sections_all (void)
7490 do_debug_abbrevs = 1;
7491 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7492 do_debug_pubnames = 1;
7493 do_debug_pubtypes = 1;
7494 do_debug_aranges = 1;
7495 do_debug_ranges = 1;
7496 do_debug_frames = 1;
7497 do_debug_macinfo = 1;
7502 do_trace_abbrevs = 1;
7503 do_trace_aranges = 1;
7505 do_debug_cu_index = 1;
7508 struct dwarf_section_display debug_displays[] =
7510 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL },
7511 display_debug_abbrev, &do_debug_abbrevs, 0 },
7512 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL },
7513 display_debug_aranges, &do_debug_aranges, 1 },
7514 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL },
7515 display_debug_frames, &do_debug_frames, 1 },
7516 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL },
7517 display_debug_info, &do_debug_info, 1 },
7518 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL },
7519 display_debug_lines, &do_debug_lines, 1 },
7520 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
7521 display_debug_pubnames, &do_debug_pubnames, 0 },
7522 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
7523 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7524 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL },
7525 display_debug_frames, &do_debug_frames, 1 },
7526 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL },
7527 display_debug_macinfo, &do_debug_macinfo, 0 },
7528 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL },
7529 display_debug_macro, &do_debug_macinfo, 1 },
7530 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL },
7531 display_debug_str, &do_debug_str, 0 },
7532 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL },
7533 display_debug_loc, &do_debug_loc, 1 },
7534 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7535 display_debug_pubnames, &do_debug_pubtypes, 0 },
7536 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7537 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7538 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL },
7539 display_debug_ranges, &do_debug_ranges, 1 },
7540 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
7541 display_debug_not_supported, NULL, 0 },
7542 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
7543 display_debug_not_supported, NULL, 0 },
7544 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL },
7545 display_debug_types, &do_debug_info, 1 },
7546 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
7547 display_debug_not_supported, NULL, 0 },
7548 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL },
7549 display_gdb_index, &do_gdb_index, 0 },
7550 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL },
7551 display_trace_info, &do_trace_info, 1 },
7552 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL },
7553 display_debug_abbrev, &do_trace_abbrevs, 0 },
7554 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL },
7555 display_debug_aranges, &do_trace_aranges, 0 },
7556 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7557 display_debug_info, &do_debug_info, 1 },
7558 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
7559 display_debug_abbrev, &do_debug_abbrevs, 0 },
7560 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7561 display_debug_types, &do_debug_info, 1 },
7562 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
7563 display_debug_lines, &do_debug_lines, 1 },
7564 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL },
7565 display_debug_loc, &do_debug_loc, 1 },
7566 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
7567 display_debug_macro, &do_debug_macinfo, 1 },
7568 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
7569 display_debug_macinfo, &do_debug_macinfo, 0 },
7570 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL },
7571 display_debug_str, &do_debug_str, 1 },
7572 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
7573 display_debug_str_offsets, NULL, 0 },
7574 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
7575 display_debug_str_offsets, NULL, 0 },
7576 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL },
7577 display_debug_addr, &do_debug_addr, 1 },
7578 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL },
7579 display_cu_index, &do_debug_cu_index, 0 },
7580 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL },
7581 display_cu_index, &do_debug_cu_index, 0 },