1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2017 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"
35 #define MAX(a, b) ((a) > (b) ? (a) : (b))
36 #define MIN(a, b) ((a) < (b) ? (a) : (b))
38 static const char *regname (unsigned int regno, int row);
40 static int have_frame_base;
41 static int need_base_address;
43 static unsigned int num_debug_info_entries = 0;
44 static unsigned int alloc_num_debug_info_entries = 0;
45 static debug_info *debug_information = NULL;
46 /* Special value for num_debug_info_entries to indicate
47 that the .debug_info section could not be loaded/parsed. */
48 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
50 unsigned int eh_addr_size;
55 int do_debug_pubnames;
56 int do_debug_pubtypes;
60 int do_debug_frames_interp;
69 int do_debug_cu_index;
72 int dwarf_cutoff_level = -1;
73 unsigned long dwarf_start_die;
77 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
78 testing whether e.g. a locview list is present. */
79 static const dwarf_vma vm1 = -1;
81 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
82 sections. For version 1 package files, each set is stored in SHNDX_POOL
83 as a zero-terminated list of section indexes comprising one set of debug
84 sections from a .dwo file. */
86 static unsigned int *shndx_pool = NULL;
87 static unsigned int shndx_pool_size = 0;
88 static unsigned int shndx_pool_used = 0;
90 /* For version 2 package files, each set contains an array of section offsets
91 and an array of section sizes, giving the offset and size of the
92 contribution from a CU or TU within one of the debug sections.
93 When displaying debug info from a package file, we need to use these
94 tables to locate the corresponding contributions to each section. */
99 dwarf_vma section_offsets[DW_SECT_MAX];
100 size_t section_sizes[DW_SECT_MAX];
103 static int cu_count = 0;
104 static int tu_count = 0;
105 static struct cu_tu_set *cu_sets = NULL;
106 static struct cu_tu_set *tu_sets = NULL;
108 static bfd_boolean load_cu_tu_indexes (void *);
110 /* Values for do_debug_lines. */
111 #define FLAG_DEBUG_LINES_RAW 1
112 #define FLAG_DEBUG_LINES_DECODED 2
115 size_of_encoded_value (int encoding)
117 switch (encoding & 0x7)
120 case 0: return eh_addr_size;
128 get_encoded_value (unsigned char **pdata,
130 struct dwarf_section *section,
133 unsigned char * data = * pdata;
134 unsigned int size = size_of_encoded_value (encoding);
137 if (data + size >= end)
139 warn (_("Encoded value extends past end of section\n"));
144 /* PR 17512: file: 002-829853-0.004. */
147 warn (_("Encoded size of %d is too large to read\n"), size);
152 /* PR 17512: file: 1085-5603-0.004. */
155 warn (_("Encoded size of 0 is too small to read\n"));
160 if (encoding & DW_EH_PE_signed)
161 val = byte_get_signed (data, size);
163 val = byte_get (data, size);
165 if ((encoding & 0x70) == DW_EH_PE_pcrel)
166 val += section->address + (data - section->start);
168 * pdata = data + size;
172 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
174 # define DWARF_VMA_FMT "ll"
175 # define DWARF_VMA_FMT_LONG "%16.16llx"
177 # define DWARF_VMA_FMT "I64"
178 # define DWARF_VMA_FMT_LONG "%016I64x"
181 # define DWARF_VMA_FMT "l"
182 # define DWARF_VMA_FMT_LONG "%16.16lx"
185 /* Convert a dwarf vma value into a string. Returns a pointer to a static
186 buffer containing the converted VALUE. The value is converted according
187 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
188 it specifies the maximum number of bytes to be displayed in the converted
189 value and FMTCH is ignored - hex is always used. */
192 dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)
194 /* As dwarf_vmatoa is used more then once in a printf call
195 for output, we are cycling through an fixed array of pointers
196 for return address. */
197 static int buf_pos = 0;
198 static struct dwarf_vmatoa_buf
204 ret = buf[buf_pos++].place;
205 buf_pos %= ARRAY_SIZE (buf);
209 /* Printf does not have a way of specifying a maximum field width for an
210 integer value, so we print the full value into a buffer and then select
211 the precision we need. */
212 snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);
215 return ret + (16 - 2 * num_bytes);
222 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
224 sprintf (fmt, "%%%s", DWARF_VMA_FMT);
225 snprintf (ret, sizeof (buf[0].place), fmt, value);
230 static inline const char *
231 dwarf_vmatoa (const char * fmtch, dwarf_vma value)
233 return dwarf_vmatoa_1 (fmtch, value, 0);
236 /* Print a dwarf_vma value (typically an address, offset or length) in
237 hexadecimal format, followed by a space. The length of the VALUE (and
238 hence the precision displayed) is determined by the NUM_BYTES parameter. */
241 print_dwarf_vma (dwarf_vma value, unsigned num_bytes)
243 printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));
246 /* Print a view number in hexadecimal value, with the same width
247 print_dwarf_vma would have printed it with the same num_bytes.
248 Print blanks for zero view, unless force is nonzero. */
251 print_dwarf_view (dwarf_vma value, unsigned num_bytes, int force)
259 assert (value == (unsigned long) value);
261 printf ("v%0*lx ", len - 1, (unsigned long) value);
263 printf ("%*s", len + 1, "");
266 /* Format a 64-bit value, given as two 32-bit values, in hex.
267 For reentrancy, this uses a buffer provided by the caller. */
270 dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
271 unsigned int buf_len)
276 snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
279 len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
280 snprintf (buf + len, buf_len - len,
281 "%08" DWARF_VMA_FMT "x", lvalue);
287 /* Read in a LEB128 encoded value starting at address DATA.
288 If SIGN is true, return a signed LEB128 value.
289 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
290 No bytes will be read at address END or beyond. */
293 read_leb128 (unsigned char *data,
294 unsigned int *length_return,
296 const unsigned char * const end)
298 dwarf_vma result = 0;
299 unsigned int num_read = 0;
300 unsigned int shift = 0;
301 unsigned char byte = 0;
308 result |= ((dwarf_vma) (byte & 0x7f)) << shift;
311 if ((byte & 0x80) == 0)
314 /* PR 17512: file: 0ca183b8.
315 FIXME: Should we signal this error somehow ? */
316 if (shift >= sizeof (result) * 8)
320 if (length_return != NULL)
321 *length_return = num_read;
323 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
324 result |= -((dwarf_vma) 1 << shift);
329 /* Create a signed version to avoid painful typecasts. */
330 static inline dwarf_signed_vma
331 read_sleb128 (unsigned char * data,
332 unsigned int * length_return,
333 const unsigned char * const end)
335 return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
338 static inline dwarf_vma
339 read_uleb128 (unsigned char * data,
340 unsigned int * length_return,
341 const unsigned char * const end)
343 return read_leb128 (data, length_return, FALSE, end);
346 #define SKIP_ULEB() read_uleb128 (start, & length_return, end); start += length_return
347 #define SKIP_SLEB() read_sleb128 (start, & length_return, end); start += length_return
349 #define READ_ULEB(var) \
354 (var) = _val = read_uleb128 (start, &length_return, end); \
356 error (_("Internal error: %s:%d: LEB value (%s) " \
357 "too large for containing variable\n"), \
358 __FILE__, __LINE__, dwarf_vmatoa ("u", _val)); \
359 start += length_return; \
363 #define READ_SLEB(var) \
366 dwarf_signed_vma _val; \
368 (var) = _val = read_sleb128 (start, &length_return, end); \
370 error (_("Internal error: %s:%d: LEB value (%s) " \
371 "too large for containing variable\n"), \
372 __FILE__, __LINE__, dwarf_vmatoa ("d", _val)); \
373 start += length_return; \
377 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
380 unsigned int amount = (AMOUNT); \
381 if (sizeof (VAL) < amount) \
383 error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
384 amount, (int) sizeof (VAL)); \
385 amount = sizeof (VAL); \
387 if (((PTR) + amount) >= (END)) \
390 amount = (END) - (PTR); \
394 if (amount == 0 || amount > 8) \
397 VAL = byte_get ((PTR), amount); \
401 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
404 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
409 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
412 unsigned int amount = (AMOUNT); \
413 if (((PTR) + amount) >= (END)) \
416 amount = (END) - (PTR); \
421 VAL = byte_get_signed ((PTR), amount); \
427 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
430 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
435 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
438 if (((PTR) + 8) <= (END)) \
440 byte_get_64 ((PTR), (HIGH), (LOW)); \
444 * (LOW) = * (HIGH) = 0; \
449 typedef struct State_Machine_Registers
458 unsigned char op_index;
459 unsigned char end_sequence;
460 /* This variable hold the number of the last entry seen
461 in the File Table. */
462 unsigned int last_file_entry;
465 static SMR state_machine_regs;
468 reset_state_machine (int is_stmt)
470 state_machine_regs.address = 0;
471 state_machine_regs.view = 0;
472 state_machine_regs.op_index = 0;
473 state_machine_regs.file = 1;
474 state_machine_regs.line = 1;
475 state_machine_regs.column = 0;
476 state_machine_regs.is_stmt = is_stmt;
477 state_machine_regs.basic_block = 0;
478 state_machine_regs.end_sequence = 0;
479 state_machine_regs.last_file_entry = 0;
482 /* Handled an extend line op.
483 Returns the number of bytes read. */
486 process_extended_line_op (unsigned char * data,
490 unsigned char op_code;
491 unsigned int bytes_read;
494 unsigned char *orig_data = data;
497 len = read_uleb128 (data, & bytes_read, end);
500 if (len == 0 || data == end || len > (uintptr_t) (end - data))
502 warn (_("Badly formed extended line op encountered!\n"));
509 printf (_(" Extended opcode %d: "), op_code);
513 case DW_LNE_end_sequence:
514 printf (_("End of Sequence\n\n"));
515 reset_state_machine (is_stmt);
518 case DW_LNE_set_address:
519 /* PR 17512: file: 002-100480-0.004. */
520 if (len - bytes_read - 1 > 8)
522 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
523 len - bytes_read - 1);
527 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
528 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
529 state_machine_regs.address = adr;
530 state_machine_regs.view = 0;
531 state_machine_regs.op_index = 0;
534 case DW_LNE_define_file:
535 printf (_("define new File Table entry\n"));
536 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
537 printf (" %d\t", ++state_machine_regs.last_file_entry);
543 l = strnlen ((char *) data, end - data);
545 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
547 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
549 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
551 printf ("%.*s\n\n", (int) l, name);
554 if (((unsigned int) (data - orig_data) != len) || data == end)
555 warn (_("DW_LNE_define_file: Bad opcode length\n"));
558 case DW_LNE_set_discriminator:
559 printf (_("set Discriminator to %s\n"),
560 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
564 case DW_LNE_HP_negate_is_UV_update:
565 printf ("DW_LNE_HP_negate_is_UV_update\n");
567 case DW_LNE_HP_push_context:
568 printf ("DW_LNE_HP_push_context\n");
570 case DW_LNE_HP_pop_context:
571 printf ("DW_LNE_HP_pop_context\n");
573 case DW_LNE_HP_set_file_line_column:
574 printf ("DW_LNE_HP_set_file_line_column\n");
576 case DW_LNE_HP_set_routine_name:
577 printf ("DW_LNE_HP_set_routine_name\n");
579 case DW_LNE_HP_set_sequence:
580 printf ("DW_LNE_HP_set_sequence\n");
582 case DW_LNE_HP_negate_post_semantics:
583 printf ("DW_LNE_HP_negate_post_semantics\n");
585 case DW_LNE_HP_negate_function_exit:
586 printf ("DW_LNE_HP_negate_function_exit\n");
588 case DW_LNE_HP_negate_front_end_logical:
589 printf ("DW_LNE_HP_negate_front_end_logical\n");
591 case DW_LNE_HP_define_proc:
592 printf ("DW_LNE_HP_define_proc\n");
594 case DW_LNE_HP_source_file_correlation:
596 unsigned char *edata = data + len - bytes_read - 1;
598 printf ("DW_LNE_HP_source_file_correlation\n");
604 opc = read_uleb128 (data, & bytes_read, edata);
609 case DW_LNE_HP_SFC_formfeed:
610 printf (" DW_LNE_HP_SFC_formfeed\n");
612 case DW_LNE_HP_SFC_set_listing_line:
613 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
615 read_uleb128 (data, & bytes_read, edata)));
618 case DW_LNE_HP_SFC_associate:
619 printf (" DW_LNE_HP_SFC_associate ");
622 read_uleb128 (data, & bytes_read, edata)));
626 read_uleb128 (data, & bytes_read, edata)));
630 read_uleb128 (data, & bytes_read, edata)));
634 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
644 unsigned int rlen = len - bytes_read - 1;
646 if (op_code >= DW_LNE_lo_user
647 /* The test against DW_LNW_hi_user is redundant due to
648 the limited range of the unsigned char data type used
650 /*&& op_code <= DW_LNE_hi_user*/)
651 printf (_("user defined: "));
653 printf (_("UNKNOWN: "));
654 printf (_("length %d ["), rlen);
656 printf (" %02x", *data++);
665 static const unsigned char *
666 fetch_indirect_string (dwarf_vma offset)
668 struct dwarf_section *section = &debug_displays [str].section;
669 const unsigned char * ret;
671 if (section->start == NULL)
672 return (const unsigned char *) _("<no .debug_str section>");
674 if (offset >= section->size)
676 warn (_("DW_FORM_strp offset too big: %s\n"),
677 dwarf_vmatoa ("x", offset));
678 return (const unsigned char *) _("<offset is too big>");
681 ret = section->start + offset;
682 /* Unfortunately we cannot rely upon the .debug_str section ending with a
683 NUL byte. Since our caller is expecting to receive a well formed C
684 string we test for the lack of a terminating byte here. */
685 if (strnlen ((const char *) ret, section->size - offset)
686 == section->size - offset)
687 ret = (const unsigned char *)
688 _("<no NUL byte at end of .debug_str section>");
693 static const unsigned char *
694 fetch_indirect_line_string (dwarf_vma offset)
696 struct dwarf_section *section = &debug_displays [line_str].section;
697 const unsigned char * ret;
699 if (section->start == NULL)
700 return (const unsigned char *) _("<no .debug_line_str section>");
702 if (offset >= section->size)
704 warn (_("DW_FORM_line_strp offset too big: %s\n"),
705 dwarf_vmatoa ("x", offset));
706 return (const unsigned char *) _("<offset is too big>");
709 ret = section->start + offset;
710 /* Unfortunately we cannot rely upon the .debug_line_str section ending
711 with a NUL byte. Since our caller is expecting to receive a well formed
712 C string we test for the lack of a terminating byte here. */
713 if (strnlen ((const char *) ret, section->size - offset)
714 == section->size - offset)
715 ret = (const unsigned char *)
716 _("<no NUL byte at end of .debug_line_str section>");
722 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
723 dwarf_vma offset_size, int dwo)
725 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
726 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
727 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
728 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
729 dwarf_vma index_offset = idx * offset_size;
730 dwarf_vma str_offset;
733 if (index_section->start == NULL)
734 return (dwo ? _("<no .debug_str_offsets.dwo section>")
735 : _("<no .debug_str_offsets section>"));
737 if (this_set != NULL)
738 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
739 if (index_offset >= index_section->size)
741 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
742 dwarf_vmatoa ("x", index_offset));
743 return _("<index offset is too big>");
746 if (str_section->start == NULL)
747 return (dwo ? _("<no .debug_str.dwo section>")
748 : _("<no .debug_str section>"));
750 str_offset = byte_get (index_section->start + index_offset, offset_size);
751 str_offset -= str_section->address;
752 if (str_offset >= str_section->size)
754 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
755 dwarf_vmatoa ("x", str_offset));
756 return _("<indirect index offset is too big>");
759 ret = (const char *) str_section->start + str_offset;
760 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
761 Since our caller is expecting to receive a well formed C string we test
762 for the lack of a terminating byte here. */
763 if (strnlen (ret, str_section->size - str_offset)
764 == str_section->size - str_offset)
765 ret = (const char *) _("<no NUL byte at end of section>");
771 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
773 struct dwarf_section *section = &debug_displays [debug_addr].section;
775 if (section->start == NULL)
776 return (_("<no .debug_addr section>"));
778 if (offset + bytes > section->size)
780 warn (_("Offset into section %s too big: %s\n"),
781 section->name, dwarf_vmatoa ("x", offset));
782 return "<offset too big>";
785 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
789 /* FIXME: There are better and more efficient ways to handle
790 these structures. For now though, I just want something that
791 is simple to implement. */
792 typedef struct abbrev_attr
794 unsigned long attribute;
796 bfd_signed_vma implicit_const;
797 struct abbrev_attr *next;
801 typedef struct abbrev_entry
806 struct abbrev_attr *first_attr;
807 struct abbrev_attr *last_attr;
808 struct abbrev_entry *next;
812 static abbrev_entry *first_abbrev = NULL;
813 static abbrev_entry *last_abbrev = NULL;
820 for (abbrv = first_abbrev; abbrv;)
822 abbrev_entry *next_abbrev = abbrv->next;
825 for (attr = abbrv->first_attr; attr;)
827 abbrev_attr *next_attr = attr->next;
837 last_abbrev = first_abbrev = NULL;
841 add_abbrev (unsigned long number, unsigned long tag, int children)
845 entry = (abbrev_entry *) malloc (sizeof (*entry));
850 entry->entry = number;
852 entry->children = children;
853 entry->first_attr = NULL;
854 entry->last_attr = NULL;
857 if (first_abbrev == NULL)
858 first_abbrev = entry;
860 last_abbrev->next = entry;
866 add_abbrev_attr (unsigned long attribute, unsigned long form,
867 bfd_signed_vma implicit_const)
871 attr = (abbrev_attr *) malloc (sizeof (*attr));
876 attr->attribute = attribute;
878 attr->implicit_const = implicit_const;
881 if (last_abbrev->first_attr == NULL)
882 last_abbrev->first_attr = attr;
884 last_abbrev->last_attr->next = attr;
886 last_abbrev->last_attr = attr;
889 /* Processes the (partial) contents of a .debug_abbrev section.
890 Returns NULL if the end of the section was encountered.
891 Returns the address after the last byte read if the end of
892 an abbreviation set was found. */
894 static unsigned char *
895 process_abbrev_section (unsigned char *start, unsigned char *end)
897 if (first_abbrev != NULL)
902 unsigned int bytes_read;
905 unsigned long attribute;
908 entry = read_uleb128 (start, & bytes_read, end);
911 /* A single zero is supposed to end the section according
912 to the standard. If there's more, then signal that to
919 tag = read_uleb128 (start, & bytes_read, end);
926 add_abbrev (entry, tag, children);
931 /* Initialize it due to a false compiler warning. */
932 bfd_signed_vma implicit_const = -1;
934 attribute = read_uleb128 (start, & bytes_read, end);
939 form = read_uleb128 (start, & bytes_read, end);
944 if (form == DW_FORM_implicit_const)
946 implicit_const = read_sleb128 (start, & bytes_read, end);
952 add_abbrev_attr (attribute, form, implicit_const);
954 while (attribute != 0);
957 /* Report the missing single zero which ends the section. */
958 error (_(".debug_abbrev section not zero terminated\n"));
964 get_TAG_name (unsigned long tag)
966 const char *name = get_DW_TAG_name ((unsigned int)tag);
970 static char buffer[100];
972 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
980 get_FORM_name (unsigned long form)
985 return "DW_FORM value: 0";
987 name = get_DW_FORM_name (form);
990 static char buffer[100];
992 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
1000 get_IDX_name (unsigned long idx)
1002 const char *name = get_DW_IDX_name ((unsigned int) idx);
1006 static char buffer[100];
1008 snprintf (buffer, sizeof (buffer), _("Unknown IDX value: %lx"), idx);
1015 static unsigned char *
1016 display_block (unsigned char *data,
1018 const unsigned char * const end, char delimiter)
1022 printf (_("%c%s byte block: "), delimiter, dwarf_vmatoa ("u", length));
1024 return (unsigned char *) end;
1026 maxlen = (dwarf_vma) (end - data);
1027 length = length > maxlen ? maxlen : length;
1030 printf ("%lx ", (unsigned long) byte_get (data++, 1));
1036 decode_location_expression (unsigned char * data,
1037 unsigned int pointer_size,
1038 unsigned int offset_size,
1041 dwarf_vma cu_offset,
1042 struct dwarf_section * section)
1045 unsigned int bytes_read;
1047 dwarf_signed_vma svalue;
1048 unsigned char *end = data + length;
1049 int need_frame_base = 0;
1058 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1059 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
1062 printf ("DW_OP_deref");
1065 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1066 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
1069 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
1070 printf ("DW_OP_const1s: %ld", (long) svalue);
1073 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1074 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
1077 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1078 printf ("DW_OP_const2s: %ld", (long) svalue);
1081 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1082 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
1085 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1086 printf ("DW_OP_const4s: %ld", (long) svalue);
1089 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1090 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
1091 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1092 printf ("%lu", (unsigned long) uvalue);
1095 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1096 printf ("DW_OP_const8s: %ld ", (long) svalue);
1097 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1098 printf ("%ld", (long) svalue);
1101 printf ("DW_OP_constu: %s",
1102 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1106 printf ("DW_OP_consts: %s",
1107 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1111 printf ("DW_OP_dup");
1114 printf ("DW_OP_drop");
1117 printf ("DW_OP_over");
1120 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1121 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
1124 printf ("DW_OP_swap");
1127 printf ("DW_OP_rot");
1130 printf ("DW_OP_xderef");
1133 printf ("DW_OP_abs");
1136 printf ("DW_OP_and");
1139 printf ("DW_OP_div");
1142 printf ("DW_OP_minus");
1145 printf ("DW_OP_mod");
1148 printf ("DW_OP_mul");
1151 printf ("DW_OP_neg");
1154 printf ("DW_OP_not");
1157 printf ("DW_OP_or");
1160 printf ("DW_OP_plus");
1162 case DW_OP_plus_uconst:
1163 printf ("DW_OP_plus_uconst: %s",
1164 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1168 printf ("DW_OP_shl");
1171 printf ("DW_OP_shr");
1174 printf ("DW_OP_shra");
1177 printf ("DW_OP_xor");
1180 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1181 printf ("DW_OP_bra: %ld", (long) svalue);
1184 printf ("DW_OP_eq");
1187 printf ("DW_OP_ge");
1190 printf ("DW_OP_gt");
1193 printf ("DW_OP_le");
1196 printf ("DW_OP_lt");
1199 printf ("DW_OP_ne");
1202 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1203 printf ("DW_OP_skip: %ld", (long) svalue);
1238 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1273 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1274 regname (op - DW_OP_reg0, 1));
1309 printf ("DW_OP_breg%d (%s): %s",
1311 regname (op - DW_OP_breg0, 1),
1312 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1317 uvalue = read_uleb128 (data, &bytes_read, end);
1319 printf ("DW_OP_regx: %s (%s)",
1320 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1323 need_frame_base = 1;
1324 printf ("DW_OP_fbreg: %s",
1325 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1329 uvalue = read_uleb128 (data, &bytes_read, end);
1331 printf ("DW_OP_bregx: %s (%s) %s",
1332 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1333 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1337 printf ("DW_OP_piece: %s",
1338 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1341 case DW_OP_deref_size:
1342 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1343 printf ("DW_OP_deref_size: %ld", (long) uvalue);
1345 case DW_OP_xderef_size:
1346 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1347 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1350 printf ("DW_OP_nop");
1353 /* DWARF 3 extensions. */
1354 case DW_OP_push_object_address:
1355 printf ("DW_OP_push_object_address");
1358 /* XXX: Strictly speaking for 64-bit DWARF3 files
1359 this ought to be an 8-byte wide computation. */
1360 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1361 printf ("DW_OP_call2: <0x%s>",
1362 dwarf_vmatoa ("x", svalue + cu_offset));
1365 /* XXX: Strictly speaking for 64-bit DWARF3 files
1366 this ought to be an 8-byte wide computation. */
1367 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1368 printf ("DW_OP_call4: <0x%s>",
1369 dwarf_vmatoa ("x", svalue + cu_offset));
1371 case DW_OP_call_ref:
1372 /* XXX: Strictly speaking for 64-bit DWARF3 files
1373 this ought to be an 8-byte wide computation. */
1374 if (dwarf_version == -1)
1376 printf (_("(DW_OP_call_ref in frame info)"));
1377 /* No way to tell where the next op is, so just bail. */
1378 return need_frame_base;
1380 if (dwarf_version == 2)
1382 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1386 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1388 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1390 case DW_OP_form_tls_address:
1391 printf ("DW_OP_form_tls_address");
1393 case DW_OP_call_frame_cfa:
1394 printf ("DW_OP_call_frame_cfa");
1396 case DW_OP_bit_piece:
1397 printf ("DW_OP_bit_piece: ");
1398 printf (_("size: %s "),
1399 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1401 printf (_("offset: %s "),
1402 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1406 /* DWARF 4 extensions. */
1407 case DW_OP_stack_value:
1408 printf ("DW_OP_stack_value");
1411 case DW_OP_implicit_value:
1412 printf ("DW_OP_implicit_value");
1413 uvalue = read_uleb128 (data, &bytes_read, end);
1415 data = display_block (data, uvalue, end, ' ');
1418 /* GNU extensions. */
1419 case DW_OP_GNU_push_tls_address:
1420 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1422 case DW_OP_GNU_uninit:
1423 printf ("DW_OP_GNU_uninit");
1424 /* FIXME: Is there data associated with this OP ? */
1426 case DW_OP_GNU_encoded_addr:
1433 addr = get_encoded_value (&data, encoding, section, end);
1435 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1436 print_dwarf_vma (addr, pointer_size);
1439 case DW_OP_implicit_pointer:
1440 case DW_OP_GNU_implicit_pointer:
1441 /* XXX: Strictly speaking for 64-bit DWARF3 files
1442 this ought to be an 8-byte wide computation. */
1443 if (dwarf_version == -1)
1445 printf (_("(%s in frame info)"),
1446 (op == DW_OP_implicit_pointer
1447 ? "DW_OP_implicit_pointer"
1448 : "DW_OP_GNU_implicit_pointer"));
1449 /* No way to tell where the next op is, so just bail. */
1450 return need_frame_base;
1452 if (dwarf_version == 2)
1454 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1458 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1460 printf ("%s: <0x%s> %s",
1461 (op == DW_OP_implicit_pointer
1462 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1463 dwarf_vmatoa ("x", uvalue),
1464 dwarf_vmatoa ("d", read_sleb128 (data,
1465 &bytes_read, end)));
1468 case DW_OP_entry_value:
1469 case DW_OP_GNU_entry_value:
1470 uvalue = read_uleb128 (data, &bytes_read, end);
1472 /* PR 17531: file: 0cc9cd00. */
1473 if (uvalue > (dwarf_vma) (end - data))
1474 uvalue = end - data;
1475 printf ("%s: (", (op == DW_OP_entry_value ? "DW_OP_entry_value"
1476 : "DW_OP_GNU_entry_value"));
1477 if (decode_location_expression (data, pointer_size, offset_size,
1478 dwarf_version, uvalue,
1479 cu_offset, section))
1480 need_frame_base = 1;
1486 case DW_OP_const_type:
1487 case DW_OP_GNU_const_type:
1488 uvalue = read_uleb128 (data, &bytes_read, end);
1490 printf ("%s: <0x%s> ",
1491 (op == DW_OP_const_type ? "DW_OP_const_type"
1492 : "DW_OP_GNU_const_type"),
1493 dwarf_vmatoa ("x", cu_offset + uvalue));
1494 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1495 data = display_block (data, uvalue, end, ' ');
1497 case DW_OP_regval_type:
1498 case DW_OP_GNU_regval_type:
1499 uvalue = read_uleb128 (data, &bytes_read, end);
1501 printf ("%s: %s (%s)",
1502 (op == DW_OP_regval_type ? "DW_OP_regval_type"
1503 : "DW_OP_GNU_regval_type"),
1504 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1505 uvalue = read_uleb128 (data, &bytes_read, end);
1507 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1509 case DW_OP_deref_type:
1510 case DW_OP_GNU_deref_type:
1511 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1513 (op == DW_OP_deref_type ? "DW_OP_deref_type"
1514 : "DW_OP_GNU_deref_type"),
1516 uvalue = read_uleb128 (data, &bytes_read, end);
1518 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1521 case DW_OP_GNU_convert:
1522 uvalue = read_uleb128 (data, &bytes_read, end);
1524 printf ("%s <0x%s>",
1525 (op == DW_OP_convert ? "DW_OP_convert" : "DW_OP_GNU_convert"),
1526 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1528 case DW_OP_reinterpret:
1529 case DW_OP_GNU_reinterpret:
1530 uvalue = read_uleb128 (data, &bytes_read, end);
1532 printf ("%s <0x%s>",
1533 (op == DW_OP_reinterpret ? "DW_OP_reinterpret"
1534 : "DW_OP_GNU_reinterpret"),
1535 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1537 case DW_OP_GNU_parameter_ref:
1538 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1539 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1540 dwarf_vmatoa ("x", cu_offset + uvalue));
1542 case DW_OP_GNU_addr_index:
1543 uvalue = read_uleb128 (data, &bytes_read, end);
1545 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1547 case DW_OP_GNU_const_index:
1548 uvalue = read_uleb128 (data, &bytes_read, end);
1550 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1553 /* HP extensions. */
1554 case DW_OP_HP_is_value:
1555 printf ("DW_OP_HP_is_value");
1556 /* FIXME: Is there data associated with this OP ? */
1558 case DW_OP_HP_fltconst4:
1559 printf ("DW_OP_HP_fltconst4");
1560 /* FIXME: Is there data associated with this OP ? */
1562 case DW_OP_HP_fltconst8:
1563 printf ("DW_OP_HP_fltconst8");
1564 /* FIXME: Is there data associated with this OP ? */
1566 case DW_OP_HP_mod_range:
1567 printf ("DW_OP_HP_mod_range");
1568 /* FIXME: Is there data associated with this OP ? */
1570 case DW_OP_HP_unmod_range:
1571 printf ("DW_OP_HP_unmod_range");
1572 /* FIXME: Is there data associated with this OP ? */
1575 printf ("DW_OP_HP_tls");
1576 /* FIXME: Is there data associated with this OP ? */
1579 /* PGI (STMicroelectronics) extensions. */
1580 case DW_OP_PGI_omp_thread_num:
1581 /* Pushes the thread number for the current thread as it would be
1582 returned by the standard OpenMP library function:
1583 omp_get_thread_num(). The "current thread" is the thread for
1584 which the expression is being evaluated. */
1585 printf ("DW_OP_PGI_omp_thread_num");
1589 if (op >= DW_OP_lo_user
1590 && op <= DW_OP_hi_user)
1591 printf (_("(User defined location op 0x%x)"), op);
1593 printf (_("(Unknown location op 0x%x)"), op);
1594 /* No way to tell where the next op is, so just bail. */
1595 return need_frame_base;
1598 /* Separate the ops. */
1603 return need_frame_base;
1606 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1607 This is used for DWARF package files. */
1609 static struct cu_tu_set *
1610 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1612 struct cu_tu_set *p;
1614 unsigned int dw_sect;
1620 dw_sect = DW_SECT_TYPES;
1626 dw_sect = DW_SECT_INFO;
1630 if (p->section_offsets [dw_sect] == cu_offset)
1638 /* Add INC to HIGH_BITS:LOW_BITS. */
1640 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1642 dwarf_vma tmp = * low_bits;
1646 /* FIXME: There is probably a better way of handling this:
1648 We need to cope with dwarf_vma being a 32-bit or 64-bit
1649 type. Plus regardless of its size LOW_BITS is meant to
1650 only hold 32-bits, so if there is overflow or wrap around
1651 we must propagate into HIGH_BITS. */
1652 if (tmp < * low_bits)
1656 else if (sizeof (tmp) > 8
1666 static unsigned char *
1667 read_and_display_attr_value (unsigned long attribute,
1669 dwarf_signed_vma implicit_const,
1670 unsigned char * data,
1671 unsigned char * end,
1672 dwarf_vma cu_offset,
1673 dwarf_vma pointer_size,
1674 dwarf_vma offset_size,
1676 debug_info * debug_info_p,
1678 struct dwarf_section * section,
1679 struct cu_tu_set * this_set, char delimiter)
1681 dwarf_vma uvalue = 0;
1682 unsigned char *block_start = NULL;
1683 unsigned char * orig_data = data;
1684 unsigned int bytes_read;
1686 if (data > end || (data == end && form != DW_FORM_flag_present))
1688 warn (_("Corrupt attribute\n"));
1697 case DW_FORM_ref_addr:
1698 if (dwarf_version == 2)
1699 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1700 else if (dwarf_version == 3 || dwarf_version == 4)
1701 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1703 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1708 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1712 case DW_FORM_line_strp:
1713 case DW_FORM_sec_offset:
1714 case DW_FORM_GNU_ref_alt:
1715 case DW_FORM_GNU_strp_alt:
1716 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1719 case DW_FORM_flag_present:
1726 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1731 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1736 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1740 uvalue = read_sleb128 (data, & bytes_read, end);
1744 case DW_FORM_GNU_str_index:
1745 uvalue = read_uleb128 (data, & bytes_read, end);
1749 case DW_FORM_ref_udata:
1751 uvalue = read_uleb128 (data, & bytes_read, end);
1755 case DW_FORM_indirect:
1756 form = read_uleb128 (data, & bytes_read, end);
1759 printf ("%c%s", delimiter, get_FORM_name (form));
1760 if (form == DW_FORM_implicit_const)
1762 implicit_const = read_sleb128 (data, & bytes_read, end);
1765 return read_and_display_attr_value (attribute, form, implicit_const, data,
1766 end, cu_offset, pointer_size,
1767 offset_size, dwarf_version,
1768 debug_info_p, do_loc,
1769 section, this_set, delimiter);
1770 case DW_FORM_GNU_addr_index:
1771 uvalue = read_uleb128 (data, & bytes_read, end);
1778 case DW_FORM_ref_addr:
1780 printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x",uvalue));
1783 case DW_FORM_GNU_ref_alt:
1785 printf ("%c<alt 0x%s>", delimiter, dwarf_vmatoa ("x",uvalue));
1791 case DW_FORM_ref_udata:
1793 printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x", uvalue + cu_offset));
1798 case DW_FORM_sec_offset:
1800 printf ("%c0x%s", delimiter, dwarf_vmatoa ("x", uvalue));
1803 case DW_FORM_flag_present:
1810 printf ("%c%s", delimiter, dwarf_vmatoa ("d", uvalue));
1813 case DW_FORM_implicit_const:
1815 printf ("%c%s", delimiter, dwarf_vmatoa ("d", implicit_const));
1822 dwarf_vma high_bits;
1826 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1828 if (form == DW_FORM_ref8)
1829 add64 (& high_bits, & utmp, cu_offset);
1830 printf ("%c0x%s", delimiter,
1831 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1834 if ((do_loc || do_debug_loc || do_debug_ranges)
1835 && num_debug_info_entries == 0)
1837 if (sizeof (uvalue) == 8)
1838 SAFE_BYTE_GET (uvalue, data, 8, end);
1840 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1846 case DW_FORM_data16:
1849 dwarf_vma left_high_bits, left_low_bits;
1850 dwarf_vma right_high_bits, right_low_bits;
1852 SAFE_BYTE_GET64 (data, &left_high_bits, &left_low_bits, end);
1853 SAFE_BYTE_GET64 (data + 8, &right_high_bits, &right_low_bits, end);
1854 if (byte_get == byte_get_little_endian)
1857 left_high_bits ^= right_high_bits;
1858 right_high_bits ^= left_high_bits;
1859 left_high_bits ^= right_high_bits;
1860 left_low_bits ^= right_low_bits;
1861 right_low_bits ^= left_low_bits;
1862 left_low_bits ^= right_low_bits;
1864 printf (" 0x%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x"
1865 "%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x",
1866 left_high_bits, left_low_bits, right_high_bits,
1872 case DW_FORM_string:
1874 printf ("%c%.*s", delimiter, (int) (end - data), data);
1875 data += strnlen ((char *) data, end - data) + 1;
1879 case DW_FORM_exprloc:
1880 uvalue = read_uleb128 (data, & bytes_read, end);
1881 block_start = data + bytes_read;
1882 if (block_start >= end)
1884 warn (_("Block ends prematurely\n"));
1888 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1889 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1890 block_start + uvalue here. */
1891 data = block_start + uvalue;
1892 /* PR 17512: file: 008-103549-0.001:0.1. */
1893 if (block_start + uvalue > end || data < block_start)
1895 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1896 uvalue = end - block_start;
1899 data = block_start + uvalue;
1901 data = display_block (block_start, uvalue, end, delimiter);
1904 case DW_FORM_block1:
1905 SAFE_BYTE_GET (uvalue, data, 1, end);
1906 block_start = data + 1;
1907 if (block_start >= end)
1909 warn (_("Block ends prematurely\n"));
1913 data = block_start + uvalue;
1914 if (block_start + uvalue > end || data < block_start)
1916 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1917 uvalue = end - block_start;
1920 data = block_start + uvalue;
1922 data = display_block (block_start, uvalue, end, delimiter);
1925 case DW_FORM_block2:
1926 SAFE_BYTE_GET (uvalue, data, 2, end);
1927 block_start = data + 2;
1928 if (block_start >= end)
1930 warn (_("Block ends prematurely\n"));
1934 data = block_start + uvalue;
1935 if (block_start + uvalue > end || data < block_start)
1937 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1938 uvalue = end - block_start;
1941 data = block_start + uvalue;
1943 data = display_block (block_start, uvalue, end, delimiter);
1946 case DW_FORM_block4:
1947 SAFE_BYTE_GET (uvalue, data, 4, end);
1948 block_start = data + 4;
1949 /* PR 17512: file: 3371-3907-0.004. */
1950 if (block_start >= end)
1952 warn (_("Block ends prematurely\n"));
1956 data = block_start + uvalue;
1957 if (block_start + uvalue > end
1958 /* PR 17531: file: 5b5f0592. */
1959 || data < block_start)
1961 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1962 uvalue = end - block_start;
1965 data = block_start + uvalue;
1967 data = display_block (block_start, uvalue, end, delimiter);
1972 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter,
1973 dwarf_vmatoa ("x", uvalue),
1974 fetch_indirect_string (uvalue));
1977 case DW_FORM_line_strp:
1979 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter,
1980 dwarf_vmatoa ("x", uvalue),
1981 fetch_indirect_line_string (uvalue));
1984 case DW_FORM_GNU_str_index:
1987 const char *suffix = strrchr (section->name, '.');
1988 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1990 printf (_("%c(indexed string: 0x%s): %s"), delimiter,
1991 dwarf_vmatoa ("x", uvalue),
1992 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1996 case DW_FORM_GNU_strp_alt:
1998 printf (_("%c(alt indirect string, offset: 0x%s)"), delimiter,
1999 dwarf_vmatoa ("x", uvalue));
2002 case DW_FORM_indirect:
2003 /* Handled above. */
2006 case DW_FORM_ref_sig8:
2009 dwarf_vma high_bits;
2012 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
2013 printf ("%csignature: 0x%s", delimiter,
2014 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
2019 case DW_FORM_GNU_addr_index:
2021 printf (_("%c(addr_index: 0x%s): %s"), delimiter,
2022 dwarf_vmatoa ("x", uvalue),
2023 fetch_indexed_value (uvalue * pointer_size, pointer_size));
2027 warn (_("Unrecognized form: %lu\n"), form);
2031 if ((do_loc || do_debug_loc || do_debug_ranges)
2032 && num_debug_info_entries == 0
2033 && debug_info_p != NULL)
2037 case DW_AT_frame_base:
2038 have_frame_base = 1;
2040 case DW_AT_location:
2041 case DW_AT_GNU_locviews:
2042 case DW_AT_string_length:
2043 case DW_AT_return_addr:
2044 case DW_AT_data_member_location:
2045 case DW_AT_vtable_elem_location:
2047 case DW_AT_static_link:
2048 case DW_AT_use_location:
2049 case DW_AT_call_value:
2050 case DW_AT_GNU_call_site_value:
2051 case DW_AT_call_data_value:
2052 case DW_AT_GNU_call_site_data_value:
2053 case DW_AT_call_target:
2054 case DW_AT_GNU_call_site_target:
2055 case DW_AT_call_target_clobbered:
2056 case DW_AT_GNU_call_site_target_clobbered:
2057 if ((dwarf_version < 4
2058 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2059 || form == DW_FORM_sec_offset)
2061 /* Process location list. */
2062 unsigned int lmax = debug_info_p->max_loc_offsets;
2063 unsigned int num = debug_info_p->num_loc_offsets;
2065 if (lmax == 0 || num >= lmax)
2068 debug_info_p->loc_offsets = (dwarf_vma *)
2069 xcrealloc (debug_info_p->loc_offsets,
2070 lmax, sizeof (*debug_info_p->loc_offsets));
2071 debug_info_p->loc_views = (dwarf_vma *)
2072 xcrealloc (debug_info_p->loc_views,
2073 lmax, sizeof (*debug_info_p->loc_views));
2074 debug_info_p->have_frame_base = (int *)
2075 xcrealloc (debug_info_p->have_frame_base,
2076 lmax, sizeof (*debug_info_p->have_frame_base));
2077 debug_info_p->max_loc_offsets = lmax;
2079 if (this_set != NULL)
2080 uvalue += this_set->section_offsets [DW_SECT_LOC];
2081 debug_info_p->have_frame_base [num] = have_frame_base;
2082 if (attribute != DW_AT_GNU_locviews)
2084 debug_info_p->loc_offsets [num] = uvalue;
2085 debug_info_p->num_loc_offsets++;
2086 assert (debug_info_p->num_loc_offsets
2087 - debug_info_p->num_loc_views <= 1);
2091 assert (debug_info_p->num_loc_views <= num);
2092 num = debug_info_p->num_loc_views;
2093 debug_info_p->loc_views [num] = uvalue;
2094 debug_info_p->num_loc_views++;
2095 assert (debug_info_p->num_loc_views
2096 - debug_info_p->num_loc_offsets <= 1);
2102 if (need_base_address)
2103 debug_info_p->base_address = uvalue;
2106 case DW_AT_GNU_addr_base:
2107 debug_info_p->addr_base = uvalue;
2110 case DW_AT_GNU_ranges_base:
2111 debug_info_p->ranges_base = uvalue;
2115 if ((dwarf_version < 4
2116 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2117 || form == DW_FORM_sec_offset)
2119 /* Process range list. */
2120 unsigned int lmax = debug_info_p->max_range_lists;
2121 unsigned int num = debug_info_p->num_range_lists;
2123 if (lmax == 0 || num >= lmax)
2126 debug_info_p->range_lists = (dwarf_vma *)
2127 xcrealloc (debug_info_p->range_lists,
2128 lmax, sizeof (*debug_info_p->range_lists));
2129 debug_info_p->max_range_lists = lmax;
2131 debug_info_p->range_lists [num] = uvalue;
2132 debug_info_p->num_range_lists++;
2141 if (do_loc || attribute == 0)
2144 /* For some attributes we can display further information. */
2151 case DW_INL_not_inlined:
2152 printf (_("(not inlined)"));
2154 case DW_INL_inlined:
2155 printf (_("(inlined)"));
2157 case DW_INL_declared_not_inlined:
2158 printf (_("(declared as inline but ignored)"));
2160 case DW_INL_declared_inlined:
2161 printf (_("(declared as inline and inlined)"));
2164 printf (_(" (Unknown inline attribute value: %s)"),
2165 dwarf_vmatoa ("x", uvalue));
2170 case DW_AT_language:
2174 /* Ordered by the numeric value of these constants. */
2175 case DW_LANG_C89: printf ("(ANSI C)"); break;
2176 case DW_LANG_C: printf ("(non-ANSI C)"); break;
2177 case DW_LANG_Ada83: printf ("(Ada)"); break;
2178 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
2179 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
2180 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
2181 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
2182 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
2183 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
2184 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
2185 /* DWARF 2.1 values. */
2186 case DW_LANG_Java: printf ("(Java)"); break;
2187 case DW_LANG_C99: printf ("(ANSI C99)"); break;
2188 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
2189 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
2190 /* DWARF 3 values. */
2191 case DW_LANG_PLI: printf ("(PLI)"); break;
2192 case DW_LANG_ObjC: printf ("(Objective C)"); break;
2193 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
2194 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
2195 case DW_LANG_D: printf ("(D)"); break;
2196 /* DWARF 4 values. */
2197 case DW_LANG_Python: printf ("(Python)"); break;
2198 /* DWARF 5 values. */
2199 case DW_LANG_Go: printf ("(Go)"); break;
2200 case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break;
2201 case DW_LANG_C11: printf ("(C11)"); break;
2202 case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break;
2203 case DW_LANG_Fortran03: printf ("(Fortran 03)"); break;
2204 case DW_LANG_Fortran08: printf ("(Fortran 08)"); break;
2205 /* MIPS extension. */
2206 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
2207 /* UPC extension. */
2208 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
2210 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
2211 printf (_("(implementation defined: %s)"),
2212 dwarf_vmatoa ("x", uvalue));
2214 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
2219 case DW_AT_encoding:
2223 case DW_ATE_void: printf ("(void)"); break;
2224 case DW_ATE_address: printf ("(machine address)"); break;
2225 case DW_ATE_boolean: printf ("(boolean)"); break;
2226 case DW_ATE_complex_float: printf ("(complex float)"); break;
2227 case DW_ATE_float: printf ("(float)"); break;
2228 case DW_ATE_signed: printf ("(signed)"); break;
2229 case DW_ATE_signed_char: printf ("(signed char)"); break;
2230 case DW_ATE_unsigned: printf ("(unsigned)"); break;
2231 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
2232 /* DWARF 2.1 values: */
2233 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
2234 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
2235 /* DWARF 3 values: */
2236 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
2237 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
2238 case DW_ATE_edited: printf ("(edited)"); break;
2239 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
2240 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
2241 /* HP extensions: */
2242 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
2243 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
2244 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
2245 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
2246 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
2247 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
2248 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
2249 /* DWARF 4 values: */
2250 case DW_ATE_UTF: printf ("(unicode string)"); break;
2253 if (uvalue >= DW_ATE_lo_user
2254 && uvalue <= DW_ATE_hi_user)
2255 printf (_("(user defined type)"));
2257 printf (_("(unknown type)"));
2262 case DW_AT_accessibility:
2266 case DW_ACCESS_public: printf ("(public)"); break;
2267 case DW_ACCESS_protected: printf ("(protected)"); break;
2268 case DW_ACCESS_private: printf ("(private)"); break;
2270 printf (_("(unknown accessibility)"));
2275 case DW_AT_visibility:
2279 case DW_VIS_local: printf ("(local)"); break;
2280 case DW_VIS_exported: printf ("(exported)"); break;
2281 case DW_VIS_qualified: printf ("(qualified)"); break;
2282 default: printf (_("(unknown visibility)")); break;
2286 case DW_AT_virtuality:
2290 case DW_VIRTUALITY_none: printf ("(none)"); break;
2291 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2292 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2293 default: printf (_("(unknown virtuality)")); break;
2297 case DW_AT_identifier_case:
2301 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2302 case DW_ID_up_case: printf ("(up_case)"); break;
2303 case DW_ID_down_case: printf ("(down_case)"); break;
2304 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
2305 default: printf (_("(unknown case)")); break;
2309 case DW_AT_calling_convention:
2313 case DW_CC_normal: printf ("(normal)"); break;
2314 case DW_CC_program: printf ("(program)"); break;
2315 case DW_CC_nocall: printf ("(nocall)"); break;
2317 if (uvalue >= DW_CC_lo_user
2318 && uvalue <= DW_CC_hi_user)
2319 printf (_("(user defined)"));
2321 printf (_("(unknown convention)"));
2325 case DW_AT_ordering:
2329 case -1: printf (_("(undefined)")); break;
2330 case 0: printf ("(row major)"); break;
2331 case 1: printf ("(column major)"); break;
2335 case DW_AT_frame_base:
2336 have_frame_base = 1;
2338 case DW_AT_location:
2339 case DW_AT_string_length:
2340 case DW_AT_return_addr:
2341 case DW_AT_data_member_location:
2342 case DW_AT_vtable_elem_location:
2344 case DW_AT_static_link:
2345 case DW_AT_use_location:
2346 case DW_AT_call_value:
2347 case DW_AT_GNU_call_site_value:
2348 case DW_AT_call_data_value:
2349 case DW_AT_GNU_call_site_data_value:
2350 case DW_AT_call_target:
2351 case DW_AT_GNU_call_site_target:
2352 case DW_AT_call_target_clobbered:
2353 case DW_AT_GNU_call_site_target_clobbered:
2354 if ((dwarf_version < 4
2355 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2356 || form == DW_FORM_sec_offset)
2357 printf (_(" (location list)"));
2359 case DW_AT_allocated:
2360 case DW_AT_associated:
2361 case DW_AT_data_location:
2363 case DW_AT_upper_bound:
2364 case DW_AT_lower_bound:
2367 int need_frame_base;
2370 need_frame_base = decode_location_expression (block_start,
2375 cu_offset, section);
2377 if (need_frame_base && !have_frame_base)
2378 printf (_(" [without DW_AT_frame_base]"));
2384 if (form == DW_FORM_ref_sig8
2385 || form == DW_FORM_GNU_ref_alt)
2388 if (form == DW_FORM_ref1
2389 || form == DW_FORM_ref2
2390 || form == DW_FORM_ref4
2391 || form == DW_FORM_ref_udata)
2392 uvalue += cu_offset;
2394 if (uvalue >= section->size)
2395 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2396 dwarf_vmatoa ("x", uvalue),
2397 (unsigned long) (orig_data - section->start));
2400 unsigned long abbrev_number;
2401 abbrev_entry * entry;
2403 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2405 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2406 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2407 use different abbrev table, and we don't track .debug_info chunks
2409 if (form != DW_FORM_ref_addr)
2411 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2412 if (entry->entry == abbrev_number)
2415 printf (" (%s)", get_TAG_name (entry->tag));
2430 get_AT_name (unsigned long attribute)
2435 return "DW_AT value: 0";
2437 /* One value is shared by the MIPS and HP extensions: */
2438 if (attribute == DW_AT_MIPS_fde)
2439 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2441 name = get_DW_AT_name (attribute);
2445 static char buffer[100];
2447 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2455 static unsigned char *
2456 read_and_display_attr (unsigned long attribute,
2458 dwarf_signed_vma implicit_const,
2459 unsigned char * data,
2460 unsigned char * end,
2461 dwarf_vma cu_offset,
2462 dwarf_vma pointer_size,
2463 dwarf_vma offset_size,
2465 debug_info * debug_info_p,
2467 struct dwarf_section * section,
2468 struct cu_tu_set * this_set)
2471 printf (" %-18s:", get_AT_name (attribute));
2472 data = read_and_display_attr_value (attribute, form, implicit_const, data, end,
2473 cu_offset, pointer_size, offset_size,
2474 dwarf_version, debug_info_p,
2475 do_loc, section, this_set, ' ');
2481 /* Process the contents of a .debug_info section. If do_loc is non-zero
2482 then we are scanning for location lists and we do not want to display
2483 anything to the user. If do_types is non-zero, we are processing
2484 a .debug_types section instead of a .debug_info section. */
2487 process_debug_info (struct dwarf_section *section,
2489 enum dwarf_section_display_enum abbrev_sec,
2493 unsigned char *start = section->start;
2494 unsigned char *end = start + section->size;
2495 unsigned char *section_begin;
2497 unsigned int num_units = 0;
2499 if ((do_loc || do_debug_loc || do_debug_ranges)
2500 && num_debug_info_entries == 0
2505 /* First scan the section to get the number of comp units. */
2506 for (section_begin = start, num_units = 0; section_begin < end;
2509 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2510 will be the length. For a 64-bit DWARF section, it'll be
2511 the escape code 0xffffffff followed by an 8 byte length. */
2512 SAFE_BYTE_GET (length, section_begin, 4, end);
2514 if (length == 0xffffffff)
2516 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2517 section_begin += length + 12;
2519 else if (length >= 0xfffffff0 && length < 0xffffffff)
2521 warn (_("Reserved length value (0x%s) found in section %s\n"),
2522 dwarf_vmatoa ("x", length), section->name);
2526 section_begin += length + 4;
2528 /* Negative values are illegal, they may even cause infinite
2529 looping. This can happen if we can't accurately apply
2530 relocations to an object file, or if the file is corrupt. */
2531 if ((signed long) length <= 0 || section_begin < start)
2533 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2534 dwarf_vmatoa ("x", length), section->name);
2541 error (_("No comp units in %s section ?\n"), section->name);
2545 /* Then allocate an array to hold the information. */
2546 debug_information = (debug_info *) cmalloc (num_units,
2547 sizeof (* debug_information));
2548 if (debug_information == NULL)
2550 error (_("Not enough memory for a debug info array of %u entries\n"),
2552 alloc_num_debug_info_entries = num_debug_info_entries = 0;
2555 /* PR 17531: file: 92ca3797.
2556 We cannot rely upon the debug_information array being initialised
2557 before it is used. A corrupt file could easily contain references
2558 to a unit for which information has not been made available. So
2559 we ensure that the array is zeroed here. */
2560 memset (debug_information, 0, num_units * sizeof (*debug_information));
2562 alloc_num_debug_info_entries = num_units;
2567 if (dwarf_start_die == 0)
2568 printf (_("Contents of the %s section:\n\n"), section->name);
2570 load_debug_section (str, file);
2571 load_debug_section (line_str, file);
2572 load_debug_section (str_dwo, file);
2573 load_debug_section (str_index, file);
2574 load_debug_section (str_index_dwo, file);
2575 load_debug_section (debug_addr, file);
2578 load_debug_section (abbrev_sec, file);
2579 if (debug_displays [abbrev_sec].section.start == NULL)
2581 warn (_("Unable to locate %s section!\n"),
2582 debug_displays [abbrev_sec].section.name);
2586 for (section_begin = start, unit = 0; start < end; unit++)
2588 DWARF2_Internal_CompUnit compunit;
2589 unsigned char *hdrptr;
2590 unsigned char *tags;
2591 int level, last_level, saved_level;
2592 dwarf_vma cu_offset;
2593 unsigned int offset_size;
2594 int initial_length_size;
2595 dwarf_vma signature_high = 0;
2596 dwarf_vma signature_low = 0;
2597 dwarf_vma type_offset = 0;
2598 struct cu_tu_set *this_set;
2599 dwarf_vma abbrev_base;
2604 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2606 if (compunit.cu_length == 0xffffffff)
2608 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2610 initial_length_size = 12;
2615 initial_length_size = 4;
2618 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2620 cu_offset = start - section_begin;
2622 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2624 if (compunit.cu_version < 5)
2626 compunit.cu_unit_type = DW_UT_compile;
2627 /* Initialize it due to a false compiler warning. */
2628 compunit.cu_pointer_size = -1;
2632 SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end);
2633 do_types = (compunit.cu_unit_type == DW_UT_type);
2635 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2638 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2640 if (this_set == NULL)
2643 abbrev_size = debug_displays [abbrev_sec].section.size;
2647 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2648 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2651 if (compunit.cu_version < 5)
2652 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2654 /* PR 17512: file: 001-108546-0.001:0.1. */
2655 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2657 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2658 compunit.cu_pointer_size, offset_size);
2659 compunit.cu_pointer_size = offset_size;
2664 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2666 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2669 if ((do_loc || do_debug_loc || do_debug_ranges)
2670 && num_debug_info_entries == 0
2673 debug_information [unit].cu_offset = cu_offset;
2674 debug_information [unit].pointer_size
2675 = compunit.cu_pointer_size;
2676 debug_information [unit].offset_size = offset_size;
2677 debug_information [unit].dwarf_version = compunit.cu_version;
2678 debug_information [unit].base_address = 0;
2679 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2680 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2681 debug_information [unit].loc_offsets = NULL;
2682 debug_information [unit].have_frame_base = NULL;
2683 debug_information [unit].max_loc_offsets = 0;
2684 debug_information [unit].num_loc_offsets = 0;
2685 debug_information [unit].range_lists = NULL;
2686 debug_information [unit].max_range_lists= 0;
2687 debug_information [unit].num_range_lists = 0;
2690 if (!do_loc && dwarf_start_die == 0)
2692 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2693 dwarf_vmatoa ("x", cu_offset));
2694 printf (_(" Length: 0x%s (%s)\n"),
2695 dwarf_vmatoa ("x", compunit.cu_length),
2696 offset_size == 8 ? "64-bit" : "32-bit");
2697 printf (_(" Version: %d\n"), compunit.cu_version);
2698 printf (_(" Abbrev Offset: 0x%s\n"),
2699 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2700 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2705 printf (_(" Signature: 0x%s\n"),
2706 dwarf_vmatoa64 (signature_high, signature_low,
2707 buf, sizeof (buf)));
2708 printf (_(" Type Offset: 0x%s\n"),
2709 dwarf_vmatoa ("x", type_offset));
2711 if (this_set != NULL)
2713 dwarf_vma *offsets = this_set->section_offsets;
2714 size_t *sizes = this_set->section_sizes;
2716 printf (_(" Section contributions:\n"));
2717 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2718 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2719 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2720 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2721 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2722 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2723 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2724 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2725 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2726 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2727 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2728 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2732 if (cu_offset + compunit.cu_length + initial_length_size
2735 warn (_("Debug info is corrupted, length of CU at %s"
2736 " extends beyond end of section (length = %s)\n"),
2737 dwarf_vmatoa ("x", cu_offset),
2738 dwarf_vmatoa ("x", compunit.cu_length));
2743 start += compunit.cu_length + initial_length_size;
2747 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2748 dwarf_vmatoa ("x", cu_offset));
2752 if (compunit.cu_version < 2 || compunit.cu_version > 5)
2754 warn (_("CU at offset %s contains corrupt or "
2755 "unsupported version number: %d.\n"),
2756 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2760 if (compunit.cu_unit_type != DW_UT_compile
2761 && compunit.cu_unit_type != DW_UT_type)
2763 warn (_("CU at offset %s contains corrupt or "
2764 "unsupported unit type: %d.\n"),
2765 dwarf_vmatoa ("x", cu_offset), compunit.cu_unit_type);
2771 /* Process the abbrevs used by this compilation unit. */
2772 if (compunit.cu_abbrev_offset >= abbrev_size)
2773 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2774 (unsigned long) compunit.cu_abbrev_offset,
2775 (unsigned long) abbrev_size);
2776 /* PR 17531: file:4bcd9ce9. */
2777 else if ((abbrev_base + abbrev_size)
2778 > debug_displays [abbrev_sec].section.size)
2779 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2780 (unsigned long) abbrev_base + abbrev_size,
2781 (unsigned long) debug_displays [abbrev_sec].section.size);
2783 process_abbrev_section
2784 (((unsigned char *) debug_displays [abbrev_sec].section.start
2785 + abbrev_base + compunit.cu_abbrev_offset),
2786 ((unsigned char *) debug_displays [abbrev_sec].section.start
2787 + abbrev_base + abbrev_size));
2792 while (tags < start)
2794 unsigned int bytes_read;
2795 unsigned long abbrev_number;
2796 unsigned long die_offset;
2797 abbrev_entry *entry;
2799 int do_printing = 1;
2801 die_offset = tags - section_begin;
2803 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2806 /* A null DIE marks the end of a list of siblings or it may also be
2807 a section padding. */
2808 if (abbrev_number == 0)
2810 /* Check if it can be a section padding for the last CU. */
2811 if (level == 0 && start == end)
2815 for (chk = tags; chk < start; chk++)
2822 if (!do_loc && die_offset >= dwarf_start_die
2823 && (dwarf_cutoff_level == -1
2824 || level < dwarf_cutoff_level))
2825 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2831 static unsigned num_bogus_warns = 0;
2833 if (num_bogus_warns < 3)
2835 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2836 die_offset, section->name);
2838 if (num_bogus_warns == 3)
2839 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2842 if (dwarf_start_die != 0 && level < saved_level)
2849 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2853 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2854 saved_level = level;
2855 do_printing = (dwarf_cutoff_level == -1
2856 || level < dwarf_cutoff_level);
2858 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2859 level, die_offset, abbrev_number);
2860 else if (dwarf_cutoff_level == -1
2861 || last_level < dwarf_cutoff_level)
2862 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2867 /* Scan through the abbreviation list until we reach the
2869 for (entry = first_abbrev;
2870 entry && entry->entry != abbrev_number;
2871 entry = entry->next)
2876 if (!do_loc && do_printing)
2881 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2882 die_offset, abbrev_number);
2886 if (!do_loc && do_printing)
2887 printf (" (%s)\n", get_TAG_name (entry->tag));
2892 need_base_address = 0;
2894 case DW_TAG_compile_unit:
2895 need_base_address = 1;
2897 case DW_TAG_entry_point:
2898 case DW_TAG_subprogram:
2899 need_base_address = 0;
2900 /* Assuming that there is no DW_AT_frame_base. */
2901 have_frame_base = 0;
2905 debug_info *debug_info_p =
2906 (debug_information && unit < alloc_num_debug_info_entries)
2907 ? debug_information + unit : NULL;
2909 assert (!debug_info_p
2910 || (debug_info_p->num_loc_offsets
2911 == debug_info_p->num_loc_views));
2913 for (attr = entry->first_attr;
2914 attr && attr->attribute;
2917 if (! do_loc && do_printing)
2918 /* Show the offset from where the tag was extracted. */
2919 printf (" <%lx>", (unsigned long)(tags - section_begin));
2921 tags = read_and_display_attr (attr->attribute,
2923 attr->implicit_const,
2927 compunit.cu_pointer_size,
2929 compunit.cu_version,
2931 do_loc || ! do_printing,
2936 /* If a locview attribute appears before a location one,
2937 make sure we don't associate it with an earlier
2940 switch (debug_info_p->num_loc_offsets - debug_info_p->num_loc_views)
2943 debug_info_p->loc_views [debug_info_p->num_loc_views] = vm1;
2944 debug_info_p->num_loc_views++;
2945 assert (debug_info_p->num_loc_views
2946 == debug_info_p->num_loc_offsets);
2953 warn(_("DIE has locviews without loclist\n"));
2954 debug_info_p->num_loc_views--;
2961 if (entry->children)
2966 /* Set num_debug_info_entries here so that it can be used to check if
2967 we need to process .debug_loc and .debug_ranges sections. */
2968 if ((do_loc || do_debug_loc || do_debug_ranges)
2969 && num_debug_info_entries == 0
2972 if (num_units > alloc_num_debug_info_entries)
2973 num_debug_info_entries = alloc_num_debug_info_entries;
2975 num_debug_info_entries = num_units;
2984 /* Locate and scan the .debug_info section in the file and record the pointer
2985 sizes and offsets for the compilation units in it. Usually an executable
2986 will have just one pointer size, but this is not guaranteed, and so we try
2987 not to make any assumptions. Returns zero upon failure, or the number of
2988 compilation units upon success. */
2991 load_debug_info (void * file)
2993 /* If we have already tried and failed to load the .debug_info
2994 section then do not bother to repeat the task. */
2995 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2998 /* If we already have the information there is nothing else to do. */
2999 if (num_debug_info_entries > 0)
3000 return num_debug_info_entries;
3002 /* If this is a DWARF package file, load the CU and TU indexes. */
3003 (void) load_cu_tu_indexes (file);
3005 if (load_debug_section (info, file)
3006 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
3007 return num_debug_info_entries;
3009 if (load_debug_section (info_dwo, file)
3010 && process_debug_info (&debug_displays [info_dwo].section, file,
3012 return num_debug_info_entries;
3014 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
3018 /* Read a DWARF .debug_line section header starting at DATA.
3019 Upon success returns an updated DATA pointer and the LINFO
3020 structure and the END_OF_SEQUENCE pointer will be filled in.
3021 Otherwise returns NULL. */
3023 static unsigned char *
3024 read_debug_line_header (struct dwarf_section * section,
3025 unsigned char * data,
3026 unsigned char * end,
3027 DWARF2_Internal_LineInfo * linfo,
3028 unsigned char ** end_of_sequence)
3030 unsigned char *hdrptr;
3031 unsigned int initial_length_size;
3032 unsigned char address_size, segment_selector_size;
3034 /* Extract information from the Line Number Program Header.
3035 (section 6.2.4 in the Dwarf3 doc). */
3038 /* Get and check the length of the block. */
3039 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
3041 if (linfo->li_length == 0xffffffff)
3043 /* This section is 64-bit DWARF 3. */
3044 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
3045 linfo->li_offset_size = 8;
3046 initial_length_size = 12;
3050 linfo->li_offset_size = 4;
3051 initial_length_size = 4;
3054 if (linfo->li_length + initial_length_size > section->size)
3056 /* If the length field has a relocation against it, then we should
3057 not complain if it is inaccurate (and probably negative). This
3058 happens in object files when the .debug_line section is actually
3059 comprised of several different .debug_line.* sections, (some of
3060 which may be removed by linker garbage collection), and a relocation
3061 is used to compute the correct length once that is done. */
3062 if (reloc_at (section, (hdrptr - section->start) - linfo->li_offset_size))
3064 linfo->li_length = (end - data) - initial_length_size;
3068 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3069 (long) linfo->li_length);
3074 /* Get and check the version number. */
3075 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
3077 if (linfo->li_version != 2
3078 && linfo->li_version != 3
3079 && linfo->li_version != 4
3080 && linfo->li_version != 5)
3082 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3083 "is currently supported.\n"));
3087 if (linfo->li_version >= 5)
3089 SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
3091 SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
3092 if (segment_selector_size != 0)
3094 warn (_("The %s section contains "
3095 "unsupported segment selector size: %d.\n"),
3096 section->name, segment_selector_size);
3101 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr,
3102 linfo->li_offset_size, end);
3103 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
3105 if (linfo->li_version >= 4)
3107 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
3109 if (linfo->li_max_ops_per_insn == 0)
3111 warn (_("Invalid maximum operations per insn.\n"));
3116 linfo->li_max_ops_per_insn = 1;
3118 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
3119 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
3120 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
3121 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
3123 * end_of_sequence = data + linfo->li_length + initial_length_size;
3124 /* PR 17512: file:002-117414-0.004. */
3125 if (* end_of_sequence > end)
3127 warn (_("Line length %s extends beyond end of section\n"),
3128 dwarf_vmatoa ("u", linfo->li_length));
3129 * end_of_sequence = end;
3136 static unsigned char *
3137 display_formatted_table (unsigned char *data,
3138 unsigned char *start, unsigned char *end,
3139 const DWARF2_Internal_LineInfo *linfo,
3140 struct dwarf_section *section, const char *what)
3142 unsigned char *format_start, format_count, *format, formati;
3143 dwarf_vma data_count, datai;
3144 unsigned int bytes_read, namepass, last_entry = 0;
3146 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3147 format_start = data;
3148 for (formati = 0; formati < format_count; formati++)
3150 read_uleb128 (data, & bytes_read, end);
3152 read_uleb128 (data, & bytes_read, end);
3156 warn (_("Corrupt %s format table entry\n"), what);
3161 data_count = read_uleb128 (data, & bytes_read, end);
3165 warn (_("Corrupt %s list\n"), what);
3169 if (data_count == 0)
3171 printf (_("\n The %s Table is empty.\n"), what);
3175 printf (_("\n The %s Table (offset 0x%lx):\n"), what,
3176 (long)(data - start));
3178 printf (_(" Entry"));
3179 /* Delay displaying name as the last entry for better screen layout. */
3180 for (namepass = 0; namepass < 2; namepass++)
3182 format = format_start;
3183 for (formati = 0; formati < format_count; formati++)
3185 dwarf_vma content_type;
3187 content_type = read_uleb128 (format, & bytes_read, end);
3188 format += bytes_read;
3189 if ((content_type == DW_LNCT_path) == (namepass == 1))
3190 switch (content_type)
3193 printf (_("\tName"));
3195 case DW_LNCT_directory_index:
3196 printf (_("\tDir"));
3198 case DW_LNCT_timestamp:
3199 printf (_("\tTime"));
3202 printf (_("\tSize"));
3205 printf (_("\tMD5"));
3208 printf (_("\t(Unknown format content type %s)"),
3209 dwarf_vmatoa ("u", content_type));
3211 read_uleb128 (format, & bytes_read, end);
3212 format += bytes_read;
3217 for (datai = 0; datai < data_count; datai++)
3219 unsigned char *datapass = data;
3221 printf (" %d", last_entry++);
3222 /* Delay displaying name as the last entry for better screen layout. */
3223 for (namepass = 0; namepass < 2; namepass++)
3225 format = format_start;
3227 for (formati = 0; formati < format_count; formati++)
3229 dwarf_vma content_type, form;
3231 content_type = read_uleb128 (format, & bytes_read, end);
3232 format += bytes_read;
3233 form = read_uleb128 (format, & bytes_read, end);
3234 format += bytes_read;
3235 data = read_and_display_attr_value (0, form, 0, data, end, 0, 0,
3236 linfo->li_offset_size,
3237 linfo->li_version, NULL,
3238 ((content_type == DW_LNCT_path) != (namepass == 1)),
3239 section, NULL, '\t');
3244 warn (_("Corrupt %s entries list\n"), what);
3253 display_debug_lines_raw (struct dwarf_section *section,
3254 unsigned char *data,
3255 unsigned char *end, void *file)
3257 unsigned char *start = section->start;
3258 int verbose_view = 0;
3260 printf (_("Raw dump of debug contents of section %s:\n\n"),
3265 static DWARF2_Internal_LineInfo saved_linfo;
3266 DWARF2_Internal_LineInfo linfo;
3267 unsigned char *standard_opcodes;
3268 unsigned char *end_of_sequence;
3271 if (const_strneq (section->name, ".debug_line.")
3272 /* Note: the following does not apply to .debug_line.dwo sections.
3273 These are full debug_line sections. */
3274 && strcmp (section->name, ".debug_line.dwo") != 0)
3276 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3277 section containing just the Line Number Statements. They are
3278 created by the assembler and intended to be used alongside gcc's
3279 -ffunction-sections command line option. When the linker's
3280 garbage collection decides to discard a .text.<foo> section it
3281 can then also discard the line number information in .debug_line.<foo>.
3283 Since the section is a fragment it does not have the details
3284 needed to fill out a LineInfo structure, so instead we use the
3285 details from the last full debug_line section that we processed. */
3286 end_of_sequence = end;
3287 standard_opcodes = NULL;
3288 linfo = saved_linfo;
3289 /* PR 17531: file: 0522b371. */
3290 if (linfo.li_line_range == 0)
3292 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3295 reset_state_machine (linfo.li_default_is_stmt);
3299 unsigned char * hdrptr;
3301 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3302 & end_of_sequence)) == NULL)
3305 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
3306 printf (_(" Length: %ld\n"), (long) linfo.li_length);
3307 printf (_(" DWARF Version: %d\n"), linfo.li_version);
3308 printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length);
3309 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
3310 if (linfo.li_version >= 4)
3311 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
3312 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
3313 printf (_(" Line Base: %d\n"), linfo.li_line_base);
3314 printf (_(" Line Range: %d\n"), linfo.li_line_range);
3315 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
3317 /* PR 17512: file: 1665-6428-0.004. */
3318 if (linfo.li_line_range == 0)
3320 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3321 linfo.li_line_range = 1;
3324 reset_state_machine (linfo.li_default_is_stmt);
3326 /* Display the contents of the Opcodes table. */
3327 standard_opcodes = hdrptr;
3329 /* PR 17512: file: 002-417945-0.004. */
3330 if (standard_opcodes + linfo.li_opcode_base >= end)
3332 warn (_("Line Base extends beyond end of section\n"));
3336 printf (_("\n Opcodes:\n"));
3338 for (i = 1; i < linfo.li_opcode_base; i++)
3339 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
3341 /* Display the contents of the Directory table. */
3342 data = standard_opcodes + linfo.li_opcode_base - 1;
3344 if (linfo.li_version >= 5)
3346 load_debug_section (line_str, file);
3348 data = display_formatted_table (data, start, end, &linfo, section,
3350 data = display_formatted_table (data, start, end, &linfo, section,
3356 printf (_("\n The Directory Table is empty.\n"));
3359 unsigned int last_dir_entry = 0;
3361 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3362 (long)(data - start));
3364 while (data < end && *data != 0)
3366 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
3368 data += strnlen ((char *) data, end - data) + 1;
3371 /* PR 17512: file: 002-132094-0.004. */
3372 if (data >= end - 1)
3376 /* Skip the NUL at the end of the table. */
3379 /* Display the contents of the File Name table. */
3381 printf (_("\n The File Name Table is empty.\n"));
3384 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3385 (long)(data - start));
3386 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3388 while (data < end && *data != 0)
3390 unsigned char *name;
3391 unsigned int bytes_read;
3393 printf (" %d\t", ++state_machine_regs.last_file_entry);
3395 data += strnlen ((char *) data, end - data) + 1;
3398 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3401 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3404 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3406 printf ("%.*s\n", (int)(end - name), name);
3410 warn (_("Corrupt file name table entry\n"));
3416 /* Skip the NUL at the end of the table. */
3421 saved_linfo = linfo;
3424 /* Now display the statements. */
3425 if (data >= end_of_sequence)
3426 printf (_(" No Line Number Statements.\n"));
3429 printf (_(" Line Number Statements:\n"));
3431 while (data < end_of_sequence)
3433 unsigned char op_code;
3434 dwarf_signed_vma adv;
3436 unsigned int bytes_read;
3438 printf (" [0x%08lx]", (long)(data - start));
3442 if (op_code >= linfo.li_opcode_base)
3444 op_code -= linfo.li_opcode_base;
3445 uladv = (op_code / linfo.li_line_range);
3446 if (linfo.li_max_ops_per_insn == 1)
3448 uladv *= linfo.li_min_insn_length;
3449 state_machine_regs.address += uladv;
3451 state_machine_regs.view = 0;
3452 printf (_(" Special opcode %d: "
3453 "advance Address by %s to 0x%s%s"),
3454 op_code, dwarf_vmatoa ("u", uladv),
3455 dwarf_vmatoa ("x", state_machine_regs.address),
3456 verbose_view && uladv
3457 ? _(" (reset view)") : "");
3462 = ((state_machine_regs.op_index + uladv)
3463 / linfo.li_max_ops_per_insn)
3464 * linfo.li_min_insn_length;
3466 state_machine_regs.address += addrdelta;
3467 state_machine_regs.op_index
3468 = (state_machine_regs.op_index + uladv)
3469 % linfo.li_max_ops_per_insn;
3471 state_machine_regs.view = 0;
3472 printf (_(" Special opcode %d: "
3473 "advance Address by %s to 0x%s[%d]%s"),
3474 op_code, dwarf_vmatoa ("u", uladv),
3475 dwarf_vmatoa ("x", state_machine_regs.address),
3476 state_machine_regs.op_index,
3477 verbose_view && addrdelta
3478 ? _(" (reset view)") : "");
3480 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3481 state_machine_regs.line += adv;
3482 printf (_(" and Line by %s to %d"),
3483 dwarf_vmatoa ("d", adv), state_machine_regs.line);
3484 if (verbose_view || state_machine_regs.view)
3485 printf (_(" (view %u)\n"), state_machine_regs.view);
3488 state_machine_regs.view++;
3490 else switch (op_code)
3492 case DW_LNS_extended_op:
3493 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3497 printf (_(" Copy"));
3498 if (verbose_view || state_machine_regs.view)
3499 printf (_(" (view %u)\n"), state_machine_regs.view);
3502 state_machine_regs.view++;
3505 case DW_LNS_advance_pc:
3506 uladv = read_uleb128 (data, & bytes_read, end);
3508 if (linfo.li_max_ops_per_insn == 1)
3510 uladv *= linfo.li_min_insn_length;
3511 state_machine_regs.address += uladv;
3513 state_machine_regs.view = 0;
3514 printf (_(" Advance PC by %s to 0x%s%s\n"),
3515 dwarf_vmatoa ("u", uladv),
3516 dwarf_vmatoa ("x", state_machine_regs.address),
3517 verbose_view && uladv
3518 ? _(" (reset view)") : "");
3523 = ((state_machine_regs.op_index + uladv)
3524 / linfo.li_max_ops_per_insn)
3525 * linfo.li_min_insn_length;
3526 state_machine_regs.address
3528 state_machine_regs.op_index
3529 = (state_machine_regs.op_index + uladv)
3530 % linfo.li_max_ops_per_insn;
3532 state_machine_regs.view = 0;
3533 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
3534 dwarf_vmatoa ("u", uladv),
3535 dwarf_vmatoa ("x", state_machine_regs.address),
3536 state_machine_regs.op_index,
3537 verbose_view && addrdelta
3538 ? _(" (reset view)") : "");
3542 case DW_LNS_advance_line:
3543 adv = read_sleb128 (data, & bytes_read, end);
3545 state_machine_regs.line += adv;
3546 printf (_(" Advance Line by %s to %d\n"),
3547 dwarf_vmatoa ("d", adv),
3548 state_machine_regs.line);
3551 case DW_LNS_set_file:
3552 adv = read_uleb128 (data, & bytes_read, end);
3554 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3555 dwarf_vmatoa ("d", adv));
3556 state_machine_regs.file = adv;
3559 case DW_LNS_set_column:
3560 uladv = read_uleb128 (data, & bytes_read, end);
3562 printf (_(" Set column to %s\n"),
3563 dwarf_vmatoa ("u", uladv));
3564 state_machine_regs.column = uladv;
3567 case DW_LNS_negate_stmt:
3568 adv = state_machine_regs.is_stmt;
3570 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3571 state_machine_regs.is_stmt = adv;
3574 case DW_LNS_set_basic_block:
3575 printf (_(" Set basic block\n"));
3576 state_machine_regs.basic_block = 1;
3579 case DW_LNS_const_add_pc:
3580 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3581 if (linfo.li_max_ops_per_insn)
3583 uladv *= linfo.li_min_insn_length;
3584 state_machine_regs.address += uladv;
3586 state_machine_regs.view = 0;
3587 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
3588 dwarf_vmatoa ("u", uladv),
3589 dwarf_vmatoa ("x", state_machine_regs.address),
3590 verbose_view && uladv
3591 ? _(" (reset view)") : "");
3596 = ((state_machine_regs.op_index + uladv)
3597 / linfo.li_max_ops_per_insn)
3598 * linfo.li_min_insn_length;
3599 state_machine_regs.address
3601 state_machine_regs.op_index
3602 = (state_machine_regs.op_index + uladv)
3603 % linfo.li_max_ops_per_insn;
3605 state_machine_regs.view = 0;
3606 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
3607 dwarf_vmatoa ("u", uladv),
3608 dwarf_vmatoa ("x", state_machine_regs.address),
3609 state_machine_regs.op_index,
3610 verbose_view && addrdelta
3611 ? _(" (reset view)") : "");
3615 case DW_LNS_fixed_advance_pc:
3616 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3617 state_machine_regs.address += uladv;
3618 state_machine_regs.op_index = 0;
3619 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3620 dwarf_vmatoa ("u", uladv),
3621 dwarf_vmatoa ("x", state_machine_regs.address));
3622 /* Do NOT reset view. */
3625 case DW_LNS_set_prologue_end:
3626 printf (_(" Set prologue_end to true\n"));
3629 case DW_LNS_set_epilogue_begin:
3630 printf (_(" Set epilogue_begin to true\n"));
3633 case DW_LNS_set_isa:
3634 uladv = read_uleb128 (data, & bytes_read, end);
3636 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3640 printf (_(" Unknown opcode %d with operands: "), op_code);
3642 if (standard_opcodes != NULL)
3643 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3645 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3647 i == 1 ? "" : ", ");
3663 unsigned char *name;
3664 unsigned int directory_index;
3665 unsigned int modification_date;
3666 unsigned int length;
3669 /* Output a decoded representation of the .debug_line section. */
3672 display_debug_lines_decoded (struct dwarf_section *section,
3673 unsigned char *data,
3674 unsigned char *end, void *fileptr)
3676 static DWARF2_Internal_LineInfo saved_linfo;
3678 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3683 /* This loop amounts to one iteration per compilation unit. */
3684 DWARF2_Internal_LineInfo linfo;
3685 unsigned char *standard_opcodes;
3686 unsigned char *end_of_sequence;
3688 File_Entry *file_table = NULL;
3689 unsigned int n_files = 0;
3690 unsigned char **directory_table = NULL;
3691 dwarf_vma n_directories = 0;
3693 if (const_strneq (section->name, ".debug_line.")
3694 /* Note: the following does not apply to .debug_line.dwo sections.
3695 These are full debug_line sections. */
3696 && strcmp (section->name, ".debug_line.dwo") != 0)
3698 /* See comment in display_debug_lines_raw(). */
3699 end_of_sequence = end;
3700 standard_opcodes = NULL;
3701 linfo = saved_linfo;
3702 /* PR 17531: file: 0522b371. */
3703 if (linfo.li_line_range == 0)
3705 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3708 reset_state_machine (linfo.li_default_is_stmt);
3712 unsigned char *hdrptr;
3714 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3715 & end_of_sequence)) == NULL)
3718 /* PR 17531: file: 0522b371. */
3719 if (linfo.li_line_range == 0)
3721 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3722 linfo.li_line_range = 1;
3724 reset_state_machine (linfo.li_default_is_stmt);
3726 /* Save a pointer to the contents of the Opcodes table. */
3727 standard_opcodes = hdrptr;
3729 /* Traverse the Directory table just to count entries. */
3730 data = standard_opcodes + linfo.li_opcode_base - 1;
3734 warn (_("opcode base of %d extends beyond end of section\n"),
3735 linfo.li_opcode_base);
3739 if (linfo.li_version >= 5)
3741 unsigned char *format_start, format_count, *format;
3742 dwarf_vma formati, entryi;
3743 unsigned int bytes_read;
3745 load_debug_section (line_str, fileptr);
3747 /* Skip directories format. */
3748 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3749 format_start = data;
3750 for (formati = 0; formati < format_count; formati++)
3752 read_uleb128 (data, & bytes_read, end);
3754 read_uleb128 (data, & bytes_read, end);
3758 n_directories = read_uleb128 (data, & bytes_read, end);
3762 warn (_("Corrupt directories list\n"));
3766 directory_table = (unsigned char **)
3767 xmalloc (n_directories * sizeof (unsigned char *));
3769 for (entryi = 0; entryi < n_directories; entryi++)
3771 unsigned char **pathp = &directory_table[entryi];
3773 format = format_start;
3774 for (formati = 0; formati < format_count; formati++)
3776 dwarf_vma content_type, form;
3779 content_type = read_uleb128 (format, & bytes_read, end);
3780 format += bytes_read;
3781 form = read_uleb128 (format, & bytes_read, end);
3782 format += bytes_read;
3785 warn (_("Corrupt directories list\n"));
3788 switch (content_type)
3793 case DW_FORM_string:
3796 case DW_FORM_line_strp:
3797 SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
3799 /* Remove const by the cast. */
3800 *pathp = (unsigned char *)
3801 fetch_indirect_line_string (uvalue);
3806 data = read_and_display_attr_value (0, form, 0, data, end,
3808 linfo.li_offset_size,
3815 warn (_("Corrupt directories list\n"));
3820 /* Skip files format. */
3821 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3822 format_start = data;
3823 for (formati = 0; formati < format_count; formati++)
3825 read_uleb128 (data, & bytes_read, end);
3827 read_uleb128 (data, & bytes_read, end);
3831 n_files = read_uleb128 (data, & bytes_read, end);
3835 warn (_("Corrupt file name list\n"));
3839 file_table = (File_Entry *) xcalloc (1, n_files
3840 * sizeof (File_Entry));
3842 for (entryi = 0; entryi < n_files; entryi++)
3844 File_Entry *file = &file_table[entryi];
3846 format = format_start;
3847 for (formati = 0; formati < format_count; formati++)
3849 dwarf_vma content_type, form;
3852 content_type = read_uleb128 (format, & bytes_read, end);
3853 format += bytes_read;
3854 form = read_uleb128 (format, & bytes_read, end);
3855 format += bytes_read;
3858 warn (_("Corrupt file name list\n"));
3861 switch (content_type)
3866 case DW_FORM_string:
3869 case DW_FORM_line_strp:
3870 SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
3872 /* Remove const by the cast. */
3873 file->name = (unsigned char *)
3874 fetch_indirect_line_string (uvalue);
3878 case DW_LNCT_directory_index:
3882 SAFE_BYTE_GET (file->directory_index, data, 1,
3886 SAFE_BYTE_GET (file->directory_index, data, 2,
3890 file->directory_index = read_uleb128 (data, NULL,
3896 data = read_and_display_attr_value (0, form, 0, data, end,
3898 linfo.li_offset_size,
3905 warn (_("Corrupt file name list\n"));
3914 unsigned char *ptr_directory_table = data;
3916 while (data < end && *data != 0)
3918 data += strnlen ((char *) data, end - data) + 1;
3925 warn (_("directory table ends unexpectedly\n"));
3930 /* Go through the directory table again to save the directories. */
3931 directory_table = (unsigned char **)
3932 xmalloc (n_directories * sizeof (unsigned char *));
3935 while (*ptr_directory_table != 0)
3937 directory_table[i] = ptr_directory_table;
3938 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3939 ptr_directory_table - end) + 1;
3943 /* Skip the NUL at the end of the table. */
3946 /* Traverse the File Name table just to count the entries. */
3947 if (data < end && *data != 0)
3949 unsigned char *ptr_file_name_table = data;
3951 while (data < end && *data != 0)
3953 unsigned int bytes_read;
3955 /* Skip Name, directory index, last modification time and length
3957 data += strnlen ((char *) data, end - data) + 1;
3958 read_uleb128 (data, & bytes_read, end);
3960 read_uleb128 (data, & bytes_read, end);
3962 read_uleb128 (data, & bytes_read, end);
3970 warn (_("file table ends unexpectedly\n"));
3975 /* Go through the file table again to save the strings. */
3976 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3979 while (*ptr_file_name_table != 0)
3981 unsigned int bytes_read;
3983 file_table[i].name = ptr_file_name_table;
3984 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3985 end - ptr_file_name_table) + 1;
3987 /* We are not interested in directory, time or size. */
3988 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3990 ptr_file_name_table += bytes_read;
3991 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3993 ptr_file_name_table += bytes_read;
3994 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3995 ptr_file_name_table += bytes_read;
4001 /* Skip the NUL at the end of the table. */
4005 /* Print the Compilation Unit's name and a header. */
4006 if (file_table == NULL)
4008 else if (directory_table == NULL)
4009 printf (_("CU: %s:\n"), file_table[0].name);
4012 unsigned int ix = file_table[0].directory_index;
4013 const char *directory;
4018 else if (n_directories == 0)
4019 directory = _("<unknown>");
4020 else if (ix > n_directories)
4022 warn (_("directory index %u > number of directories %s\n"),
4023 ix, dwarf_vmatoa ("u", n_directories));
4024 directory = _("<corrupt>");
4027 directory = (char *) directory_table[ix - 1];
4029 if (do_wide || strlen (directory) < 76)
4030 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
4032 printf ("%s:\n", file_table[0].name);
4035 printf (_("File name Line number Starting address View\n"));
4036 saved_linfo = linfo;
4039 /* This loop iterates through the Dwarf Line Number Program. */
4040 while (data < end_of_sequence)
4042 unsigned char op_code;
4045 unsigned long int uladv;
4046 unsigned int bytes_read;
4047 int is_special_opcode = 0;
4052 if (op_code >= linfo.li_opcode_base)
4054 op_code -= linfo.li_opcode_base;
4055 uladv = (op_code / linfo.li_line_range);
4056 if (linfo.li_max_ops_per_insn == 1)
4058 uladv *= linfo.li_min_insn_length;
4059 state_machine_regs.address += uladv;
4061 state_machine_regs.view = 0;
4066 = ((state_machine_regs.op_index + uladv)
4067 / linfo.li_max_ops_per_insn)
4068 * linfo.li_min_insn_length;
4069 state_machine_regs.address
4071 state_machine_regs.op_index
4072 = (state_machine_regs.op_index + uladv)
4073 % linfo.li_max_ops_per_insn;
4075 state_machine_regs.view = 0;
4078 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
4079 state_machine_regs.line += adv;
4080 is_special_opcode = 1;
4081 /* Increment view after printing this row. */
4083 else switch (op_code)
4085 case DW_LNS_extended_op:
4087 unsigned int ext_op_code_len;
4088 unsigned char ext_op_code;
4089 unsigned char *op_code_data = data;
4091 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
4093 op_code_data += bytes_read;
4095 if (ext_op_code_len == 0)
4097 warn (_("Badly formed extended line op encountered!\n"));
4100 ext_op_code_len += bytes_read;
4101 ext_op_code = *op_code_data++;
4105 switch (ext_op_code)
4107 case DW_LNE_end_sequence:
4108 /* Reset stuff after printing this row. */
4110 case DW_LNE_set_address:
4111 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
4113 ext_op_code_len - bytes_read - 1,
4115 state_machine_regs.op_index = 0;
4116 state_machine_regs.view = 0;
4118 case DW_LNE_define_file:
4120 file_table = (File_Entry *) xrealloc
4121 (file_table, (n_files + 1) * sizeof (File_Entry));
4123 ++state_machine_regs.last_file_entry;
4124 /* Source file name. */
4125 file_table[n_files].name = op_code_data;
4126 op_code_data += strlen ((char *) op_code_data) + 1;
4127 /* Directory index. */
4128 file_table[n_files].directory_index =
4129 read_uleb128 (op_code_data, & bytes_read,
4131 op_code_data += bytes_read;
4132 /* Last modification time. */
4133 file_table[n_files].modification_date =
4134 read_uleb128 (op_code_data, & bytes_read,
4136 op_code_data += bytes_read;
4138 file_table[n_files].length =
4139 read_uleb128 (op_code_data, & bytes_read,
4145 case DW_LNE_set_discriminator:
4146 case DW_LNE_HP_set_sequence:
4147 /* Simply ignored. */
4151 printf (_("UNKNOWN (%u): length %d\n"),
4152 ext_op_code, ext_op_code_len - bytes_read);
4155 data += ext_op_code_len;
4159 /* Increment view after printing this row. */
4162 case DW_LNS_advance_pc:
4163 uladv = read_uleb128 (data, & bytes_read, end);
4165 if (linfo.li_max_ops_per_insn == 1)
4167 uladv *= linfo.li_min_insn_length;
4168 state_machine_regs.address += uladv;
4170 state_machine_regs.view = 0;
4175 = ((state_machine_regs.op_index + uladv)
4176 / linfo.li_max_ops_per_insn)
4177 * linfo.li_min_insn_length;
4178 state_machine_regs.address
4180 state_machine_regs.op_index
4181 = (state_machine_regs.op_index + uladv)
4182 % linfo.li_max_ops_per_insn;
4184 state_machine_regs.view = 0;
4188 case DW_LNS_advance_line:
4189 adv = read_sleb128 (data, & bytes_read, end);
4191 state_machine_regs.line += adv;
4194 case DW_LNS_set_file:
4195 adv = read_uleb128 (data, & bytes_read, end);
4197 state_machine_regs.file = adv;
4200 unsigned file = state_machine_regs.file - 1;
4203 if (file_table == NULL || n_files == 0)
4204 printf (_("\n [Use file table entry %d]\n"), file);
4206 else if (file >= n_files)
4208 warn (_("file index %u > number of files %u\n"), file + 1, n_files);
4209 printf (_("\n <over large file table index %u>"), file);
4211 else if ((dir = file_table[file].directory_index) == 0)
4212 /* If directory index is 0, that means current directory. */
4213 printf ("\n./%s:[++]\n", file_table[file].name);
4214 else if (directory_table == NULL || n_directories == 0)
4215 printf (_("\n [Use file %s in directory table entry %d]\n"),
4216 file_table[file].name, dir);
4218 else if (dir > n_directories)
4220 warn (_("directory index %u > number of directories %s\n"),
4221 dir, dwarf_vmatoa ("u", n_directories));
4222 printf (_("\n <over large directory table entry %u>\n"), dir);
4225 printf ("\n%s/%s:\n",
4226 /* The directory index starts counting at 1. */
4227 directory_table[dir - 1], file_table[file].name);
4231 case DW_LNS_set_column:
4232 uladv = read_uleb128 (data, & bytes_read, end);
4234 state_machine_regs.column = uladv;
4237 case DW_LNS_negate_stmt:
4238 adv = state_machine_regs.is_stmt;
4240 state_machine_regs.is_stmt = adv;
4243 case DW_LNS_set_basic_block:
4244 state_machine_regs.basic_block = 1;
4247 case DW_LNS_const_add_pc:
4248 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
4249 if (linfo.li_max_ops_per_insn == 1)
4251 uladv *= linfo.li_min_insn_length;
4252 state_machine_regs.address += uladv;
4254 state_machine_regs.view = 0;
4259 = ((state_machine_regs.op_index + uladv)
4260 / linfo.li_max_ops_per_insn)
4261 * linfo.li_min_insn_length;
4262 state_machine_regs.address
4264 state_machine_regs.op_index
4265 = (state_machine_regs.op_index + uladv)
4266 % linfo.li_max_ops_per_insn;
4268 state_machine_regs.view = 0;
4272 case DW_LNS_fixed_advance_pc:
4273 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
4274 state_machine_regs.address += uladv;
4275 state_machine_regs.op_index = 0;
4276 /* Do NOT reset view. */
4279 case DW_LNS_set_prologue_end:
4282 case DW_LNS_set_epilogue_begin:
4285 case DW_LNS_set_isa:
4286 uladv = read_uleb128 (data, & bytes_read, end);
4288 printf (_(" Set ISA to %lu\n"), uladv);
4292 printf (_(" Unknown opcode %d with operands: "), op_code);
4294 if (standard_opcodes != NULL)
4295 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
4297 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
4299 i == 1 ? "" : ", ");
4306 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4307 to the DWARF address/line matrix. */
4308 if ((is_special_opcode) || (xop == -DW_LNE_end_sequence)
4309 || (xop == DW_LNS_copy))
4311 const unsigned int MAX_FILENAME_LENGTH = 35;
4313 char *newFileName = NULL;
4314 size_t fileNameLength;
4318 unsigned indx = state_machine_regs.file - 1;
4320 if (indx >= n_files)
4322 warn (_("corrupt file index %u encountered\n"), indx);
4323 fileName = _("<corrupt>");
4326 fileName = (char *) file_table[indx].name;
4329 fileName = _("<unknown>");
4331 fileNameLength = strlen (fileName);
4333 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
4335 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
4336 /* Truncate file name */
4337 strncpy (newFileName,
4338 fileName + fileNameLength - MAX_FILENAME_LENGTH,
4339 MAX_FILENAME_LENGTH + 1);
4343 newFileName = (char *) xmalloc (fileNameLength + 1);
4344 strncpy (newFileName, fileName, fileNameLength + 1);
4347 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
4349 if (linfo.li_max_ops_per_insn == 1)
4350 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x",
4351 newFileName, state_machine_regs.line,
4352 state_machine_regs.address);
4354 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]",
4355 newFileName, state_machine_regs.line,
4356 state_machine_regs.address,
4357 state_machine_regs.op_index);
4361 if (linfo.li_max_ops_per_insn == 1)
4362 printf ("%s %11d %#18" DWARF_VMA_FMT "x",
4363 newFileName, state_machine_regs.line,
4364 state_machine_regs.address);
4366 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]",
4367 newFileName, state_machine_regs.line,
4368 state_machine_regs.address,
4369 state_machine_regs.op_index);
4372 if (state_machine_regs.view)
4373 printf (" %6u\n", state_machine_regs.view);
4376 state_machine_regs.view++;
4378 if (xop == -DW_LNE_end_sequence)
4380 reset_state_machine (linfo.li_default_is_stmt);
4395 if (directory_table)
4397 free (directory_table);
4398 directory_table = NULL;
4409 display_debug_lines (struct dwarf_section *section, void *file)
4411 unsigned char *data = section->start;
4412 unsigned char *end = data + section->size;
4414 int retValDecoded = 1;
4416 if (do_debug_lines == 0)
4417 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4419 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
4420 retValRaw = display_debug_lines_raw (section, data, end, file);
4422 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
4423 retValDecoded = display_debug_lines_decoded (section, data, end, file);
4425 if (!retValRaw || !retValDecoded)
4432 find_debug_info_for_offset (unsigned long offset)
4436 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
4439 for (i = 0; i < num_debug_info_entries; i++)
4440 if (debug_information[i].cu_offset == offset)
4441 return debug_information + i;
4447 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
4449 /* See gdb/gdb-index.h. */
4450 static const char * const kinds[] =
4462 return _ (kinds[kind]);
4466 display_debug_pubnames_worker (struct dwarf_section *section,
4467 void *file ATTRIBUTE_UNUSED,
4470 DWARF2_Internal_PubNames names;
4471 unsigned char *start = section->start;
4472 unsigned char *end = start + section->size;
4474 /* It does not matter if this load fails,
4475 we test for that later on. */
4476 load_debug_info (file);
4478 printf (_("Contents of the %s section:\n\n"), section->name);
4482 unsigned char *data;
4485 unsigned int offset_size, initial_length_size;
4489 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
4490 if (names.pn_length == 0xffffffff)
4492 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
4494 initial_length_size = 12;
4499 initial_length_size = 4;
4502 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
4503 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
4505 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4506 && num_debug_info_entries > 0
4507 && find_debug_info_for_offset (names.pn_offset) == NULL)
4508 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4509 (unsigned long) names.pn_offset, section->name);
4511 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
4513 adr = start + names.pn_length + initial_length_size;
4514 /* PR 17531: file: 7615b6b2. */
4515 if ((dwarf_signed_vma) names.pn_length < 0
4516 /* PR 17531: file: a5dbeaa7. */
4519 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
4525 printf (_(" Length: %ld\n"),
4526 (long) names.pn_length);
4527 printf (_(" Version: %d\n"),
4529 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4530 (unsigned long) names.pn_offset);
4531 printf (_(" Size of area in .debug_info section: %ld\n"),
4532 (long) names.pn_size);
4534 if (names.pn_version != 2 && names.pn_version != 3)
4536 static int warned = 0;
4540 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4548 printf (_("\n Offset Kind Name\n"));
4550 printf (_("\n Offset\tName\n"));
4554 bfd_size_type maxprint;
4556 SAFE_BYTE_GET (offset, data, offset_size, end);
4560 data += offset_size;
4563 maxprint = (end - data) - 1;
4567 unsigned int kind_data;
4568 gdb_index_symbol_kind kind;
4569 const char *kind_name;
4572 SAFE_BYTE_GET (kind_data, data, 1, end);
4575 /* GCC computes the kind as the upper byte in the CU index
4576 word, and then right shifts it by the CU index size.
4577 Left shift KIND to where the gdb-index.h accessor macros
4579 kind_data <<= GDB_INDEX_CU_BITSIZE;
4580 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
4581 kind_name = get_gdb_index_symbol_kind_name (kind);
4582 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
4583 printf (" %-6lx %s,%-10s %.*s\n",
4584 (unsigned long) offset, is_static ? _("s") : _("g"),
4585 kind_name, (int) maxprint, data);
4588 printf (" %-6lx\t%.*s\n",
4589 (unsigned long) offset, (int) maxprint, data);
4591 data += strnlen ((char *) data, maxprint) + 1;
4596 while (offset != 0);
4604 display_debug_pubnames (struct dwarf_section *section, void *file)
4606 return display_debug_pubnames_worker (section, file, 0);
4610 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
4612 return display_debug_pubnames_worker (section, file, 1);
4616 display_debug_macinfo (struct dwarf_section *section,
4617 void *file ATTRIBUTE_UNUSED)
4619 unsigned char *start = section->start;
4620 unsigned char *end = start + section->size;
4621 unsigned char *curr = start;
4622 unsigned int bytes_read;
4623 enum dwarf_macinfo_record_type op;
4625 printf (_("Contents of the %s section:\n\n"), section->name);
4629 unsigned int lineno;
4630 const unsigned char *string;
4632 op = (enum dwarf_macinfo_record_type) *curr;
4637 case DW_MACINFO_start_file:
4639 unsigned int filenum;
4641 lineno = read_uleb128 (curr, & bytes_read, end);
4643 filenum = read_uleb128 (curr, & bytes_read, end);
4646 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4651 case DW_MACINFO_end_file:
4652 printf (_(" DW_MACINFO_end_file\n"));
4655 case DW_MACINFO_define:
4656 lineno = read_uleb128 (curr, & bytes_read, end);
4659 curr += strnlen ((char *) string, end - string) + 1;
4660 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4664 case DW_MACINFO_undef:
4665 lineno = read_uleb128 (curr, & bytes_read, end);
4668 curr += strnlen ((char *) string, end - string) + 1;
4669 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4673 case DW_MACINFO_vendor_ext:
4675 unsigned int constant;
4677 constant = read_uleb128 (curr, & bytes_read, end);
4680 curr += strnlen ((char *) string, end - string) + 1;
4681 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4691 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4692 filename and dirname corresponding to file name table entry with index
4693 FILEIDX. Return NULL on failure. */
4695 static unsigned char *
4696 get_line_filename_and_dirname (dwarf_vma line_offset,
4698 unsigned char **dir_name)
4700 struct dwarf_section *section = &debug_displays [line].section;
4701 unsigned char *hdrptr, *dirtable, *file_name;
4702 unsigned int offset_size, initial_length_size;
4703 unsigned int version, opcode_base, bytes_read;
4704 dwarf_vma length, diridx;
4705 const unsigned char * end;
4708 if (section->start == NULL
4709 || line_offset >= section->size
4713 hdrptr = section->start + line_offset;
4714 end = section->start + section->size;
4716 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
4717 if (length == 0xffffffff)
4719 /* This section is 64-bit DWARF 3. */
4720 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
4722 initial_length_size = 12;
4727 initial_length_size = 4;
4729 if (length + initial_length_size > section->size)
4732 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
4733 if (version != 2 && version != 3 && version != 4)
4735 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
4737 hdrptr++; /* Skip max_ops_per_insn. */
4738 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
4740 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
4741 if (opcode_base == 0)
4744 hdrptr += opcode_base - 1;
4749 /* Skip over dirname table. */
4750 while (*hdrptr != '\0')
4752 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4756 hdrptr++; /* Skip the NUL at the end of the table. */
4758 /* Now skip over preceding filename table entries. */
4759 for (; hdrptr < end && *hdrptr != '\0' && fileidx > 1; fileidx--)
4761 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4762 read_uleb128 (hdrptr, &bytes_read, end);
4763 hdrptr += bytes_read;
4764 read_uleb128 (hdrptr, &bytes_read, end);
4765 hdrptr += bytes_read;
4766 read_uleb128 (hdrptr, &bytes_read, end);
4767 hdrptr += bytes_read;
4769 if (hdrptr >= end || *hdrptr == '\0')
4773 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4776 diridx = read_uleb128 (hdrptr, &bytes_read, end);
4779 for (; dirtable < end && *dirtable != '\0' && diridx > 1; diridx--)
4780 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4781 if (dirtable >= end || *dirtable == '\0')
4783 *dir_name = dirtable;
4788 display_debug_macro (struct dwarf_section *section,
4791 unsigned char *start = section->start;
4792 unsigned char *end = start + section->size;
4793 unsigned char *curr = start;
4794 unsigned char *extended_op_buf[256];
4795 unsigned int bytes_read;
4797 load_debug_section (str, file);
4798 load_debug_section (line, file);
4800 printf (_("Contents of the %s section:\n\n"), section->name);
4804 unsigned int lineno, version, flags;
4805 unsigned int offset_size = 4;
4806 const unsigned char *string;
4807 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4808 unsigned char **extended_ops = NULL;
4810 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4811 if (version != 4 && version != 5)
4813 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
4818 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4821 printf (_(" Offset: 0x%lx\n"),
4822 (unsigned long) sec_offset);
4823 printf (_(" Version: %d\n"), version);
4824 printf (_(" Offset size: %d\n"), offset_size);
4827 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4828 printf (_(" Offset into .debug_line: 0x%lx\n"),
4829 (unsigned long) line_offset);
4833 unsigned int i, count, op;
4836 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4838 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4839 extended_ops = extended_op_buf;
4842 printf (_(" Extension opcode arguments:\n"));
4843 for (i = 0; i < count; i++)
4845 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4846 extended_ops[op] = curr;
4847 nargs = read_uleb128 (curr, &bytes_read, end);
4850 printf (_(" DW_MACRO_%02x has no arguments\n"), op);
4853 printf (_(" DW_MACRO_%02x arguments: "), op);
4854 for (n = 0; n < nargs; n++)
4858 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4859 printf ("%s%s", get_FORM_name (form),
4860 n == nargs - 1 ? "\n" : ", ");
4870 case DW_FORM_block1:
4871 case DW_FORM_block2:
4872 case DW_FORM_block4:
4874 case DW_FORM_string:
4876 case DW_FORM_sec_offset:
4879 error (_("Invalid extension opcode form %s\n"),
4880 get_FORM_name (form));
4896 error (_(".debug_macro section not zero terminated\n"));
4900 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4906 case DW_MACRO_start_file:
4908 unsigned int filenum;
4909 unsigned char *file_name = NULL, *dir_name = NULL;
4911 lineno = read_uleb128 (curr, &bytes_read, end);
4913 filenum = read_uleb128 (curr, &bytes_read, end);
4916 if ((flags & 2) == 0)
4917 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
4920 = get_line_filename_and_dirname (line_offset, filenum,
4922 if (file_name == NULL)
4923 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
4926 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4928 dir_name != NULL ? (const char *) dir_name : "",
4929 dir_name != NULL ? "/" : "", file_name);
4933 case DW_MACRO_end_file:
4934 printf (_(" DW_MACRO_end_file\n"));
4937 case DW_MACRO_define:
4938 lineno = read_uleb128 (curr, &bytes_read, end);
4941 curr += strnlen ((char *) string, end - string) + 1;
4942 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
4946 case DW_MACRO_undef:
4947 lineno = read_uleb128 (curr, &bytes_read, end);
4950 curr += strnlen ((char *) string, end - string) + 1;
4951 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
4955 case DW_MACRO_define_strp:
4956 lineno = read_uleb128 (curr, &bytes_read, end);
4958 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4959 string = fetch_indirect_string (offset);
4960 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
4964 case DW_MACRO_undef_strp:
4965 lineno = read_uleb128 (curr, &bytes_read, end);
4967 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4968 string = fetch_indirect_string (offset);
4969 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
4973 case DW_MACRO_import:
4974 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4975 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
4976 (unsigned long) offset);
4979 case DW_MACRO_define_sup:
4980 lineno = read_uleb128 (curr, &bytes_read, end);
4982 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4983 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
4984 lineno, (unsigned long) offset);
4987 case DW_MACRO_undef_sup:
4988 lineno = read_uleb128 (curr, &bytes_read, end);
4990 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4991 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
4992 lineno, (unsigned long) offset);
4995 case DW_MACRO_import_sup:
4996 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4997 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
4998 (unsigned long) offset);
5002 if (extended_ops == NULL || extended_ops[op] == NULL)
5004 error (_(" Unknown macro opcode %02x seen\n"), op);
5009 /* Skip over unhandled opcodes. */
5011 unsigned char *desc = extended_ops[op];
5012 nargs = read_uleb128 (desc, &bytes_read, end);
5016 printf (_(" DW_MACRO_%02x\n"), op);
5019 printf (_(" DW_MACRO_%02x -"), op);
5020 for (n = 0; n < nargs; n++)
5024 /* DW_FORM_implicit_const is not expected here. */
5025 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
5027 = read_and_display_attr_value (0, val, 0,
5028 curr, end, 0, 0, offset_size,
5029 version, NULL, 0, NULL,
5047 display_debug_abbrev (struct dwarf_section *section,
5048 void *file ATTRIBUTE_UNUSED)
5050 abbrev_entry *entry;
5051 unsigned char *start = section->start;
5052 unsigned char *end = start + section->size;
5054 printf (_("Contents of the %s section:\n\n"), section->name);
5058 unsigned char *last;
5063 start = process_abbrev_section (start, end);
5065 if (first_abbrev == NULL)
5068 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
5070 for (entry = first_abbrev; entry; entry = entry->next)
5074 printf (" %ld %s [%s]\n",
5076 get_TAG_name (entry->tag),
5077 entry->children ? _("has children") : _("no children"));
5079 for (attr = entry->first_attr; attr; attr = attr->next)
5081 printf (" %-18s %s",
5082 get_AT_name (attr->attribute),
5083 get_FORM_name (attr->form));
5084 if (attr->form == DW_FORM_implicit_const)
5085 printf (": %" BFD_VMA_FMT "d", attr->implicit_const);
5097 /* Return true when ADDR is the maximum address, when addresses are
5098 POINTER_SIZE bytes long. */
5101 is_max_address (dwarf_vma addr, unsigned int pointer_size)
5103 dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
5104 return ((addr & mask) == mask);
5107 /* Display a view pair list starting at *VSTART_PTR and ending at
5108 VLISTEND within SECTION. */
5111 display_view_pair_list (struct dwarf_section *section,
5112 unsigned char **vstart_ptr,
5113 unsigned int debug_info_entry,
5114 unsigned char *vlistend)
5116 unsigned char *vstart = *vstart_ptr;
5117 unsigned char *section_end = section->start + section->size;
5118 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
5120 if (vlistend < section_end)
5121 section_end = vlistend;
5125 while (vstart < section_end)
5127 dwarf_vma off = vstart - section->start;
5128 dwarf_vma vbegin, vend;
5130 unsigned int bytes_read;
5131 vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5132 vstart += bytes_read;
5133 if (vstart == section_end)
5135 vstart -= bytes_read;
5139 vend = read_uleb128 (vstart, &bytes_read, section_end);
5140 vstart += bytes_read;
5142 printf (" %8.8lx ", (unsigned long) off);
5144 print_dwarf_view (vbegin, pointer_size, 1);
5145 print_dwarf_view (vend, pointer_size, 1);
5146 printf (_("location view pair\n"));
5150 *vstart_ptr = vstart;
5153 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5156 display_loc_list (struct dwarf_section *section,
5157 unsigned char **start_ptr,
5158 unsigned int debug_info_entry,
5160 dwarf_vma base_address,
5161 unsigned char **vstart_ptr,
5164 unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
5165 unsigned char *section_end = section->start + section->size;
5166 unsigned long cu_offset;
5167 unsigned int pointer_size;
5168 unsigned int offset_size;
5173 unsigned short length;
5174 int need_frame_base;
5176 if (debug_info_entry >= num_debug_info_entries)
5178 warn (_("No debug information available for loc lists of entry: %u\n"),
5183 cu_offset = debug_information [debug_info_entry].cu_offset;
5184 pointer_size = debug_information [debug_info_entry].pointer_size;
5185 offset_size = debug_information [debug_info_entry].offset_size;
5186 dwarf_version = debug_information [debug_info_entry].dwarf_version;
5188 if (pointer_size < 2 || pointer_size > 8)
5190 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5191 pointer_size, debug_info_entry);
5197 dwarf_vma off = offset + (start - *start_ptr);
5198 dwarf_vma vbegin = vm1, vend = vm1;
5200 if (start + 2 * pointer_size > section_end)
5202 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5203 (unsigned long) offset);
5207 printf (" %8.8lx ", (unsigned long) off);
5209 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
5210 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
5212 if (begin == 0 && end == 0)
5214 /* PR 18374: In a object file we can have a location list that
5215 starts with a begin and end of 0 because there are relocations
5216 that need to be applied to the addresses. Actually applying
5217 the relocations now does not help as they will probably resolve
5218 to 0, since the object file has not been fully linked. Real
5219 end of list markers will not have any relocations against them. */
5220 if (! reloc_at (section, off)
5221 && ! reloc_at (section, off + pointer_size))
5223 printf (_("<End of list>\n"));
5228 /* Check base address specifiers. */
5229 if (is_max_address (begin, pointer_size)
5230 && !is_max_address (end, pointer_size))
5233 print_dwarf_vma (begin, pointer_size);
5234 print_dwarf_vma (end, pointer_size);
5235 printf (_("(base address)\n"));
5241 unsigned int bytes_read;
5243 off = offset + (vstart - *start_ptr);
5245 vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5246 vstart += bytes_read;
5247 print_dwarf_view (vbegin, pointer_size, 1);
5249 vend = read_uleb128 (vstart, &bytes_read, section_end);
5250 vstart += bytes_read;
5251 print_dwarf_view (vend, pointer_size, 1);
5253 printf (_("views at %8.8lx for:\n %*s "),
5254 (unsigned long) off, 8, "");
5257 if (start + 2 > section_end)
5259 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5260 (unsigned long) offset);
5264 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
5266 if (start + length > section_end)
5268 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5269 (unsigned long) offset);
5273 print_dwarf_vma (begin + base_address, pointer_size);
5274 print_dwarf_vma (end + base_address, pointer_size);
5277 need_frame_base = decode_location_expression (start,
5282 cu_offset, section);
5285 if (need_frame_base && !has_frame_base)
5286 printf (_(" [without DW_AT_frame_base]"));
5288 if (begin == end && vbegin == vend)
5289 fputs (_(" (start == end)"), stdout);
5290 else if (begin > end || (begin == end && vbegin > vend))
5291 fputs (_(" (start > end)"), stdout);
5299 *vstart_ptr = vstart;
5302 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5305 display_loclists_list (struct dwarf_section *section,
5306 unsigned char **start_ptr,
5307 unsigned int debug_info_entry,
5309 dwarf_vma base_address,
5310 unsigned char **vstart_ptr,
5313 unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
5314 unsigned char *section_end = section->start + section->size;
5315 unsigned long cu_offset;
5316 unsigned int pointer_size;
5317 unsigned int offset_size;
5319 unsigned int bytes_read;
5321 /* Initialize it due to a false compiler warning. */
5322 dwarf_vma begin = -1, vbegin = -1;
5323 dwarf_vma end = -1, vend = -1;
5325 int need_frame_base;
5327 if (debug_info_entry >= num_debug_info_entries)
5329 warn (_("No debug information available for "
5330 "loclists lists of entry: %u\n"),
5335 cu_offset = debug_information [debug_info_entry].cu_offset;
5336 pointer_size = debug_information [debug_info_entry].pointer_size;
5337 offset_size = debug_information [debug_info_entry].offset_size;
5338 dwarf_version = debug_information [debug_info_entry].dwarf_version;
5340 if (pointer_size < 2 || pointer_size > 8)
5342 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5343 pointer_size, debug_info_entry);
5349 dwarf_vma off = offset + (start - *start_ptr);
5350 enum dwarf_location_list_entry_type llet;
5352 if (start + 1 > section_end)
5354 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5355 (unsigned long) offset);
5359 printf (" %8.8lx ", (unsigned long) off);
5361 SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end);
5363 if (vstart && llet == DW_LLE_offset_pair)
5365 off = offset + (vstart - *start_ptr);
5367 vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5368 vstart += bytes_read;
5369 print_dwarf_view (vbegin, pointer_size, 1);
5371 vend = read_uleb128 (vstart, &bytes_read, section_end);
5372 vstart += bytes_read;
5373 print_dwarf_view (vend, pointer_size, 1);
5375 printf (_("views at %8.8lx for:\n %*s "),
5376 (unsigned long) off, 8, "");
5381 case DW_LLE_end_of_list:
5382 printf (_("<End of list>\n"));
5384 case DW_LLE_offset_pair:
5385 begin = read_uleb128 (start, &bytes_read, section_end);
5386 start += bytes_read;
5387 end = read_uleb128 (start, &bytes_read, section_end);
5388 start += bytes_read;
5390 case DW_LLE_base_address:
5391 SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size,
5393 print_dwarf_vma (base_address, pointer_size);
5394 printf (_("(base address)\n"));
5396 #ifdef DW_LLE_view_pair
5397 case DW_LLE_view_pair:
5399 printf (_("View pair entry in loclist with locviews attribute\n"));
5400 vbegin = read_uleb128 (start, &bytes_read, section_end);
5401 start += bytes_read;
5402 print_dwarf_view (vbegin, pointer_size, 1);
5404 vend = read_uleb128 (start, &bytes_read, section_end);
5405 start += bytes_read;
5406 print_dwarf_view (vend, pointer_size, 1);
5408 printf (_("views for:\n"));
5412 error (_("Invalid location list entry type %d\n"), llet);
5415 if (llet == DW_LLE_end_of_list)
5417 if (llet != DW_LLE_offset_pair)
5420 if (start + 2 > section_end)
5422 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5423 (unsigned long) offset);
5427 length = read_uleb128 (start, &bytes_read, section_end);
5428 start += bytes_read;
5430 print_dwarf_vma (begin + base_address, pointer_size);
5431 print_dwarf_vma (end + base_address, pointer_size);
5434 need_frame_base = decode_location_expression (start,
5439 cu_offset, section);
5442 if (need_frame_base && !has_frame_base)
5443 printf (_(" [without DW_AT_frame_base]"));
5445 if (begin == end && vbegin == vend)
5446 fputs (_(" (start == end)"), stdout);
5447 else if (begin > end || (begin == end && vbegin > vend))
5448 fputs (_(" (start > end)"), stdout);
5456 if (vbegin != vm1 || vend != vm1)
5457 printf (_("Trailing view pair not used in a range"));
5460 *vstart_ptr = vstart;
5463 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5464 right-adjusted in a field of length LEN, and followed by a space. */
5467 print_addr_index (unsigned int idx, unsigned int len)
5469 static char buf[15];
5470 snprintf (buf, sizeof (buf), "[%d]", idx);
5471 printf ("%*s ", len, buf);
5474 /* Display a location list from a .dwo section. It uses address indexes rather
5475 than embedded addresses. This code closely follows display_loc_list, but the
5476 two are sufficiently different that combining things is very ugly. */
5479 display_loc_list_dwo (struct dwarf_section *section,
5480 unsigned char **start_ptr,
5481 unsigned int debug_info_entry,
5483 unsigned char **vstart_ptr,
5486 unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
5487 unsigned char *section_end = section->start + section->size;
5488 unsigned long cu_offset;
5489 unsigned int pointer_size;
5490 unsigned int offset_size;
5493 unsigned short length;
5494 int need_frame_base;
5496 unsigned int bytes_read;
5498 if (debug_info_entry >= num_debug_info_entries)
5500 warn (_("No debug information for loc lists of entry: %u\n"),
5505 cu_offset = debug_information [debug_info_entry].cu_offset;
5506 pointer_size = debug_information [debug_info_entry].pointer_size;
5507 offset_size = debug_information [debug_info_entry].offset_size;
5508 dwarf_version = debug_information [debug_info_entry].dwarf_version;
5510 if (pointer_size < 2 || pointer_size > 8)
5512 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5513 pointer_size, debug_info_entry);
5519 printf (" %8.8lx ", (unsigned long) (offset + (start - *start_ptr)));
5521 if (start >= section_end)
5523 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5524 (unsigned long) offset);
5528 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
5541 dwarf_vma off = offset + (vstart - *start_ptr);
5543 view = read_uleb128 (vstart, &bytes_read, section_end);
5544 vstart += bytes_read;
5545 print_dwarf_view (view, 8, 1);
5547 view = read_uleb128 (vstart, &bytes_read, section_end);
5548 vstart += bytes_read;
5549 print_dwarf_view (view, 8, 1);
5551 printf (_("views at %8.8lx for:\n %*s "),
5552 (unsigned long) off, 8, "");
5560 case 0: /* A terminating entry. */
5562 *vstart_ptr = vstart;
5563 printf (_("<End of list>\n"));
5565 case 1: /* A base-address entry. */
5566 idx = read_uleb128 (start, &bytes_read, section_end);
5567 start += bytes_read;
5568 print_addr_index (idx, 8);
5569 printf ("%*s", 9 + (vstart ? 2 * 6 : 0), "");
5570 printf (_("(base address selection entry)\n"));
5572 case 2: /* A start/end entry. */
5573 idx = read_uleb128 (start, &bytes_read, section_end);
5574 start += bytes_read;
5575 print_addr_index (idx, 8);
5576 idx = read_uleb128 (start, &bytes_read, section_end);
5577 start += bytes_read;
5578 print_addr_index (idx, 8);
5580 case 3: /* A start/length entry. */
5581 idx = read_uleb128 (start, &bytes_read, section_end);
5582 start += bytes_read;
5583 print_addr_index (idx, 8);
5584 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5585 printf ("%08x ", idx);
5587 case 4: /* An offset pair entry. */
5588 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5589 printf ("%08x ", idx);
5590 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5591 printf ("%08x ", idx);
5594 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
5596 *vstart_ptr = vstart;
5600 if (start + 2 > section_end)
5602 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5603 (unsigned long) offset);
5607 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
5608 if (start + length > section_end)
5610 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5611 (unsigned long) offset);
5616 need_frame_base = decode_location_expression (start,
5621 cu_offset, section);
5624 if (need_frame_base && !has_frame_base)
5625 printf (_(" [without DW_AT_frame_base]"));
5633 *vstart_ptr = vstart;
5636 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5639 static dwarf_vma *loc_offsets, *loc_views;
5642 loc_offsets_compar (const void *ap, const void *bp)
5644 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
5645 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
5647 int ret = (a > b) - (b > a);
5651 a = loc_views[*(const unsigned int *) ap];
5652 b = loc_views[*(const unsigned int *) bp];
5654 ret = (a > b) - (b > a);
5660 display_debug_loc (struct dwarf_section *section, void *file)
5662 unsigned char *start = section->start, *vstart = NULL;
5663 unsigned long bytes;
5664 unsigned char *section_begin = start;
5665 unsigned int num_loc_list = 0;
5666 unsigned long last_offset = 0;
5667 unsigned long last_view = 0;
5668 unsigned int first = 0;
5671 int seen_first_offset = 0;
5672 int locs_sorted = 1;
5673 unsigned char *next = start, *vnext = vstart;
5674 unsigned int *array = NULL;
5675 const char *suffix = strrchr (section->name, '.');
5677 int is_loclists = strstr (section->name, "debug_loclists") != NULL;
5678 dwarf_vma expected_start = 0;
5680 if (suffix && strcmp (suffix, ".dwo") == 0)
5683 bytes = section->size;
5687 printf (_("\nThe %s section is empty.\n"), section->name);
5693 unsigned char *hdrptr = section_begin;
5694 dwarf_vma ll_length;
5695 unsigned short ll_version;
5696 unsigned char *end = section_begin + section->size;
5697 unsigned char address_size, segment_selector_size;
5698 uint32_t offset_entry_count;
5700 SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 4, end);
5701 if (ll_length == 0xffffffff)
5702 SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 8, end);
5704 SAFE_BYTE_GET_AND_INC (ll_version, hdrptr, 2, end);
5705 if (ll_version != 5)
5707 warn (_("The %s section contains corrupt or "
5708 "unsupported version number: %d.\n"),
5709 section->name, ll_version);
5713 SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
5715 SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
5716 if (segment_selector_size != 0)
5718 warn (_("The %s section contains "
5719 "unsupported segment selector size: %d.\n"),
5720 section->name, segment_selector_size);
5724 SAFE_BYTE_GET_AND_INC (offset_entry_count, hdrptr, 4, end);
5725 if (offset_entry_count != 0)
5727 warn (_("The %s section contains "
5728 "unsupported offset entry count: %d.\n"),
5729 section->name, offset_entry_count);
5733 expected_start = hdrptr - section_begin;
5736 if (load_debug_info (file) == 0)
5738 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5743 /* Check the order of location list in .debug_info section. If
5744 offsets of location lists are in the ascending order, we can
5745 use `debug_information' directly. */
5746 for (i = 0; i < num_debug_info_entries; i++)
5750 num = debug_information [i].num_loc_offsets;
5751 if (num > num_loc_list)
5754 /* Check if we can use `debug_information' directly. */
5755 if (locs_sorted && num != 0)
5757 if (!seen_first_offset)
5759 /* This is the first location list. */
5760 last_offset = debug_information [i].loc_offsets [0];
5761 last_view = debug_information [i].loc_views [0];
5763 seen_first_offset = 1;
5769 for (; j < num; j++)
5772 debug_information [i].loc_offsets [j]
5773 || (last_offset == debug_information [i].loc_offsets [j]
5774 && last_view > debug_information [i].loc_views [j]))
5779 last_offset = debug_information [i].loc_offsets [j];
5780 last_view = debug_information [i].loc_views [j];
5785 if (!seen_first_offset)
5786 error (_("No location lists in .debug_info section!\n"));
5788 if (debug_information [first].num_loc_offsets > 0
5789 && debug_information [first].loc_offsets [0] != expected_start
5790 && debug_information [first].loc_views [0] != expected_start)
5791 warn (_("Location lists in %s section start at 0x%s\n"),
5793 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
5796 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
5797 printf (_("Contents of the %s section:\n\n"), section->name);
5798 if (reloc_at (section, 0))
5799 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
5800 printf (_(" Offset Begin End Expression\n"));
5802 seen_first_offset = 0;
5803 for (i = first; i < num_debug_info_entries; i++)
5805 dwarf_vma offset, voffset;
5806 dwarf_vma base_address;
5812 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
5814 loc_offsets = debug_information [i].loc_offsets;
5815 loc_views = debug_information [i].loc_views;
5816 qsort (array, debug_information [i].num_loc_offsets,
5817 sizeof (*array), loc_offsets_compar);
5820 int adjacent_view_loclists = 1;
5821 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
5823 j = locs_sorted ? k : array[k];
5825 && (debug_information [i].loc_offsets [locs_sorted
5826 ? k - 1 : array [k - 1]]
5827 == debug_information [i].loc_offsets [j])
5828 && (debug_information [i].loc_views [locs_sorted
5829 ? k - 1 : array [k - 1]]
5830 == debug_information [i].loc_views [j]))
5832 has_frame_base = debug_information [i].have_frame_base [j];
5833 offset = debug_information [i].loc_offsets [j];
5834 next = section_begin + offset;
5835 voffset = debug_information [i].loc_views [j];
5837 vnext = section_begin + voffset;
5840 base_address = debug_information [i].base_address;
5842 if (vnext && vnext < next)
5845 display_view_pair_list (section, &vstart, i, next);
5850 if (!seen_first_offset || !adjacent_view_loclists)
5851 seen_first_offset = 1;
5855 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
5856 (unsigned long) (start - section_begin),
5857 (unsigned long) offset);
5858 else if (start > next)
5859 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
5860 (unsigned long) (start - section_begin),
5861 (unsigned long) offset);
5866 if (offset >= bytes)
5868 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
5869 (unsigned long) offset);
5873 if (vnext && voffset >= bytes)
5875 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
5876 (unsigned long) voffset);
5883 display_loc_list_dwo (section, &start, i, offset,
5884 &vstart, has_frame_base);
5886 display_loc_list (section, &start, i, offset, base_address,
5887 &vstart, has_frame_base);
5892 warn (_("DWO is not yet supported.\n"));
5894 display_loclists_list (section, &start, i, offset, base_address,
5895 &vstart, has_frame_base);
5898 /* FIXME: this arrangement is quite simplistic. Nothing
5899 requires locview lists to be adjacent to corresponding
5900 loclists, and a single loclist could be augmented by
5901 different locview lists, and vice-versa, unlikely as it
5902 is that it would make sense to do so. Hopefully we'll
5903 have view pair support built into loclists before we ever
5904 need to address all these possibilities. */
5905 if (adjacent_view_loclists && vnext
5906 && vnext != start && vstart != next)
5908 adjacent_view_loclists = 0;
5909 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
5912 if (vnext && vnext == start)
5913 display_view_pair_list (section, &start, i, vstart);
5917 if (start < section->start + section->size)
5918 warn (_("There are %ld unused bytes at the end of section %s\n"),
5919 (long) (section->start + section->size - start), section->name);
5926 display_debug_str (struct dwarf_section *section,
5927 void *file ATTRIBUTE_UNUSED)
5929 unsigned char *start = section->start;
5930 unsigned long bytes = section->size;
5931 dwarf_vma addr = section->address;
5935 printf (_("\nThe %s section is empty.\n"), section->name);
5939 printf (_("Contents of the %s section:\n\n"), section->name);
5947 lbytes = (bytes > 16 ? 16 : bytes);
5949 printf (" 0x%8.8lx ", (unsigned long) addr);
5951 for (j = 0; j < 16; j++)
5954 printf ("%2.2x", start[j]);
5962 for (j = 0; j < lbytes; j++)
5965 if (k >= ' ' && k < 0x80)
5984 display_debug_info (struct dwarf_section *section, void *file)
5986 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
5990 display_debug_types (struct dwarf_section *section, void *file)
5992 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
5996 display_trace_info (struct dwarf_section *section, void *file)
5998 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
6002 display_debug_aranges (struct dwarf_section *section,
6003 void *file ATTRIBUTE_UNUSED)
6005 unsigned char *start = section->start;
6006 unsigned char *end = start + section->size;
6008 printf (_("Contents of the %s section:\n\n"), section->name);
6010 /* It does not matter if this load fails,
6011 we test for that later on. */
6012 load_debug_info (file);
6016 unsigned char *hdrptr;
6017 DWARF2_Internal_ARange arange;
6018 unsigned char *addr_ranges;
6021 unsigned char address_size;
6023 unsigned int offset_size;
6024 unsigned int initial_length_size;
6028 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
6029 if (arange.ar_length == 0xffffffff)
6031 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
6033 initial_length_size = 12;
6038 initial_length_size = 4;
6041 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
6042 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
6044 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
6045 && num_debug_info_entries > 0
6046 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
6047 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6048 (unsigned long) arange.ar_info_offset, section->name);
6050 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
6051 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
6053 if (arange.ar_version != 2 && arange.ar_version != 3)
6055 /* PR 19872: A version number of 0 probably means that there is
6056 padding at the end of the .debug_aranges section. Gold puts
6057 it there when performing an incremental link, for example.
6058 So do not generate a warning in this case. */
6059 if (arange.ar_version)
6060 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6064 printf (_(" Length: %ld\n"),
6065 (long) arange.ar_length);
6066 printf (_(" Version: %d\n"), arange.ar_version);
6067 printf (_(" Offset into .debug_info: 0x%lx\n"),
6068 (unsigned long) arange.ar_info_offset);
6069 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6070 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6072 address_size = arange.ar_pointer_size + arange.ar_segment_size;
6074 /* PR 17512: file: 001-108546-0.001:0.1. */
6075 if (address_size == 0 || address_size > 8)
6077 error (_("Invalid address size in %s section!\n"),
6082 /* The DWARF spec does not require that the address size be a power
6083 of two, but we do. This will have to change if we ever encounter
6084 an uneven architecture. */
6085 if ((address_size & (address_size - 1)) != 0)
6087 warn (_("Pointer size + Segment size is not a power of two.\n"));
6091 if (address_size > 4)
6092 printf (_("\n Address Length\n"));
6094 printf (_("\n Address Length\n"));
6096 addr_ranges = hdrptr;
6098 /* Must pad to an alignment boundary that is twice the address size. */
6099 excess = (hdrptr - start) % (2 * address_size);
6101 addr_ranges += (2 * address_size) - excess;
6103 hdrptr = start + arange.ar_length + initial_length_size;
6104 if (hdrptr < start || hdrptr > end)
6106 error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
6111 while (addr_ranges + 2 * address_size <= start)
6113 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
6114 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
6117 print_dwarf_vma (address, address_size);
6118 print_dwarf_vma (length, address_size);
6128 /* Comparison function for qsort. */
6130 comp_addr_base (const void * v0, const void * v1)
6132 debug_info * info0 = (debug_info *) v0;
6133 debug_info * info1 = (debug_info *) v1;
6134 return info0->addr_base - info1->addr_base;
6137 /* Display the debug_addr section. */
6139 display_debug_addr (struct dwarf_section *section,
6142 debug_info **debug_addr_info;
6143 unsigned char *entry;
6148 if (section->size == 0)
6150 printf (_("\nThe %s section is empty.\n"), section->name);
6154 if (load_debug_info (file) == 0)
6156 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6161 printf (_("Contents of the %s section:\n\n"), section->name);
6163 /* PR 17531: file: cf38d01b.
6164 We use xcalloc because a corrupt file may not have initialised all of the
6165 fields in the debug_info structure, which means that the sort below might
6166 try to move uninitialised data. */
6167 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
6168 sizeof (debug_info *));
6171 for (i = 0; i < num_debug_info_entries; i++)
6172 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
6174 /* PR 17531: file: cf38d01b. */
6175 if (debug_information[i].addr_base >= section->size)
6176 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6177 (unsigned long) debug_information[i].addr_base, i);
6179 debug_addr_info [count++] = debug_information + i;
6182 /* Add a sentinel to make iteration convenient. */
6183 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
6184 debug_addr_info [count]->addr_base = section->size;
6185 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
6187 for (i = 0; i < count; i++)
6190 unsigned int address_size = debug_addr_info [i]->pointer_size;
6192 printf (_(" For compilation unit at offset 0x%s:\n"),
6193 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
6195 printf (_("\tIndex\tAddress\n"));
6196 entry = section->start + debug_addr_info [i]->addr_base;
6197 end = section->start + debug_addr_info [i + 1]->addr_base;
6201 dwarf_vma base = byte_get (entry, address_size);
6202 printf (_("\t%d:\t"), idx);
6203 print_dwarf_vma (base, address_size);
6205 entry += address_size;
6211 free (debug_addr_info);
6215 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6217 display_debug_str_offsets (struct dwarf_section *section,
6218 void *file ATTRIBUTE_UNUSED)
6220 if (section->size == 0)
6222 printf (_("\nThe %s section is empty.\n"), section->name);
6225 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6226 what the offset size is for this section. */
6230 /* Each debug_information[x].range_lists[y] gets this representation for
6231 sorting purposes. */
6235 /* The debug_information[x].range_lists[y] value. */
6236 dwarf_vma ranges_offset;
6238 /* Original debug_information to find parameters of the data. */
6239 debug_info *debug_info_p;
6242 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6245 range_entry_compar (const void *ap, const void *bp)
6247 const struct range_entry *a_re = (const struct range_entry *) ap;
6248 const struct range_entry *b_re = (const struct range_entry *) bp;
6249 const dwarf_vma a = a_re->ranges_offset;
6250 const dwarf_vma b = b_re->ranges_offset;
6252 return (a > b) - (b > a);
6256 display_debug_ranges_list (unsigned char *start, unsigned char *finish,
6257 unsigned int pointer_size, unsigned long offset,
6258 unsigned long base_address)
6260 while (start < finish)
6265 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6266 if (start >= finish)
6268 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
6270 printf (" %8.8lx ", offset);
6272 if (begin == 0 && end == 0)
6274 printf (_("<End of list>\n"));
6278 /* Check base address specifiers. */
6279 if (is_max_address (begin, pointer_size)
6280 && !is_max_address (end, pointer_size))
6283 print_dwarf_vma (begin, pointer_size);
6284 print_dwarf_vma (end, pointer_size);
6285 printf ("(base address)\n");
6289 print_dwarf_vma (begin + base_address, pointer_size);
6290 print_dwarf_vma (end + base_address, pointer_size);
6293 fputs (_("(start == end)"), stdout);
6294 else if (begin > end)
6295 fputs (_("(start > end)"), stdout);
6302 display_debug_rnglists_list (unsigned char *start, unsigned char *finish,
6303 unsigned int pointer_size, unsigned long offset,
6304 unsigned long base_address)
6306 unsigned char *next = start;
6310 unsigned long off = offset + (start - next);
6311 enum dwarf_range_list_entry rlet;
6312 /* Initialize it due to a false compiler warning. */
6313 dwarf_vma begin = -1, length, end = -1;
6314 unsigned int bytes_read;
6316 if (start + 1 > finish)
6318 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6323 printf (" %8.8lx ", off);
6325 SAFE_BYTE_GET_AND_INC (rlet, start, 1, finish);
6329 case DW_RLE_end_of_list:
6330 printf (_("<End of list>\n"));
6332 case DW_RLE_base_address:
6333 SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, finish);
6334 print_dwarf_vma (base_address, pointer_size);
6335 printf (_("(base address)\n"));
6337 case DW_RLE_start_length:
6338 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6339 length = read_uleb128 (start, &bytes_read, finish);
6340 start += bytes_read;
6341 end = begin + length;
6343 case DW_RLE_offset_pair:
6344 begin = read_uleb128 (start, &bytes_read, finish);
6345 start += bytes_read;
6346 end = read_uleb128 (start, &bytes_read, finish);
6347 start += bytes_read;
6349 case DW_RLE_start_end:
6350 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6351 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, finish);
6354 error (_("Invalid range list entry type %d\n"), rlet);
6355 rlet = DW_RLE_end_of_list;
6358 if (rlet == DW_RLE_end_of_list)
6360 if (rlet == DW_RLE_base_address)
6363 print_dwarf_vma (begin + base_address, pointer_size);
6364 print_dwarf_vma (end + base_address, pointer_size);
6367 fputs (_("(start == end)"), stdout);
6368 else if (begin > end)
6369 fputs (_("(start > end)"), stdout);
6376 display_debug_ranges (struct dwarf_section *section,
6377 void *file ATTRIBUTE_UNUSED)
6379 unsigned char *start = section->start;
6380 unsigned char *last_start = start;
6381 unsigned long bytes = section->size;
6382 unsigned char *section_begin = start;
6383 unsigned char *finish = start + bytes;
6384 unsigned int num_range_list, i;
6385 struct range_entry *range_entries, *range_entry_fill;
6386 int is_rnglists = strstr (section->name, "debug_rnglists") != NULL;
6387 /* Initialize it due to a false compiler warning. */
6388 unsigned char address_size = 0;
6392 printf (_("\nThe %s section is empty.\n"), section->name);
6398 dwarf_vma initial_length;
6399 unsigned int initial_length_size;
6400 unsigned char segment_selector_size;
6401 unsigned int offset_size, offset_entry_count;
6402 unsigned short version;
6404 /* Get and check the length of the block. */
6405 SAFE_BYTE_GET_AND_INC (initial_length, start, 4, finish);
6407 if (initial_length == 0xffffffff)
6409 /* This section is 64-bit DWARF 3. */
6410 SAFE_BYTE_GET_AND_INC (initial_length, start, 8, finish);
6412 initial_length_size = 12;
6417 initial_length_size = 4;
6420 if (initial_length + initial_length_size > section->size)
6422 /* If the length field has a relocation against it, then we should
6423 not complain if it is inaccurate (and probably negative).
6424 It is copied from .debug_line handling code. */
6425 if (reloc_at (section, (start - section->start) - offset_size))
6427 initial_length = (finish - start) - initial_length_size;
6431 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6432 (long) initial_length);
6437 /* Get and check the version number. */
6438 SAFE_BYTE_GET_AND_INC (version, start, 2, finish);
6442 warn (_("Only DWARF version 5 debug_rnglists info "
6443 "is currently supported.\n"));
6447 SAFE_BYTE_GET_AND_INC (address_size, start, 1, finish);
6449 SAFE_BYTE_GET_AND_INC (segment_selector_size, start, 1, finish);
6450 if (segment_selector_size != 0)
6452 warn (_("The %s section contains "
6453 "unsupported segment selector size: %d.\n"),
6454 section->name, segment_selector_size);
6458 SAFE_BYTE_GET_AND_INC (offset_entry_count, start, 4, finish);
6459 if (offset_entry_count != 0)
6461 warn (_("The %s section contains "
6462 "unsupported offset entry count: %u.\n"),
6463 section->name, offset_entry_count);
6468 if (load_debug_info (file) == 0)
6470 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6476 for (i = 0; i < num_debug_info_entries; i++)
6477 num_range_list += debug_information [i].num_range_lists;
6479 if (num_range_list == 0)
6481 /* This can happen when the file was compiled with -gsplit-debug
6482 which removes references to range lists from the primary .o file. */
6483 printf (_("No range lists in .debug_info section.\n"));
6487 range_entries = (struct range_entry *)
6488 xmalloc (sizeof (*range_entries) * num_range_list);
6489 range_entry_fill = range_entries;
6491 for (i = 0; i < num_debug_info_entries; i++)
6493 debug_info *debug_info_p = &debug_information[i];
6496 for (j = 0; j < debug_info_p->num_range_lists; j++)
6498 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
6499 range_entry_fill->debug_info_p = debug_info_p;
6504 qsort (range_entries, num_range_list, sizeof (*range_entries),
6505 range_entry_compar);
6507 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
6508 warn (_("Range lists in %s section start at 0x%lx\n"),
6509 section->name, (unsigned long) range_entries[0].ranges_offset);
6511 printf (_("Contents of the %s section:\n\n"), section->name);
6512 printf (_(" Offset Begin End\n"));
6514 for (i = 0; i < num_range_list; i++)
6516 struct range_entry *range_entry = &range_entries[i];
6517 debug_info *debug_info_p = range_entry->debug_info_p;
6518 unsigned int pointer_size;
6520 unsigned char *next;
6521 dwarf_vma base_address;
6523 pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size);
6524 offset = range_entry->ranges_offset;
6525 next = section_begin + offset;
6526 base_address = debug_info_p->base_address;
6528 /* PR 17512: file: 001-101485-0.001:0.1. */
6529 if (pointer_size < 2 || pointer_size > 8)
6531 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6532 pointer_size, (unsigned long) offset);
6536 if (dwarf_check != 0 && i > 0)
6539 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6540 (unsigned long) (start - section_begin),
6541 (unsigned long) (next - section_begin), section->name);
6542 else if (start > next)
6544 if (next == last_start)
6546 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6547 (unsigned long) (start - section_begin),
6548 (unsigned long) (next - section_begin), section->name);
6554 (is_rnglists ? display_debug_rnglists_list : display_debug_ranges_list)
6555 (start, finish, pointer_size, offset, base_address);
6559 free (range_entries);
6564 typedef struct Frame_Chunk
6566 struct Frame_Chunk *next;
6567 unsigned char *chunk_start;
6569 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6570 short int *col_type;
6573 unsigned int code_factor;
6578 dwarf_vma cfa_offset;
6580 unsigned char fde_encoding;
6581 unsigned char cfa_exp;
6582 unsigned char ptr_size;
6583 unsigned char segment_size;
6587 static const char *const *dwarf_regnames;
6588 static unsigned int dwarf_regnames_count;
6590 /* A marker for a col_type that means this column was never referenced
6591 in the frame info. */
6592 #define DW_CFA_unreferenced (-1)
6594 /* Return 0 if no more space is needed, 1 if more space is needed,
6595 -1 for invalid reg. */
6598 frame_need_space (Frame_Chunk *fc, unsigned int reg)
6600 unsigned int prev = fc->ncols;
6602 if (reg < (unsigned int) fc->ncols)
6605 if (dwarf_regnames_count
6606 && reg > dwarf_regnames_count)
6609 fc->ncols = reg + 1;
6610 /* PR 17512: file: 10450-2643-0.004.
6611 If reg == -1 then this can happen... */
6615 /* PR 17512: file: 2844a11d. */
6616 if (fc->ncols > 1024)
6618 error (_("Unfeasibly large register number: %u\n"), reg);
6620 /* FIXME: 1024 is an arbitrary limit. Increase it if
6621 we ever encounter a valid binary that exceeds it. */
6625 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
6626 sizeof (short int));
6627 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
6628 /* PR 17512: file:002-10025-0.005. */
6629 if (fc->col_type == NULL || fc->col_offset == NULL)
6631 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6637 while (prev < fc->ncols)
6639 fc->col_type[prev] = DW_CFA_unreferenced;
6640 fc->col_offset[prev] = 0;
6646 static const char *const dwarf_regnames_i386[] =
6648 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6649 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6650 "eip", "eflags", NULL, /* 8 - 10 */
6651 "st0", "st1", "st2", "st3", /* 11 - 14 */
6652 "st4", "st5", "st6", "st7", /* 15 - 18 */
6653 NULL, NULL, /* 19 - 20 */
6654 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
6655 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
6656 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
6657 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
6658 "fcw", "fsw", "mxcsr", /* 37 - 39 */
6659 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
6660 "tr", "ldtr", /* 48 - 49 */
6661 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
6662 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
6663 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
6664 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
6665 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
6666 NULL, NULL, NULL, /* 90 - 92 */
6667 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
6670 static const char *const dwarf_regnames_iamcu[] =
6672 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6673 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6674 "eip", "eflags", NULL, /* 8 - 10 */
6675 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18 */
6676 NULL, NULL, /* 19 - 20 */
6677 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28 */
6678 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36 */
6679 NULL, NULL, NULL, /* 37 - 39 */
6680 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
6681 "tr", "ldtr", /* 48 - 49 */
6682 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
6683 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
6684 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
6685 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
6686 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
6687 NULL, NULL, NULL, /* 90 - 92 */
6688 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL /* 93 - 100 */
6692 init_dwarf_regnames_i386 (void)
6694 dwarf_regnames = dwarf_regnames_i386;
6695 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
6699 init_dwarf_regnames_iamcu (void)
6701 dwarf_regnames = dwarf_regnames_iamcu;
6702 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
6705 static const char *const dwarf_regnames_x86_64[] =
6707 "rax", "rdx", "rcx", "rbx",
6708 "rsi", "rdi", "rbp", "rsp",
6709 "r8", "r9", "r10", "r11",
6710 "r12", "r13", "r14", "r15",
6712 "xmm0", "xmm1", "xmm2", "xmm3",
6713 "xmm4", "xmm5", "xmm6", "xmm7",
6714 "xmm8", "xmm9", "xmm10", "xmm11",
6715 "xmm12", "xmm13", "xmm14", "xmm15",
6716 "st0", "st1", "st2", "st3",
6717 "st4", "st5", "st6", "st7",
6718 "mm0", "mm1", "mm2", "mm3",
6719 "mm4", "mm5", "mm6", "mm7",
6721 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
6722 "fs.base", "gs.base", NULL, NULL,
6724 "mxcsr", "fcw", "fsw",
6725 "xmm16", "xmm17", "xmm18", "xmm19",
6726 "xmm20", "xmm21", "xmm22", "xmm23",
6727 "xmm24", "xmm25", "xmm26", "xmm27",
6728 "xmm28", "xmm29", "xmm30", "xmm31",
6729 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
6730 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
6731 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
6732 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
6733 NULL, NULL, NULL, /* 115 - 117 */
6734 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
6738 init_dwarf_regnames_x86_64 (void)
6740 dwarf_regnames = dwarf_regnames_x86_64;
6741 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
6744 static const char *const dwarf_regnames_aarch64[] =
6746 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
6747 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
6748 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
6749 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
6750 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
6751 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6752 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6753 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6754 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
6755 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
6756 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
6757 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6761 init_dwarf_regnames_aarch64 (void)
6763 dwarf_regnames = dwarf_regnames_aarch64;
6764 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
6767 static const char *const dwarf_regnames_s390[] =
6769 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
6770 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6771 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6772 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
6773 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
6774 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6775 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
6776 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
6777 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
6780 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
6781 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
6785 init_dwarf_regnames_s390 (void)
6787 dwarf_regnames = dwarf_regnames_s390;
6788 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
6792 init_dwarf_regnames (unsigned int e_machine)
6797 init_dwarf_regnames_i386 ();
6801 init_dwarf_regnames_iamcu ();
6807 init_dwarf_regnames_x86_64 ();
6811 init_dwarf_regnames_aarch64 ();
6815 init_dwarf_regnames_s390 ();
6824 regname (unsigned int regno, int row)
6826 static char reg[64];
6829 && regno < dwarf_regnames_count
6830 && dwarf_regnames [regno] != NULL)
6833 return dwarf_regnames [regno];
6834 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
6835 dwarf_regnames [regno]);
6838 snprintf (reg, sizeof (reg), "r%d", regno);
6843 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
6848 if (*max_regs != fc->ncols)
6849 *max_regs = fc->ncols;
6851 if (*need_col_headers)
6853 static const char *sloc = " LOC";
6855 *need_col_headers = 0;
6857 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
6859 for (r = 0; r < *max_regs; r++)
6860 if (fc->col_type[r] != DW_CFA_unreferenced)
6865 printf ("%-5s ", regname (r, 1));
6871 print_dwarf_vma (fc->pc_begin, eh_addr_size);
6873 strcpy (tmp, "exp");
6875 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
6876 printf ("%-8s ", tmp);
6878 for (r = 0; r < fc->ncols; r++)
6880 if (fc->col_type[r] != DW_CFA_unreferenced)
6882 switch (fc->col_type[r])
6884 case DW_CFA_undefined:
6887 case DW_CFA_same_value:
6891 sprintf (tmp, "c%+d", fc->col_offset[r]);
6893 case DW_CFA_val_offset:
6894 sprintf (tmp, "v%+d", fc->col_offset[r]);
6896 case DW_CFA_register:
6897 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
6899 case DW_CFA_expression:
6900 strcpy (tmp, "exp");
6902 case DW_CFA_val_expression:
6903 strcpy (tmp, "vexp");
6906 strcpy (tmp, "n/a");
6909 printf ("%-5s ", tmp);
6915 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
6917 static unsigned char *
6918 read_cie (unsigned char *start, unsigned char *end,
6919 Frame_Chunk **p_cie, int *p_version,
6920 unsigned long *p_aug_len, unsigned char **p_aug)
6924 unsigned int length_return;
6925 unsigned char *augmentation_data = NULL;
6926 unsigned long augmentation_data_len = 0;
6929 /* PR 17512: file: 001-228113-0.004. */
6933 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6934 memset (fc, 0, sizeof (Frame_Chunk));
6936 fc->col_type = (short int *) xmalloc (sizeof (short int));
6937 fc->col_offset = (int *) xmalloc (sizeof (int));
6941 fc->augmentation = (char *) start;
6942 /* PR 17512: file: 001-228113-0.004.
6943 Skip past augmentation name, but avoid running off the end of the data. */
6945 if (* start ++ == '\0')
6949 warn (_("No terminator for augmentation name\n"));
6953 if (strcmp (fc->augmentation, "eh") == 0)
6954 start += eh_addr_size;
6958 GET (fc->ptr_size, 1);
6959 if (fc->ptr_size < 1 || fc->ptr_size > 8)
6961 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
6965 GET (fc->segment_size, 1);
6966 /* PR 17512: file: e99d2804. */
6967 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
6969 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
6973 eh_addr_size = fc->ptr_size;
6977 fc->ptr_size = eh_addr_size;
6978 fc->segment_size = 0;
6980 READ_ULEB (fc->code_factor);
6981 READ_SLEB (fc->data_factor);
6991 if (fc->augmentation[0] == 'z')
6993 READ_ULEB (augmentation_data_len);
6994 augmentation_data = start;
6995 start += augmentation_data_len;
6996 /* PR 17512: file: 11042-2589-0.004. */
6999 warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"),
7000 augmentation_data_len, (long)((end - start) + augmentation_data_len));
7005 if (augmentation_data_len)
7009 unsigned char *qend;
7011 p = (unsigned char *) fc->augmentation + 1;
7012 q = augmentation_data;
7013 qend = q + augmentation_data_len;
7015 /* PR 17531: file: 015adfaa. */
7018 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
7019 augmentation_data_len = 0;
7022 while (p < end && q < augmentation_data + augmentation_data_len)
7027 q += 1 + size_of_encoded_value (*q);
7029 fc->fde_encoding = *q++;
7036 /* Note - it is OK if this loop terminates with q < qend.
7037 Padding may have been inserted to align the end of the CIE. */
7042 *p_version = version;
7045 *p_aug_len = augmentation_data_len;
7046 *p_aug = augmentation_data;
7052 display_debug_frames (struct dwarf_section *section,
7053 void *file ATTRIBUTE_UNUSED)
7055 unsigned char *start = section->start;
7056 unsigned char *end = start + section->size;
7057 unsigned char *section_start = start;
7058 Frame_Chunk *chunks = 0, *forward_refs = 0;
7059 Frame_Chunk *remembered_state = 0;
7061 int is_eh = strcmp (section->name, ".eh_frame") == 0;
7062 unsigned int length_return;
7063 unsigned int max_regs = 0;
7064 const char *bad_reg = _("bad register: ");
7065 unsigned int saved_eh_addr_size = eh_addr_size;
7067 printf (_("Contents of the %s section:\n"), section->name);
7071 unsigned char *saved_start;
7072 unsigned char *block_end;
7077 int need_col_headers = 1;
7078 unsigned char *augmentation_data = NULL;
7079 unsigned long augmentation_data_len = 0;
7080 unsigned int encoded_ptr_size = saved_eh_addr_size;
7081 unsigned int offset_size;
7082 unsigned int initial_length_size;
7083 bfd_boolean all_nops;
7085 saved_start = start;
7087 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
7091 printf ("\n%08lx ZERO terminator\n\n",
7092 (unsigned long)(saved_start - section_start));
7093 /* Skip any zero terminators that directly follow.
7094 A corrupt section size could have loaded a whole
7095 slew of zero filled memory bytes. eg
7096 PR 17512: file: 070-19381-0.004. */
7097 while (start < end && * start == 0)
7102 if (length == 0xffffffff)
7104 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
7106 initial_length_size = 12;
7111 initial_length_size = 4;
7114 block_end = saved_start + length + initial_length_size;
7115 if (block_end > end || block_end < start)
7117 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7118 dwarf_vmatoa_1 (NULL, length, offset_size),
7119 (unsigned long) (saved_start - section_start));
7123 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
7125 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
7126 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
7131 start = read_cie (start, end, &cie, &version,
7132 &augmentation_data_len, &augmentation_data);
7133 /* PR 17512: file: 027-135133-0.005. */
7140 fc->chunk_start = saved_start;
7141 mreg = max_regs > 0 ? max_regs - 1 : 0;
7144 if (frame_need_space (fc, mreg) < 0)
7146 if (fc->fde_encoding)
7147 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7149 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
7150 print_dwarf_vma (length, fc->ptr_size);
7151 print_dwarf_vma (cie_id, offset_size);
7153 if (do_debug_frames_interp)
7155 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
7156 fc->code_factor, fc->data_factor, fc->ra);
7161 printf (" Version: %d\n", version);
7162 printf (" Augmentation: \"%s\"\n", fc->augmentation);
7165 printf (" Pointer Size: %u\n", fc->ptr_size);
7166 printf (" Segment Size: %u\n", fc->segment_size);
7168 printf (" Code alignment factor: %u\n", fc->code_factor);
7169 printf (" Data alignment factor: %d\n", fc->data_factor);
7170 printf (" Return address column: %d\n", fc->ra);
7172 if (augmentation_data_len)
7176 printf (" Augmentation data: ");
7177 for (i = 0; i < augmentation_data_len; ++i)
7178 /* FIXME: If do_wide is FALSE, then we should
7179 add carriage returns at 80 columns... */
7180 printf (" %02x", augmentation_data[i]);
7188 unsigned char *look_for;
7189 static Frame_Chunk fde_fc;
7190 unsigned long segment_selector;
7194 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
7195 look_for = start - 4 - ((cie_id ^ sign) - sign);
7198 look_for = section_start + cie_id;
7200 if (look_for <= saved_start)
7202 for (cie = chunks; cie ; cie = cie->next)
7203 if (cie->chunk_start == look_for)
7208 for (cie = forward_refs; cie ; cie = cie->next)
7209 if (cie->chunk_start == look_for)
7213 unsigned int off_size;
7214 unsigned char *cie_scan;
7216 cie_scan = look_for;
7218 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
7219 if (length == 0xffffffff)
7221 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
7228 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
7231 : ((off_size == 4 && c_id == DW_CIE_ID)
7232 || (off_size == 8 && c_id == DW64_CIE_ID)))
7237 read_cie (cie_scan, end, &cie, &version,
7238 &augmentation_data_len, &augmentation_data);
7239 /* PR 17512: file: 3450-2098-0.004. */
7242 warn (_("Failed to read CIE information\n"));
7245 cie->next = forward_refs;
7247 cie->chunk_start = look_for;
7248 mreg = max_regs > 0 ? max_regs - 1 : 0;
7251 if (frame_need_space (cie, mreg) < 0)
7253 warn (_("Invalid max register\n"));
7256 if (cie->fde_encoding)
7258 = size_of_encoded_value (cie->fde_encoding);
7265 memset (fc, 0, sizeof (Frame_Chunk));
7269 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7270 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
7271 (unsigned long) (saved_start - section_start));
7273 fc->col_type = (short int *) xmalloc (sizeof (short int));
7274 fc->col_offset = (int *) xmalloc (sizeof (int));
7275 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
7277 warn (_("Invalid max register\n"));
7281 fc->augmentation = "";
7282 fc->fde_encoding = 0;
7283 fc->ptr_size = eh_addr_size;
7284 fc->segment_size = 0;
7288 fc->ncols = cie->ncols;
7289 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
7290 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
7291 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7292 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7293 fc->augmentation = cie->augmentation;
7294 fc->ptr_size = cie->ptr_size;
7295 eh_addr_size = cie->ptr_size;
7296 fc->segment_size = cie->segment_size;
7297 fc->code_factor = cie->code_factor;
7298 fc->data_factor = cie->data_factor;
7299 fc->cfa_reg = cie->cfa_reg;
7300 fc->cfa_offset = cie->cfa_offset;
7302 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
7304 warn (_("Invalid max register\n"));
7307 fc->fde_encoding = cie->fde_encoding;
7310 if (fc->fde_encoding)
7311 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7313 segment_selector = 0;
7314 if (fc->segment_size)
7316 if (fc->segment_size > sizeof (segment_selector))
7318 /* PR 17512: file: 9e196b3e. */
7319 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
7320 fc->segment_size = 4;
7322 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
7325 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
7327 /* FIXME: It appears that sometimes the final pc_range value is
7328 encoded in less than encoded_ptr_size bytes. See the x86_64
7329 run of the "objcopy on compressed debug sections" test for an
7331 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
7333 if (cie->augmentation[0] == 'z')
7335 READ_ULEB (augmentation_data_len);
7336 augmentation_data = start;
7337 start += augmentation_data_len;
7338 /* PR 17512: file: 722-8446-0.004. */
7339 if (start >= end || ((signed long) augmentation_data_len) < 0)
7341 warn (_("Corrupt augmentation data length: %lx\n"),
7342 augmentation_data_len);
7344 augmentation_data = NULL;
7345 augmentation_data_len = 0;
7349 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7350 (unsigned long)(saved_start - section_start),
7351 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
7352 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
7353 (unsigned long)(cie->chunk_start - section_start));
7355 if (fc->segment_size)
7356 printf ("%04lx:", segment_selector);
7359 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
7360 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
7362 if (! do_debug_frames_interp && augmentation_data_len)
7366 printf (" Augmentation data: ");
7367 for (i = 0; i < augmentation_data_len; ++i)
7368 printf (" %02x", augmentation_data[i]);
7374 /* At this point, fc is the current chunk, cie (if any) is set, and
7375 we're about to interpret instructions for the chunk. */
7376 /* ??? At present we need to do this always, since this sizes the
7377 fc->col_type and fc->col_offset arrays, which we write into always.
7378 We should probably split the interpreted and non-interpreted bits
7379 into two different routines, since there's so much that doesn't
7380 really overlap between them. */
7381 if (1 || do_debug_frames_interp)
7383 /* Start by making a pass over the chunk, allocating storage
7384 and taking note of what registers are used. */
7385 unsigned char *tmp = start;
7387 while (start < block_end)
7389 unsigned int reg, op, opa;
7391 unsigned char * new_start;
7398 /* Warning: if you add any more cases to this switch, be
7399 sure to add them to the corresponding switch below. */
7402 case DW_CFA_advance_loc:
7406 if (frame_need_space (fc, opa) >= 0)
7407 fc->col_type[opa] = DW_CFA_undefined;
7409 case DW_CFA_restore:
7410 if (frame_need_space (fc, opa) >= 0)
7411 fc->col_type[opa] = DW_CFA_undefined;
7413 case DW_CFA_set_loc:
7414 start += encoded_ptr_size;
7416 case DW_CFA_advance_loc1:
7419 case DW_CFA_advance_loc2:
7422 case DW_CFA_advance_loc4:
7425 case DW_CFA_offset_extended:
7426 case DW_CFA_val_offset:
7429 if (frame_need_space (fc, reg) >= 0)
7430 fc->col_type[reg] = DW_CFA_undefined;
7432 case DW_CFA_restore_extended:
7434 if (frame_need_space (fc, reg) >= 0)
7435 fc->col_type[reg] = DW_CFA_undefined;
7437 case DW_CFA_undefined:
7439 if (frame_need_space (fc, reg) >= 0)
7440 fc->col_type[reg] = DW_CFA_undefined;
7442 case DW_CFA_same_value:
7444 if (frame_need_space (fc, reg) >= 0)
7445 fc->col_type[reg] = DW_CFA_undefined;
7447 case DW_CFA_register:
7450 if (frame_need_space (fc, reg) >= 0)
7451 fc->col_type[reg] = DW_CFA_undefined;
7453 case DW_CFA_def_cfa:
7457 case DW_CFA_def_cfa_register:
7460 case DW_CFA_def_cfa_offset:
7463 case DW_CFA_def_cfa_expression:
7465 new_start = start + temp;
7466 if (new_start < start)
7468 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
7474 case DW_CFA_expression:
7475 case DW_CFA_val_expression:
7478 new_start = start + temp;
7479 if (new_start < start)
7481 /* PR 17512: file:306-192417-0.005. */
7482 warn (_("Corrupt CFA expression value: %lu\n"), temp);
7487 if (frame_need_space (fc, reg) >= 0)
7488 fc->col_type[reg] = DW_CFA_undefined;
7490 case DW_CFA_offset_extended_sf:
7491 case DW_CFA_val_offset_sf:
7494 if (frame_need_space (fc, reg) >= 0)
7495 fc->col_type[reg] = DW_CFA_undefined;
7497 case DW_CFA_def_cfa_sf:
7501 case DW_CFA_def_cfa_offset_sf:
7504 case DW_CFA_MIPS_advance_loc8:
7507 case DW_CFA_GNU_args_size:
7510 case DW_CFA_GNU_negative_offset_extended:
7513 if (frame_need_space (fc, reg) >= 0)
7514 fc->col_type[reg] = DW_CFA_undefined;
7525 /* Now we know what registers are used, make a second pass over
7526 the chunk, this time actually printing out the info. */
7528 while (start < block_end)
7530 unsigned char * tmp;
7532 unsigned long ul, roffs;
7533 /* Note: It is tempting to use an unsigned long for 'reg' but there
7534 are various functions, notably frame_space_needed() that assume that
7535 reg is an unsigned int. */
7540 const char *reg_prefix = "";
7547 /* Make a note if something other than DW_CFA_nop happens. */
7548 if (op != DW_CFA_nop)
7551 /* Warning: if you add any more cases to this switch, be
7552 sure to add them to the corresponding switch above. */
7555 case DW_CFA_advance_loc:
7556 if (do_debug_frames_interp)
7557 frame_display_row (fc, &need_col_headers, &max_regs);
7559 printf (" DW_CFA_advance_loc: %d to %s\n",
7560 opa * fc->code_factor,
7561 dwarf_vmatoa_1 (NULL,
7562 fc->pc_begin + opa * fc->code_factor,
7564 fc->pc_begin += opa * fc->code_factor;
7569 if (opa >= (unsigned int) fc->ncols)
7570 reg_prefix = bad_reg;
7571 if (! do_debug_frames_interp || *reg_prefix != '\0')
7572 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7573 reg_prefix, regname (opa, 0),
7574 roffs * fc->data_factor);
7575 if (*reg_prefix == '\0')
7577 fc->col_type[opa] = DW_CFA_offset;
7578 fc->col_offset[opa] = roffs * fc->data_factor;
7582 case DW_CFA_restore:
7583 if (opa >= (unsigned int) fc->ncols)
7584 reg_prefix = bad_reg;
7585 if (! do_debug_frames_interp || *reg_prefix != '\0')
7586 printf (" DW_CFA_restore: %s%s\n",
7587 reg_prefix, regname (opa, 0));
7588 if (*reg_prefix != '\0')
7591 if (opa >= (unsigned int) cie->ncols
7592 || (do_debug_frames_interp
7593 && cie->col_type[opa] == DW_CFA_unreferenced))
7595 fc->col_type[opa] = DW_CFA_undefined;
7596 fc->col_offset[opa] = 0;
7600 fc->col_type[opa] = cie->col_type[opa];
7601 fc->col_offset[opa] = cie->col_offset[opa];
7605 case DW_CFA_set_loc:
7606 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
7607 if (do_debug_frames_interp)
7608 frame_display_row (fc, &need_col_headers, &max_regs);
7610 printf (" DW_CFA_set_loc: %s\n",
7611 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
7615 case DW_CFA_advance_loc1:
7616 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
7617 if (do_debug_frames_interp)
7618 frame_display_row (fc, &need_col_headers, &max_regs);
7620 printf (" DW_CFA_advance_loc1: %ld to %s\n",
7621 (unsigned long) (ofs * fc->code_factor),
7622 dwarf_vmatoa_1 (NULL,
7623 fc->pc_begin + ofs * fc->code_factor,
7625 fc->pc_begin += ofs * fc->code_factor;
7628 case DW_CFA_advance_loc2:
7629 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
7630 if (do_debug_frames_interp)
7631 frame_display_row (fc, &need_col_headers, &max_regs);
7633 printf (" DW_CFA_advance_loc2: %ld to %s\n",
7634 (unsigned long) (ofs * fc->code_factor),
7635 dwarf_vmatoa_1 (NULL,
7636 fc->pc_begin + ofs * fc->code_factor,
7638 fc->pc_begin += ofs * fc->code_factor;
7641 case DW_CFA_advance_loc4:
7642 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
7643 if (do_debug_frames_interp)
7644 frame_display_row (fc, &need_col_headers, &max_regs);
7646 printf (" DW_CFA_advance_loc4: %ld to %s\n",
7647 (unsigned long) (ofs * fc->code_factor),
7648 dwarf_vmatoa_1 (NULL,
7649 fc->pc_begin + ofs * fc->code_factor,
7651 fc->pc_begin += ofs * fc->code_factor;
7654 case DW_CFA_offset_extended:
7657 if (reg >= (unsigned int) fc->ncols)
7658 reg_prefix = bad_reg;
7659 if (! do_debug_frames_interp || *reg_prefix != '\0')
7660 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
7661 reg_prefix, regname (reg, 0),
7662 roffs * fc->data_factor);
7663 if (*reg_prefix == '\0')
7665 fc->col_type[reg] = DW_CFA_offset;
7666 fc->col_offset[reg] = roffs * fc->data_factor;
7670 case DW_CFA_val_offset:
7673 if (reg >= (unsigned int) fc->ncols)
7674 reg_prefix = bad_reg;
7675 if (! do_debug_frames_interp || *reg_prefix != '\0')
7676 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
7677 reg_prefix, regname (reg, 0),
7678 roffs * fc->data_factor);
7679 if (*reg_prefix == '\0')
7681 fc->col_type[reg] = DW_CFA_val_offset;
7682 fc->col_offset[reg] = roffs * fc->data_factor;
7686 case DW_CFA_restore_extended:
7688 if (reg >= (unsigned int) fc->ncols)
7689 reg_prefix = bad_reg;
7690 if (! do_debug_frames_interp || *reg_prefix != '\0')
7691 printf (" DW_CFA_restore_extended: %s%s\n",
7692 reg_prefix, regname (reg, 0));
7693 if (*reg_prefix != '\0')
7696 if (reg >= (unsigned int) cie->ncols)
7698 fc->col_type[reg] = DW_CFA_undefined;
7699 fc->col_offset[reg] = 0;
7703 fc->col_type[reg] = cie->col_type[reg];
7704 fc->col_offset[reg] = cie->col_offset[reg];
7708 case DW_CFA_undefined:
7710 if (reg >= (unsigned int) fc->ncols)
7711 reg_prefix = bad_reg;
7712 if (! do_debug_frames_interp || *reg_prefix != '\0')
7713 printf (" DW_CFA_undefined: %s%s\n",
7714 reg_prefix, regname (reg, 0));
7715 if (*reg_prefix == '\0')
7717 fc->col_type[reg] = DW_CFA_undefined;
7718 fc->col_offset[reg] = 0;
7722 case DW_CFA_same_value:
7724 if (reg >= (unsigned int) fc->ncols)
7725 reg_prefix = bad_reg;
7726 if (! do_debug_frames_interp || *reg_prefix != '\0')
7727 printf (" DW_CFA_same_value: %s%s\n",
7728 reg_prefix, regname (reg, 0));
7729 if (*reg_prefix == '\0')
7731 fc->col_type[reg] = DW_CFA_same_value;
7732 fc->col_offset[reg] = 0;
7736 case DW_CFA_register:
7739 if (reg >= (unsigned int) fc->ncols)
7740 reg_prefix = bad_reg;
7741 if (! do_debug_frames_interp || *reg_prefix != '\0')
7743 printf (" DW_CFA_register: %s%s in ",
7744 reg_prefix, regname (reg, 0));
7745 puts (regname (roffs, 0));
7747 if (*reg_prefix == '\0')
7749 fc->col_type[reg] = DW_CFA_register;
7750 fc->col_offset[reg] = roffs;
7754 case DW_CFA_remember_state:
7755 if (! do_debug_frames_interp)
7756 printf (" DW_CFA_remember_state\n");
7757 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7758 rs->cfa_offset = fc->cfa_offset;
7759 rs->cfa_reg = fc->cfa_reg;
7761 rs->cfa_exp = fc->cfa_exp;
7762 rs->ncols = fc->ncols;
7763 rs->col_type = (short int *) xcmalloc (rs->ncols,
7764 sizeof (* rs->col_type));
7765 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
7766 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
7767 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
7768 rs->next = remembered_state;
7769 remembered_state = rs;
7772 case DW_CFA_restore_state:
7773 if (! do_debug_frames_interp)
7774 printf (" DW_CFA_restore_state\n");
7775 rs = remembered_state;
7778 remembered_state = rs->next;
7779 fc->cfa_offset = rs->cfa_offset;
7780 fc->cfa_reg = rs->cfa_reg;
7782 fc->cfa_exp = rs->cfa_exp;
7783 if (frame_need_space (fc, rs->ncols - 1) < 0)
7785 warn (_("Invalid column number in saved frame state\n"));
7789 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
7790 memcpy (fc->col_offset, rs->col_offset,
7791 rs->ncols * sizeof (* rs->col_offset));
7792 free (rs->col_type);
7793 free (rs->col_offset);
7796 else if (do_debug_frames_interp)
7797 printf ("Mismatched DW_CFA_restore_state\n");
7800 case DW_CFA_def_cfa:
7801 READ_SLEB (fc->cfa_reg);
7802 READ_ULEB (fc->cfa_offset);
7804 if (! do_debug_frames_interp)
7805 printf (" DW_CFA_def_cfa: %s ofs %d\n",
7806 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
7809 case DW_CFA_def_cfa_register:
7810 READ_SLEB (fc->cfa_reg);
7812 if (! do_debug_frames_interp)
7813 printf (" DW_CFA_def_cfa_register: %s\n",
7814 regname (fc->cfa_reg, 0));
7817 case DW_CFA_def_cfa_offset:
7818 READ_ULEB (fc->cfa_offset);
7819 if (! do_debug_frames_interp)
7820 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
7824 if (! do_debug_frames_interp)
7825 printf (" DW_CFA_nop\n");
7828 case DW_CFA_def_cfa_expression:
7830 if (start >= block_end || ul > (unsigned long) (block_end - start))
7832 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
7835 if (! do_debug_frames_interp)
7837 printf (" DW_CFA_def_cfa_expression (");
7838 decode_location_expression (start, eh_addr_size, 0, -1,
7846 case DW_CFA_expression:
7849 if (reg >= (unsigned int) fc->ncols)
7850 reg_prefix = bad_reg;
7851 /* PR 17512: file: 069-133014-0.006. */
7852 /* PR 17512: file: 98c02eb4. */
7854 if (start >= block_end || tmp > block_end || tmp < start)
7856 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
7859 if (! do_debug_frames_interp || *reg_prefix != '\0')
7861 printf (" DW_CFA_expression: %s%s (",
7862 reg_prefix, regname (reg, 0));
7863 decode_location_expression (start, eh_addr_size, 0, -1,
7867 if (*reg_prefix == '\0')
7868 fc->col_type[reg] = DW_CFA_expression;
7872 case DW_CFA_val_expression:
7875 if (reg >= (unsigned int) fc->ncols)
7876 reg_prefix = bad_reg;
7878 if (start >= block_end || tmp > block_end || tmp < start)
7880 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
7883 if (! do_debug_frames_interp || *reg_prefix != '\0')
7885 printf (" DW_CFA_val_expression: %s%s (",
7886 reg_prefix, regname (reg, 0));
7887 decode_location_expression (start, eh_addr_size, 0, -1,
7891 if (*reg_prefix == '\0')
7892 fc->col_type[reg] = DW_CFA_val_expression;
7896 case DW_CFA_offset_extended_sf:
7899 if (frame_need_space (fc, reg) < 0)
7900 reg_prefix = bad_reg;
7901 if (! do_debug_frames_interp || *reg_prefix != '\0')
7902 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
7903 reg_prefix, regname (reg, 0),
7904 (long)(l * fc->data_factor));
7905 if (*reg_prefix == '\0')
7907 fc->col_type[reg] = DW_CFA_offset;
7908 fc->col_offset[reg] = l * fc->data_factor;
7912 case DW_CFA_val_offset_sf:
7915 if (frame_need_space (fc, reg) < 0)
7916 reg_prefix = bad_reg;
7917 if (! do_debug_frames_interp || *reg_prefix != '\0')
7918 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
7919 reg_prefix, regname (reg, 0),
7920 (long)(l * fc->data_factor));
7921 if (*reg_prefix == '\0')
7923 fc->col_type[reg] = DW_CFA_val_offset;
7924 fc->col_offset[reg] = l * fc->data_factor;
7928 case DW_CFA_def_cfa_sf:
7929 READ_SLEB (fc->cfa_reg);
7930 READ_ULEB (fc->cfa_offset);
7931 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
7933 if (! do_debug_frames_interp)
7934 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
7935 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
7938 case DW_CFA_def_cfa_offset_sf:
7939 READ_ULEB (fc->cfa_offset);
7940 fc->cfa_offset *= fc->data_factor;
7941 if (! do_debug_frames_interp)
7942 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
7945 case DW_CFA_MIPS_advance_loc8:
7946 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
7947 if (do_debug_frames_interp)
7948 frame_display_row (fc, &need_col_headers, &max_regs);
7950 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
7951 (unsigned long) (ofs * fc->code_factor),
7952 dwarf_vmatoa_1 (NULL,
7953 fc->pc_begin + ofs * fc->code_factor,
7955 fc->pc_begin += ofs * fc->code_factor;
7958 case DW_CFA_GNU_window_save:
7959 if (! do_debug_frames_interp)
7960 printf (" DW_CFA_GNU_window_save\n");
7963 case DW_CFA_GNU_args_size:
7965 if (! do_debug_frames_interp)
7966 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
7969 case DW_CFA_GNU_negative_offset_extended:
7973 if (frame_need_space (fc, reg) < 0)
7974 reg_prefix = bad_reg;
7975 if (! do_debug_frames_interp || *reg_prefix != '\0')
7976 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
7977 reg_prefix, regname (reg, 0),
7978 (long)(l * fc->data_factor));
7979 if (*reg_prefix == '\0')
7981 fc->col_type[reg] = DW_CFA_offset;
7982 fc->col_offset[reg] = l * fc->data_factor;
7987 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
7988 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
7990 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
7995 /* Interpret the CFA - as long as it is not completely full of NOPs. */
7996 if (do_debug_frames_interp && ! all_nops)
7997 frame_display_row (fc, &need_col_headers, &max_regs);
8000 eh_addr_size = saved_eh_addr_size;
8011 display_debug_names (struct dwarf_section *section, void *file)
8013 unsigned char *hdrptr = section->start;
8014 dwarf_vma unit_length;
8015 unsigned char *unit_start;
8016 const unsigned char *const section_end = section->start + section->size;
8017 unsigned char *unit_end;
8019 printf (_("Contents of the %s section:\n"), section->name);
8021 load_debug_section (str, file);
8023 for (; hdrptr < section_end; hdrptr = unit_end)
8025 unsigned int offset_size;
8026 uint16_t dwarf_version, padding;
8027 uint32_t comp_unit_count, local_type_unit_count, foreign_type_unit_count;
8028 uint32_t bucket_count, name_count, abbrev_table_size;
8029 uint32_t augmentation_string_size;
8032 unit_start = hdrptr;
8034 /* Get and check the length of the block. */
8035 SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 4, section_end);
8037 if (unit_length == 0xffffffff)
8039 /* This section is 64-bit DWARF. */
8040 SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 8, section_end);
8045 unit_end = hdrptr + unit_length;
8047 if ((hdrptr - section->start) + unit_length > section->size)
8049 warn (_("The length field (0x%lx) for unit 0x%lx in the debug_names "
8050 "header is wrong - the section is too small\n"),
8051 (long) unit_length, (long) (unit_start - section->start));
8055 /* Get and check the version number. */
8056 SAFE_BYTE_GET_AND_INC (dwarf_version, hdrptr, 2, unit_end);
8057 printf (_("Version %ld\n"), (long) dwarf_version);
8059 /* Prior versions did not exist, and future versions may not be
8060 backwards compatible. */
8061 if (dwarf_version != 5)
8063 warn (_("Only DWARF version 5 .debug_names "
8064 "is currently supported.\n"));
8068 SAFE_BYTE_GET_AND_INC (padding, hdrptr, 2, unit_end);
8070 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8073 SAFE_BYTE_GET_AND_INC (comp_unit_count, hdrptr, 4, unit_end);
8074 if (comp_unit_count == 0)
8075 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8077 SAFE_BYTE_GET_AND_INC (local_type_unit_count, hdrptr, 4, unit_end);
8078 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count, hdrptr, 4, unit_end);
8079 SAFE_BYTE_GET_AND_INC (bucket_count, hdrptr, 4, unit_end);
8080 SAFE_BYTE_GET_AND_INC (name_count, hdrptr, 4, unit_end);
8081 SAFE_BYTE_GET_AND_INC (abbrev_table_size, hdrptr, 4, unit_end);
8083 SAFE_BYTE_GET_AND_INC (augmentation_string_size, hdrptr, 4, unit_end);
8084 if (augmentation_string_size % 4 != 0)
8086 warn (_("Augmentation string length %u must be rounded up "
8087 "to a multiple of 4 in .debug_names.\n"),
8088 augmentation_string_size);
8089 augmentation_string_size += (-augmentation_string_size) & 3;
8091 printf (_("Augmentation string:"));
8092 for (i = 0; i < augmentation_string_size; i++)
8096 SAFE_BYTE_GET_AND_INC (uc, hdrptr, 1, unit_end);
8097 printf (" %02x", uc);
8102 printf (_("CU table:\n"));
8103 for (i = 0; i < comp_unit_count; i++)
8107 SAFE_BYTE_GET_AND_INC (cu_offset, hdrptr, offset_size, unit_end);
8108 printf (_("[%3u] 0x%lx\n"), i, (unsigned long) cu_offset);
8112 printf (_("TU table:\n"));
8113 for (i = 0; i < local_type_unit_count; i++)
8117 SAFE_BYTE_GET_AND_INC (tu_offset, hdrptr, offset_size, unit_end);
8118 printf (_("[%3u] 0x%lx\n"), i, (unsigned long) tu_offset);
8122 printf (_("Foreign TU table:\n"));
8123 for (i = 0; i < foreign_type_unit_count; i++)
8127 SAFE_BYTE_GET_AND_INC (signature, hdrptr, 8, unit_end);
8128 printf (_("[%3u] "), i);
8129 print_dwarf_vma (signature, 8);
8134 const uint32_t *const hash_table_buckets = (uint32_t *) hdrptr;
8135 hdrptr += bucket_count * sizeof (uint32_t);
8136 const uint32_t *const hash_table_hashes = (uint32_t *) hdrptr;
8137 hdrptr += name_count * sizeof (uint32_t);
8138 unsigned char *const name_table_string_offsets = hdrptr;
8139 hdrptr += name_count * offset_size;
8140 unsigned char *const name_table_entry_offsets = hdrptr;
8141 hdrptr += name_count * offset_size;
8142 unsigned char *const abbrev_table = hdrptr;
8143 hdrptr += abbrev_table_size;
8144 const unsigned char *const abbrev_table_end = hdrptr;
8145 unsigned char *const entry_pool = hdrptr;
8146 if (hdrptr > unit_end)
8148 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8149 "for unit 0x%lx in the debug_names\n"),
8150 (long) (hdrptr - section->start),
8151 (long) (unit_end - section->start),
8152 (long) (unit_start - section->start));
8156 size_t buckets_filled = 0;
8158 for (bucketi = 0; bucketi < bucket_count; bucketi++)
8160 const uint32_t bucket = hash_table_buckets[bucketi];
8165 printf (_("Used %zu of %lu buckets.\n"), buckets_filled,
8166 (unsigned long) bucket_count);
8168 uint32_t hash_prev = 0;
8169 size_t hash_clash_count = 0;
8170 size_t longest_clash = 0;
8171 size_t this_length = 0;
8173 for (hashi = 0; hashi < name_count; hashi++)
8175 const uint32_t hash_this = hash_table_hashes[hashi];
8179 if (hash_prev % bucket_count == hash_this % bucket_count)
8183 longest_clash = MAX (longest_clash, this_length);
8188 hash_prev = hash_this;
8190 printf (_("Out of %lu items there are %zu bucket clashes"
8191 " (longest of %zu entries).\n"),
8192 (unsigned long) name_count, hash_clash_count, longest_clash);
8193 assert (name_count == buckets_filled + hash_clash_count);
8195 struct abbrev_lookup_entry
8197 dwarf_vma abbrev_tag;
8198 unsigned char *abbrev_lookup_ptr;
8200 struct abbrev_lookup_entry *abbrev_lookup = NULL;
8201 size_t abbrev_lookup_used = 0;
8202 size_t abbrev_lookup_allocated = 0;
8204 unsigned char *abbrevptr = abbrev_table;
8207 unsigned int bytes_read;
8208 const dwarf_vma abbrev_tag = read_uleb128 (abbrevptr, &bytes_read,
8210 abbrevptr += bytes_read;
8211 if (abbrev_tag == 0)
8213 if (abbrev_lookup_used == abbrev_lookup_allocated)
8215 abbrev_lookup_allocated = MAX (0x100,
8216 abbrev_lookup_allocated * 2);
8217 abbrev_lookup = xrealloc (abbrev_lookup,
8218 (abbrev_lookup_allocated
8219 * sizeof (*abbrev_lookup)));
8221 assert (abbrev_lookup_used < abbrev_lookup_allocated);
8222 struct abbrev_lookup_entry *entry;
8223 for (entry = abbrev_lookup;
8224 entry < abbrev_lookup + abbrev_lookup_used;
8226 if (entry->abbrev_tag == abbrev_tag)
8228 warn (_("Duplicate abbreviation tag %lu "
8229 "in unit 0x%lx in the debug_names\n"),
8230 (long) abbrev_tag, (long) (unit_start - section->start));
8233 entry = &abbrev_lookup[abbrev_lookup_used++];
8234 entry->abbrev_tag = abbrev_tag;
8235 entry->abbrev_lookup_ptr = abbrevptr;
8237 /* Skip DWARF tag. */
8238 read_uleb128 (abbrevptr, &bytes_read, abbrev_table_end);
8239 abbrevptr += bytes_read;
8242 const dwarf_vma xindex = read_uleb128 (abbrevptr,
8245 abbrevptr += bytes_read;
8246 const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
8248 abbrevptr += bytes_read;
8249 if (xindex == 0 && form == 0)
8254 printf (_("\nSymbol table:\n"));
8256 for (namei = 0; namei < name_count; ++namei)
8258 uint64_t string_offset, entry_offset;
8260 SAFE_BYTE_GET (string_offset,
8261 name_table_string_offsets + namei * offset_size,
8262 offset_size, unit_end);
8263 SAFE_BYTE_GET (entry_offset,
8264 name_table_entry_offsets + namei * offset_size,
8265 offset_size, unit_end);
8267 printf ("[%3u] #%08x %s:", namei, hash_table_hashes[namei],
8268 fetch_indirect_string (string_offset));
8270 unsigned char *entryptr = entry_pool + entry_offset;
8272 // We need to scan first whether there is a single or multiple
8273 // entries. TAGNO is -2 for the first entry, it is -1 for the
8274 // initial tag read of the second entry, then it becomes 0 for the
8275 // first entry for real printing etc.
8277 /* Initialize it due to a false compiler warning. */
8278 dwarf_vma second_abbrev_tag = -1;
8281 unsigned int bytes_read;
8282 const dwarf_vma abbrev_tag = read_uleb128 (entryptr, &bytes_read,
8284 entryptr += bytes_read;
8287 second_abbrev_tag = abbrev_tag;
8289 entryptr = entry_pool + entry_offset;
8292 if (abbrev_tag == 0)
8296 (tagno == 0 && second_abbrev_tag == 0 ? " " : "\n\t"),
8297 (unsigned long) abbrev_tag);
8299 const struct abbrev_lookup_entry *entry;
8300 for (entry = abbrev_lookup;
8301 entry < abbrev_lookup + abbrev_lookup_used;
8303 if (entry->abbrev_tag == abbrev_tag)
8305 if (entry >= abbrev_lookup + abbrev_lookup_used)
8307 warn (_("Undefined abbreviation tag %lu "
8308 "in unit 0x%lx in the debug_names\n"),
8310 (long) (unit_start - section->start));
8313 abbrevptr = entry->abbrev_lookup_ptr;
8314 const dwarf_vma dwarf_tag = read_uleb128 (abbrevptr, &bytes_read,
8316 abbrevptr += bytes_read;
8318 printf (" %s", get_TAG_name (dwarf_tag));
8321 const dwarf_vma xindex = read_uleb128 (abbrevptr,
8324 abbrevptr += bytes_read;
8325 const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
8327 abbrevptr += bytes_read;
8328 if (xindex == 0 && form == 0)
8332 printf (" %s", get_IDX_name (xindex));
8333 entryptr = read_and_display_attr_value (0, form, 0, entryptr,
8336 dwarf_version, NULL,
8343 printf (_(" <no entries>"));
8347 free (abbrev_lookup);
8354 display_gdb_index (struct dwarf_section *section,
8355 void *file ATTRIBUTE_UNUSED)
8357 unsigned char *start = section->start;
8359 uint32_t cu_list_offset, tu_list_offset;
8360 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
8361 unsigned int cu_list_elements, tu_list_elements;
8362 unsigned int address_table_size, symbol_table_slots;
8363 unsigned char *cu_list, *tu_list;
8364 unsigned char *address_table, *symbol_table, *constant_pool;
8367 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8369 printf (_("Contents of the %s section:\n"), section->name);
8371 if (section->size < 6 * sizeof (uint32_t))
8373 warn (_("Truncated header in the %s section.\n"), section->name);
8377 version = byte_get_little_endian (start, 4);
8378 printf (_("Version %ld\n"), (long) version);
8380 /* Prior versions are obsolete, and future versions may not be
8381 backwards compatible. */
8382 if (version < 3 || version > 8)
8384 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
8388 warn (_("The address table data in version 3 may be wrong.\n"));
8390 warn (_("Version 4 does not support case insensitive lookups.\n"));
8392 warn (_("Version 5 does not include inlined functions.\n"));
8394 warn (_("Version 6 does not include symbol attributes.\n"));
8395 /* Version 7 indices generated by Gold have bad type unit references,
8396 PR binutils/15021. But we don't know if the index was generated by
8397 Gold or not, so to avoid worrying users with gdb-generated indices
8398 we say nothing for version 7 here. */
8400 cu_list_offset = byte_get_little_endian (start + 4, 4);
8401 tu_list_offset = byte_get_little_endian (start + 8, 4);
8402 address_table_offset = byte_get_little_endian (start + 12, 4);
8403 symbol_table_offset = byte_get_little_endian (start + 16, 4);
8404 constant_pool_offset = byte_get_little_endian (start + 20, 4);
8406 if (cu_list_offset > section->size
8407 || tu_list_offset > section->size
8408 || address_table_offset > section->size
8409 || symbol_table_offset > section->size
8410 || constant_pool_offset > section->size)
8412 warn (_("Corrupt header in the %s section.\n"), section->name);
8416 /* PR 17531: file: 418d0a8a. */
8417 if (tu_list_offset < cu_list_offset)
8419 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8420 tu_list_offset, cu_list_offset);
8424 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
8426 if (address_table_offset < tu_list_offset)
8428 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8429 address_table_offset, tu_list_offset);
8433 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
8435 /* PR 17531: file: 18a47d3d. */
8436 if (symbol_table_offset < address_table_offset)
8438 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8439 symbol_table_offset, address_table_offset);
8443 address_table_size = symbol_table_offset - address_table_offset;
8445 if (constant_pool_offset < symbol_table_offset)
8447 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8448 constant_pool_offset, symbol_table_offset);
8452 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
8454 cu_list = start + cu_list_offset;
8455 tu_list = start + tu_list_offset;
8456 address_table = start + address_table_offset;
8457 symbol_table = start + symbol_table_offset;
8458 constant_pool = start + constant_pool_offset;
8460 if (address_table + address_table_size > section->start + section->size)
8462 warn (_("Address table extends beyond end of section.\n"));
8466 printf (_("\nCU table:\n"));
8467 for (i = 0; i < cu_list_elements; i += 2)
8469 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
8470 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
8472 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
8473 (unsigned long) cu_offset,
8474 (unsigned long) (cu_offset + cu_length - 1));
8477 printf (_("\nTU table:\n"));
8478 for (i = 0; i < tu_list_elements; i += 3)
8480 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
8481 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
8482 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
8484 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
8485 (unsigned long) tu_offset,
8486 (unsigned long) type_offset);
8487 print_dwarf_vma (signature, 8);
8491 printf (_("\nAddress table:\n"));
8492 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
8495 uint64_t low = byte_get_little_endian (address_table + i, 8);
8496 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
8497 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
8499 print_dwarf_vma (low, 8);
8500 print_dwarf_vma (high, 8);
8501 printf (_("%lu\n"), (unsigned long) cu_index);
8504 printf (_("\nSymbol table:\n"));
8505 for (i = 0; i < symbol_table_slots; ++i)
8507 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
8508 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
8509 uint32_t num_cus, cu;
8511 if (name_offset != 0
8512 || cu_vector_offset != 0)
8515 unsigned char * adr;
8517 adr = constant_pool + name_offset;
8518 /* PR 17531: file: 5b7b07ad. */
8519 if (adr < constant_pool || adr >= section->start + section->size)
8521 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
8522 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8526 printf ("[%3u] %.*s:", i,
8527 (int) (section->size - (constant_pool_offset + name_offset)),
8528 constant_pool + name_offset);
8530 adr = constant_pool + cu_vector_offset;
8531 if (adr < constant_pool || adr >= section->start + section->size - 3)
8533 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
8534 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8535 cu_vector_offset, i);
8539 num_cus = byte_get_little_endian (adr, 4);
8541 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
8542 if (num_cus * 4 < num_cus
8543 || adr >= section->start + section->size
8544 || adr < constant_pool)
8546 printf ("<invalid number of CUs: %d>\n", num_cus);
8547 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
8555 for (j = 0; j < num_cus; ++j)
8558 gdb_index_symbol_kind kind;
8560 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
8561 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
8562 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
8563 cu = GDB_INDEX_CU_VALUE (cu);
8564 /* Convert to TU number if it's for a type unit. */
8565 if (cu >= cu_list_elements / 2)
8566 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
8567 (unsigned long) (cu - cu_list_elements / 2));
8569 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
8571 printf (" [%s, %s]",
8572 is_static ? _("static") : _("global"),
8573 get_gdb_index_symbol_kind_name (kind));
8585 /* Pre-allocate enough space for the CU/TU sets needed. */
8588 prealloc_cu_tu_list (unsigned int nshndx)
8590 if (shndx_pool == NULL)
8592 shndx_pool_size = nshndx;
8593 shndx_pool_used = 0;
8594 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
8595 sizeof (unsigned int));
8599 shndx_pool_size = shndx_pool_used + nshndx;
8600 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
8601 sizeof (unsigned int));
8606 add_shndx_to_cu_tu_entry (unsigned int shndx)
8608 if (shndx_pool_used >= shndx_pool_size)
8610 error (_("Internal error: out of space in the shndx pool.\n"));
8613 shndx_pool [shndx_pool_used++] = shndx;
8617 end_cu_tu_entry (void)
8619 if (shndx_pool_used >= shndx_pool_size)
8621 error (_("Internal error: out of space in the shndx pool.\n"));
8624 shndx_pool [shndx_pool_used++] = 0;
8627 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
8630 get_DW_SECT_short_name (unsigned int dw_sect)
8632 static char buf[16];
8640 case DW_SECT_ABBREV:
8646 case DW_SECT_STR_OFFSETS:
8648 case DW_SECT_MACINFO:
8656 snprintf (buf, sizeof (buf), "%d", dw_sect);
8660 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
8661 These sections are extensions for Fission.
8662 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
8665 process_cu_tu_index (struct dwarf_section *section, int do_display)
8667 unsigned char *phdr = section->start;
8668 unsigned char *limit = phdr + section->size;
8669 unsigned char *phash;
8670 unsigned char *pindex;
8671 unsigned char *ppool;
8672 unsigned int version;
8673 unsigned int ncols = 0;
8675 unsigned int nslots;
8678 dwarf_vma signature_high;
8679 dwarf_vma signature_low;
8682 /* PR 17512: file: 002-168123-0.004. */
8685 warn (_("Section %s is empty\n"), section->name);
8688 /* PR 17512: file: 002-376-0.004. */
8689 if (section->size < 24)
8691 warn (_("Section %s is too small to contain a CU/TU header\n"),
8696 SAFE_BYTE_GET (version, phdr, 4, limit);
8698 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
8699 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
8700 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
8703 pindex = phash + nslots * 8;
8704 ppool = pindex + nslots * 4;
8706 /* PR 17531: file: 45d69832. */
8707 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
8709 warn (_("Section %s is too small for %d slots\n"),
8710 section->name, nslots);
8716 printf (_("Contents of the %s section:\n\n"), section->name);
8717 printf (_(" Version: %d\n"), version);
8719 printf (_(" Number of columns: %d\n"), ncols);
8720 printf (_(" Number of used entries: %d\n"), nused);
8721 printf (_(" Number of slots: %d\n\n"), nslots);
8724 if (ppool > limit || ppool < phdr)
8726 warn (_("Section %s too small for %d hash table entries\n"),
8727 section->name, nslots);
8734 prealloc_cu_tu_list ((limit - ppool) / 4);
8735 for (i = 0; i < nslots; i++)
8737 unsigned char *shndx_list;
8740 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
8741 if (signature_high != 0 || signature_low != 0)
8743 SAFE_BYTE_GET (j, pindex, 4, limit);
8744 shndx_list = ppool + j * 4;
8745 /* PR 17531: file: 705e010d. */
8746 if (shndx_list < ppool)
8748 warn (_("Section index pool located before start of section\n"));
8753 printf (_(" [%3d] Signature: 0x%s Sections: "),
8754 i, dwarf_vmatoa64 (signature_high, signature_low,
8755 buf, sizeof (buf)));
8758 if (shndx_list >= limit)
8760 warn (_("Section %s too small for shndx pool\n"),
8764 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
8768 printf (" %d", shndx);
8770 add_shndx_to_cu_tu_entry (shndx);
8782 else if (version == 2)
8785 unsigned int dw_sect;
8786 unsigned char *ph = phash;
8787 unsigned char *pi = pindex;
8788 unsigned char *poffsets = ppool + ncols * 4;
8789 unsigned char *psizes = poffsets + nused * ncols * 4;
8790 unsigned char *pend = psizes + nused * ncols * 4;
8791 bfd_boolean is_tu_index;
8792 struct cu_tu_set *this_set = NULL;
8794 unsigned char *prow;
8796 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
8798 /* PR 17531: file: 0dd159bf.
8799 Check for wraparound with an overlarge ncols value. */
8800 if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
8802 warn (_("Overlarge number of columns: %x\n"), ncols);
8808 warn (_("Section %s too small for offset and size tables\n"),
8815 printf (_(" Offset table\n"));
8816 printf (" slot %-16s ",
8817 is_tu_index ? _("signature") : _("dwo_id"));
8824 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
8830 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
8837 for (j = 0; j < ncols; j++)
8839 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
8840 printf (" %8s", get_DW_SECT_short_name (dw_sect));
8845 for (i = 0; i < nslots; i++)
8847 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
8849 SAFE_BYTE_GET (row, pi, 4, limit);
8852 /* PR 17531: file: a05f6ab3. */
8855 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
8861 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
8863 prow = poffsets + (row - 1) * ncols * 4;
8864 /* PR 17531: file: b8ce60a8. */
8865 if (prow < poffsets || prow > limit)
8867 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
8873 printf (_(" [%3d] 0x%s"),
8874 i, dwarf_vmatoa64 (signature_high, signature_low,
8875 buf, sizeof (buf)));
8876 for (j = 0; j < ncols; j++)
8878 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
8880 printf (" %8d", val);
8883 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
8885 /* PR 17531: file: 10796eb3. */
8886 if (dw_sect >= DW_SECT_MAX)
8887 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
8889 this_set [row - 1].section_offsets [dw_sect] = val;
8905 printf (_(" Size table\n"));
8906 printf (" slot %-16s ",
8907 is_tu_index ? _("signature") : _("dwo_id"));
8910 for (j = 0; j < ncols; j++)
8912 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
8914 printf (" %8s", get_DW_SECT_short_name (val));
8920 for (i = 0; i < nslots; i++)
8922 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
8924 SAFE_BYTE_GET (row, pi, 4, limit);
8927 prow = psizes + (row - 1) * ncols * 4;
8930 printf (_(" [%3d] 0x%s"),
8931 i, dwarf_vmatoa64 (signature_high, signature_low,
8932 buf, sizeof (buf)));
8934 for (j = 0; j < ncols; j++)
8936 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
8938 printf (" %8d", val);
8941 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
8942 if (dw_sect >= DW_SECT_MAX)
8943 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
8945 this_set [row - 1].section_sizes [dw_sect] = val;
8957 else if (do_display)
8958 printf (_(" Unsupported version (%d)\n"), version);
8966 /* Load the CU and TU indexes if present. This will build a list of
8967 section sets that we can use to associate a .debug_info.dwo section
8968 with its associated .debug_abbrev.dwo section in a .dwp file. */
8971 load_cu_tu_indexes (void *file)
8973 static int cu_tu_indexes_read = -1; /* Tri-state variable. */
8975 /* If we have already loaded (or tried to load) the CU and TU indexes
8976 then do not bother to repeat the task. */
8977 if (cu_tu_indexes_read == -1)
8979 cu_tu_indexes_read = TRUE;
8981 if (load_debug_section (dwp_cu_index, file))
8982 if (! process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0))
8983 cu_tu_indexes_read = FALSE;
8985 if (load_debug_section (dwp_tu_index, file))
8986 if (! process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0))
8987 cu_tu_indexes_read = FALSE;
8990 return (bfd_boolean) cu_tu_indexes_read;
8993 /* Find the set of sections that includes section SHNDX. */
8996 find_cu_tu_set (void *file, unsigned int shndx)
9000 if (! load_cu_tu_indexes (file))
9003 /* Find SHNDX in the shndx pool. */
9004 for (i = 0; i < shndx_pool_used; i++)
9005 if (shndx_pool [i] == shndx)
9008 if (i >= shndx_pool_used)
9011 /* Now backup to find the first entry in the set. */
9012 while (i > 0 && shndx_pool [i - 1] != 0)
9015 return shndx_pool + i;
9018 /* Display a .debug_cu_index or .debug_tu_index section. */
9021 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
9023 return process_cu_tu_index (section, 1);
9027 display_debug_not_supported (struct dwarf_section *section,
9028 void *file ATTRIBUTE_UNUSED)
9030 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9036 /* Like malloc, but takes two parameters like calloc.
9037 Verifies that the first parameter is not too large.
9038 Note: does *not* initialise the allocated memory to zero. */
9040 cmalloc (size_t nmemb, size_t size)
9042 /* Check for overflow. */
9043 if (nmemb >= ~(size_t) 0 / size)
9046 return xmalloc (nmemb * size);
9049 /* Like xmalloc, but takes two parameters like calloc.
9050 Verifies that the first parameter is not too large.
9051 Note: does *not* initialise the allocated memory to zero. */
9053 xcmalloc (size_t nmemb, size_t size)
9055 /* Check for overflow. */
9056 if (nmemb >= ~(size_t) 0 / size)
9059 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9064 return xmalloc (nmemb * size);
9067 /* Like xrealloc, but takes three parameters.
9068 Verifies that the second parameter is not too large.
9069 Note: does *not* initialise any new memory to zero. */
9071 xcrealloc (void *ptr, size_t nmemb, size_t size)
9073 /* Check for overflow. */
9074 if (nmemb >= ~(size_t) 0 / size)
9077 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9082 return xrealloc (ptr, nmemb * size);
9085 /* Like xcalloc, but verifies that the first parameter is not too large. */
9087 xcalloc2 (size_t nmemb, size_t size)
9089 /* Check for overflow. */
9090 if (nmemb >= ~(size_t) 0 / size)
9093 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9098 return xcalloc (nmemb, size);
9102 free_debug_memory (void)
9108 for (i = 0; i < max; i++)
9109 free_debug_section ((enum dwarf_section_display_enum) i);
9111 if (debug_information != NULL)
9113 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
9115 for (i = 0; i < num_debug_info_entries; i++)
9117 if (!debug_information [i].max_loc_offsets)
9119 free (debug_information [i].loc_offsets);
9120 free (debug_information [i].have_frame_base);
9122 if (!debug_information [i].max_range_lists)
9123 free (debug_information [i].range_lists);
9126 free (debug_information);
9127 debug_information = NULL;
9128 alloc_num_debug_info_entries = num_debug_info_entries = 0;
9133 dwarf_select_sections_by_names (const char *names)
9137 const char * option;
9141 debug_dump_long_opts;
9143 static const debug_dump_long_opts opts_table [] =
9145 /* Please keep this table alpha- sorted. */
9146 { "Ranges", & do_debug_ranges, 1 },
9147 { "abbrev", & do_debug_abbrevs, 1 },
9148 { "addr", & do_debug_addr, 1 },
9149 { "aranges", & do_debug_aranges, 1 },
9150 { "cu_index", & do_debug_cu_index, 1 },
9151 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
9152 { "frames", & do_debug_frames, 1 },
9153 { "frames-interp", & do_debug_frames_interp, 1 },
9154 /* The special .gdb_index section. */
9155 { "gdb_index", & do_gdb_index, 1 },
9156 { "info", & do_debug_info, 1 },
9157 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
9158 { "loc", & do_debug_loc, 1 },
9159 { "macro", & do_debug_macinfo, 1 },
9160 { "pubnames", & do_debug_pubnames, 1 },
9161 { "pubtypes", & do_debug_pubtypes, 1 },
9162 /* This entry is for compatibility
9163 with earlier versions of readelf. */
9164 { "ranges", & do_debug_aranges, 1 },
9165 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
9166 { "str", & do_debug_str, 1 },
9167 /* These trace_* sections are used by Itanium VMS. */
9168 { "trace_abbrev", & do_trace_abbrevs, 1 },
9169 { "trace_aranges", & do_trace_aranges, 1 },
9170 { "trace_info", & do_trace_info, 1 },
9179 const debug_dump_long_opts * entry;
9181 for (entry = opts_table; entry->option; entry++)
9183 size_t len = strlen (entry->option);
9185 if (strncmp (p, entry->option, len) == 0
9186 && (p[len] == ',' || p[len] == '\0'))
9188 * entry->variable |= entry->val;
9190 /* The --debug-dump=frames-interp option also
9191 enables the --debug-dump=frames option. */
9192 if (do_debug_frames_interp)
9193 do_debug_frames = 1;
9200 if (entry->option == NULL)
9202 warn (_("Unrecognized debug option '%s'\n"), p);
9203 p = strchr (p, ',');
9214 dwarf_select_sections_by_letters (const char *letters)
9216 unsigned int lindex = 0;
9218 while (letters[lindex])
9219 switch (letters[lindex++])
9226 do_debug_abbrevs = 1;
9230 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
9234 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
9238 do_debug_pubnames = 1;
9242 do_debug_pubtypes = 1;
9246 do_debug_aranges = 1;
9250 do_debug_ranges = 1;
9254 do_debug_frames_interp = 1;
9257 do_debug_frames = 1;
9261 do_debug_macinfo = 1;
9273 warn (_("Unrecognized debug option '%s'\n"), letters);
9279 dwarf_select_sections_all (void)
9282 do_debug_abbrevs = 1;
9283 do_debug_lines = FLAG_DEBUG_LINES_RAW;
9284 do_debug_pubnames = 1;
9285 do_debug_pubtypes = 1;
9286 do_debug_aranges = 1;
9287 do_debug_ranges = 1;
9288 do_debug_frames = 1;
9289 do_debug_macinfo = 1;
9294 do_trace_abbrevs = 1;
9295 do_trace_aranges = 1;
9297 do_debug_cu_index = 1;
9300 struct dwarf_section_display debug_displays[] =
9302 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9303 display_debug_abbrev, &do_debug_abbrevs, FALSE },
9304 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9305 display_debug_aranges, &do_debug_aranges, TRUE },
9306 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9307 display_debug_frames, &do_debug_frames, TRUE },
9308 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
9309 display_debug_info, &do_debug_info, TRUE },
9310 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9311 display_debug_lines, &do_debug_lines, TRUE },
9312 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9313 display_debug_pubnames, &do_debug_pubnames, FALSE },
9314 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9315 display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
9316 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9317 display_debug_frames, &do_debug_frames, TRUE },
9318 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9319 display_debug_macinfo, &do_debug_macinfo, FALSE },
9320 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9321 display_debug_macro, &do_debug_macinfo, TRUE },
9322 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9323 display_debug_str, &do_debug_str, FALSE },
9324 { { ".debug_line_str", ".zdebug_line_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9325 display_debug_str, &do_debug_str, FALSE },
9326 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9327 display_debug_loc, &do_debug_loc, TRUE },
9328 { { ".debug_loclists", ".zdebug_loclists", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9329 display_debug_loc, &do_debug_loc, TRUE },
9330 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9331 display_debug_pubnames, &do_debug_pubtypes, FALSE },
9332 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9333 display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
9334 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9335 display_debug_ranges, &do_debug_ranges, TRUE },
9336 { { ".debug_rnglists", ".zdebug_rnglists", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9337 display_debug_ranges, &do_debug_ranges, TRUE },
9338 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9339 display_debug_not_supported, NULL, FALSE },
9340 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9341 display_debug_not_supported, NULL, FALSE },
9342 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
9343 display_debug_types, &do_debug_info, TRUE },
9344 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9345 display_debug_not_supported, NULL, FALSE },
9346 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9347 display_gdb_index, &do_gdb_index, FALSE },
9348 { { ".debug_names", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9349 display_debug_names, &do_gdb_index, FALSE },
9350 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
9351 display_trace_info, &do_trace_info, TRUE },
9352 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9353 display_debug_abbrev, &do_trace_abbrevs, FALSE },
9354 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9355 display_debug_aranges, &do_trace_aranges, FALSE },
9356 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
9357 display_debug_info, &do_debug_info, TRUE },
9358 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9359 display_debug_abbrev, &do_debug_abbrevs, FALSE },
9360 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
9361 display_debug_types, &do_debug_info, TRUE },
9362 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9363 display_debug_lines, &do_debug_lines, TRUE },
9364 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9365 display_debug_loc, &do_debug_loc, TRUE },
9366 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9367 display_debug_macro, &do_debug_macinfo, TRUE },
9368 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9369 display_debug_macinfo, &do_debug_macinfo, FALSE },
9370 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9371 display_debug_str, &do_debug_str, TRUE },
9372 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9373 display_debug_str_offsets, NULL, FALSE },
9374 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9375 display_debug_str_offsets, NULL, FALSE },
9376 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9377 display_debug_addr, &do_debug_addr, TRUE },
9378 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9379 display_cu_index, &do_debug_cu_index, FALSE },
9380 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9381 display_cu_index, &do_debug_cu_index, FALSE },
9384 /* A static assertion. */
9385 extern int debug_displays_assert[ARRAY_SIZE (debug_displays) == max ? 1 : -1];