1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
32 static const char *regname (unsigned int regno, int row);
34 static int have_frame_base;
35 static int need_base_address;
37 static unsigned int last_pointer_size = 0;
38 static int warned_about_missing_comp_units = FALSE;
40 static unsigned int num_debug_info_entries = 0;
41 static unsigned int alloc_num_debug_info_entries = 0;
42 static debug_info *debug_information = NULL;
43 /* Special value for num_debug_info_entries to indicate
44 that the .debug_info section could not be loaded/parsed. */
45 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
47 unsigned int eh_addr_size;
52 int do_debug_pubnames;
53 int do_debug_pubtypes;
57 int do_debug_frames_interp;
66 int do_debug_cu_index;
69 int dwarf_cutoff_level = -1;
70 unsigned long dwarf_start_die;
74 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
75 sections. For version 1 package files, each set is stored in SHNDX_POOL
76 as a zero-terminated list of section indexes comprising one set of debug
77 sections from a .dwo file. */
79 static int cu_tu_indexes_read = 0;
80 static unsigned int *shndx_pool = NULL;
81 static unsigned int shndx_pool_size = 0;
82 static unsigned int shndx_pool_used = 0;
84 /* For version 2 package files, each set contains an array of section offsets
85 and an array of section sizes, giving the offset and size of the
86 contribution from a CU or TU within one of the debug sections.
87 When displaying debug info from a package file, we need to use these
88 tables to locate the corresponding contributions to each section. */
93 dwarf_vma section_offsets[DW_SECT_MAX];
94 size_t section_sizes[DW_SECT_MAX];
97 static int cu_count = 0;
98 static int tu_count = 0;
99 static struct cu_tu_set *cu_sets = NULL;
100 static struct cu_tu_set *tu_sets = NULL;
102 static void load_cu_tu_indexes (void *file);
104 /* Values for do_debug_lines. */
105 #define FLAG_DEBUG_LINES_RAW 1
106 #define FLAG_DEBUG_LINES_DECODED 2
109 size_of_encoded_value (int encoding)
111 switch (encoding & 0x7)
114 case 0: return eh_addr_size;
122 get_encoded_value (unsigned char **pdata,
124 struct dwarf_section *section,
127 unsigned char * data = * pdata;
128 unsigned int size = size_of_encoded_value (encoding);
131 if (data + size >= end)
133 warn (_("Encoded value extends past end of section\n"));
138 /* PR 17512: file: 002-829853-0.004. */
141 warn (_("Encoded size of %d is too large to read\n"), size);
146 /* PR 17512: file: 1085-5603-0.004. */
149 warn (_("Encoded size of 0 is too small to read\n"));
154 if (encoding & DW_EH_PE_signed)
155 val = byte_get_signed (data, size);
157 val = byte_get (data, size);
159 if ((encoding & 0x70) == DW_EH_PE_pcrel)
160 val += section->address + (data - section->start);
162 * pdata = data + size;
166 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
168 # define DWARF_VMA_FMT "ll"
169 # define DWARF_VMA_FMT_LONG "%16.16llx"
171 # define DWARF_VMA_FMT "I64"
172 # define DWARF_VMA_FMT_LONG "%016I64x"
175 # define DWARF_VMA_FMT "l"
176 # define DWARF_VMA_FMT_LONG "%16.16lx"
179 /* Convert a dwarf vma value into a string. Returns a pointer to a static
180 buffer containing the converted VALUE. The value is converted according
181 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
182 it specifies the maximum number of bytes to be displayed in the converted
183 value and FMTCH is ignored - hex is always used. */
186 dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)
188 /* As dwarf_vmatoa is used more then once in a printf call
189 for output, we are cycling through an fixed array of pointers
190 for return address. */
191 static int buf_pos = 0;
192 static struct dwarf_vmatoa_buf
198 ret = buf[buf_pos++].place;
199 buf_pos %= ARRAY_SIZE (buf);
203 /* Printf does not have a way of specifiying a maximum field width for an
204 integer value, so we print the full value into a buffer and then select
205 the precision we need. */
206 snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);
209 return ret + (16 - 2 * num_bytes);
215 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
216 snprintf (ret, sizeof (buf[0].place), fmt, value);
221 static inline const char *
222 dwarf_vmatoa (const char * fmtch, dwarf_vma value)
224 return dwarf_vmatoa_1 (fmtch, value, 0);
227 /* Print a dwarf_vma value (typically an address, offset or length) in
228 hexadecimal format, followed by a space. The length of the VALUE (and
229 hence the precision displayed) is determined by the NUM_BYTES parameter. */
232 print_dwarf_vma (dwarf_vma value, unsigned num_bytes)
234 printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));
237 /* Format a 64-bit value, given as two 32-bit values, in hex.
238 For reentrancy, this uses a buffer provided by the caller. */
241 dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
242 unsigned int buf_len)
247 snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
250 len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
251 snprintf (buf + len, buf_len - len,
252 "%08" DWARF_VMA_FMT "x", lvalue);
258 /* Read in a LEB128 encoded value starting at address DATA.
259 If SIGN is true, return a signed LEB128 value.
260 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
261 No bytes will be read at address END or beyond. */
264 read_leb128 (unsigned char *data,
265 unsigned int *length_return,
267 const unsigned char * const end)
269 dwarf_vma result = 0;
270 unsigned int num_read = 0;
271 unsigned int shift = 0;
272 unsigned char byte = 0;
279 result |= ((dwarf_vma) (byte & 0x7f)) << shift;
282 if ((byte & 0x80) == 0)
285 /* PR 17512: file: 0ca183b8.
286 FIXME: Should we signal this error somehow ? */
287 if (shift >= sizeof (result) * 8)
291 if (length_return != NULL)
292 *length_return = num_read;
294 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
295 result |= -((dwarf_vma) 1 << shift);
300 /* Create a signed version to avoid painful typecasts. */
301 static inline dwarf_signed_vma
302 read_sleb128 (unsigned char * data,
303 unsigned int * length_return,
304 const unsigned char * const end)
306 return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
309 static inline dwarf_vma
310 read_uleb128 (unsigned char * data,
311 unsigned int * length_return,
312 const unsigned char * const end)
314 return read_leb128 (data, length_return, FALSE, end);
317 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
320 unsigned int amount = (AMOUNT); \
321 if (sizeof (VAL) < amount) \
323 error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
324 amount, (int) sizeof (VAL)); \
325 amount = sizeof (VAL); \
327 if (((PTR) + amount) >= (END)) \
330 amount = (END) - (PTR); \
334 if (amount == 0 || amount > 8) \
337 VAL = byte_get ((PTR), amount); \
341 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
344 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
349 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
352 unsigned int amount = (AMOUNT); \
353 if (((PTR) + amount) >= (END)) \
356 amount = (END) - (PTR); \
361 VAL = byte_get_signed ((PTR), amount); \
367 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
370 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
375 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
378 if (((PTR) + 8) <= (END)) \
380 byte_get_64 ((PTR), (HIGH), (LOW)); \
384 * (LOW) = * (HIGH) = 0; \
389 typedef struct State_Machine_Registers
397 unsigned char op_index;
398 unsigned char end_sequence;
399 /* This variable hold the number of the last entry seen
400 in the File Table. */
401 unsigned int last_file_entry;
404 static SMR state_machine_regs;
407 reset_state_machine (int is_stmt)
409 state_machine_regs.address = 0;
410 state_machine_regs.op_index = 0;
411 state_machine_regs.file = 1;
412 state_machine_regs.line = 1;
413 state_machine_regs.column = 0;
414 state_machine_regs.is_stmt = is_stmt;
415 state_machine_regs.basic_block = 0;
416 state_machine_regs.end_sequence = 0;
417 state_machine_regs.last_file_entry = 0;
420 /* Handled an extend line op.
421 Returns the number of bytes read. */
424 process_extended_line_op (unsigned char * data,
428 unsigned char op_code;
429 unsigned int bytes_read;
432 unsigned char *orig_data = data;
435 len = read_uleb128 (data, & bytes_read, end);
438 if (len == 0 || data == end || len > (uintptr_t) (end - data))
440 warn (_("Badly formed extended line op encountered!\n"));
447 printf (_(" Extended opcode %d: "), op_code);
451 case DW_LNE_end_sequence:
452 printf (_("End of Sequence\n\n"));
453 reset_state_machine (is_stmt);
456 case DW_LNE_set_address:
457 /* PR 17512: file: 002-100480-0.004. */
458 if (len - bytes_read - 1 > 8)
460 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
461 len - bytes_read - 1);
465 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
466 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
467 state_machine_regs.address = adr;
468 state_machine_regs.op_index = 0;
471 case DW_LNE_define_file:
472 printf (_("define new File Table entry\n"));
473 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
474 printf (" %d\t", ++state_machine_regs.last_file_entry);
477 data += strnlen ((char *) data, end - data) + 1;
478 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
480 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
482 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
484 printf ("%s\n\n", name);
486 if (((unsigned int) (data - orig_data) != len) || data == end)
487 warn (_("DW_LNE_define_file: Bad opcode length\n"));
490 case DW_LNE_set_discriminator:
491 printf (_("set Discriminator to %s\n"),
492 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
496 case DW_LNE_HP_negate_is_UV_update:
497 printf ("DW_LNE_HP_negate_is_UV_update\n");
499 case DW_LNE_HP_push_context:
500 printf ("DW_LNE_HP_push_context\n");
502 case DW_LNE_HP_pop_context:
503 printf ("DW_LNE_HP_pop_context\n");
505 case DW_LNE_HP_set_file_line_column:
506 printf ("DW_LNE_HP_set_file_line_column\n");
508 case DW_LNE_HP_set_routine_name:
509 printf ("DW_LNE_HP_set_routine_name\n");
511 case DW_LNE_HP_set_sequence:
512 printf ("DW_LNE_HP_set_sequence\n");
514 case DW_LNE_HP_negate_post_semantics:
515 printf ("DW_LNE_HP_negate_post_semantics\n");
517 case DW_LNE_HP_negate_function_exit:
518 printf ("DW_LNE_HP_negate_function_exit\n");
520 case DW_LNE_HP_negate_front_end_logical:
521 printf ("DW_LNE_HP_negate_front_end_logical\n");
523 case DW_LNE_HP_define_proc:
524 printf ("DW_LNE_HP_define_proc\n");
526 case DW_LNE_HP_source_file_correlation:
528 unsigned char *edata = data + len - bytes_read - 1;
530 printf ("DW_LNE_HP_source_file_correlation\n");
536 opc = read_uleb128 (data, & bytes_read, edata);
541 case DW_LNE_HP_SFC_formfeed:
542 printf (" DW_LNE_HP_SFC_formfeed\n");
544 case DW_LNE_HP_SFC_set_listing_line:
545 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
547 read_uleb128 (data, & bytes_read, edata)));
550 case DW_LNE_HP_SFC_associate:
551 printf (" DW_LNE_HP_SFC_associate ");
554 read_uleb128 (data, & bytes_read, edata)));
558 read_uleb128 (data, & bytes_read, edata)));
562 read_uleb128 (data, & bytes_read, edata)));
566 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
576 unsigned int rlen = len - bytes_read - 1;
578 if (op_code >= DW_LNE_lo_user
579 /* The test against DW_LNW_hi_user is redundant due to
580 the limited range of the unsigned char data type used
582 /*&& op_code <= DW_LNE_hi_user*/)
583 printf (_("user defined: "));
585 printf (_("UNKNOWN: "));
586 printf (_("length %d ["), rlen);
588 printf (" %02x", *data++);
597 static const unsigned char *
598 fetch_indirect_string (dwarf_vma offset)
600 struct dwarf_section *section = &debug_displays [str].section;
602 if (section->start == NULL)
603 return (const unsigned char *) _("<no .debug_str section>");
605 if (offset > section->size)
607 warn (_("DW_FORM_strp offset too big: %s\n"),
608 dwarf_vmatoa ("x", offset));
609 return (const unsigned char *) _("<offset is too big>");
612 return (const unsigned char *) section->start + offset;
616 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
617 dwarf_vma offset_size, int dwo)
619 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
620 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
621 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
622 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
623 dwarf_vma index_offset = idx * offset_size;
624 dwarf_vma str_offset;
626 if (index_section->start == NULL)
627 return (dwo ? _("<no .debug_str_offsets.dwo section>")
628 : _("<no .debug_str_offsets section>"));
630 if (this_set != NULL)
631 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
632 if (index_offset > index_section->size)
634 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
635 dwarf_vmatoa ("x", index_offset));
636 return _("<index offset is too big>");
639 if (str_section->start == NULL)
640 return (dwo ? _("<no .debug_str.dwo section>")
641 : _("<no .debug_str section>"));
643 str_offset = byte_get (index_section->start + index_offset, offset_size);
644 str_offset -= str_section->address;
645 if (str_offset > str_section->size)
647 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
648 dwarf_vmatoa ("x", str_offset));
649 return _("<indirect index offset is too big>");
652 return (const char *) str_section->start + str_offset;
656 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
658 struct dwarf_section *section = &debug_displays [debug_addr].section;
660 if (section->start == NULL)
661 return (_("<no .debug_addr section>"));
663 if (offset + bytes > section->size)
665 warn (_("Offset into section %s too big: %s\n"),
666 section->name, dwarf_vmatoa ("x", offset));
667 return "<offset too big>";
670 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
674 /* FIXME: There are better and more efficient ways to handle
675 these structures. For now though, I just want something that
676 is simple to implement. */
677 typedef struct abbrev_attr
679 unsigned long attribute;
681 struct abbrev_attr *next;
685 typedef struct abbrev_entry
690 struct abbrev_attr *first_attr;
691 struct abbrev_attr *last_attr;
692 struct abbrev_entry *next;
696 static abbrev_entry *first_abbrev = NULL;
697 static abbrev_entry *last_abbrev = NULL;
704 for (abbrv = first_abbrev; abbrv;)
706 abbrev_entry *next_abbrev = abbrv->next;
709 for (attr = abbrv->first_attr; attr;)
711 abbrev_attr *next_attr = attr->next;
721 last_abbrev = first_abbrev = NULL;
725 add_abbrev (unsigned long number, unsigned long tag, int children)
729 entry = (abbrev_entry *) malloc (sizeof (*entry));
734 entry->entry = number;
736 entry->children = children;
737 entry->first_attr = NULL;
738 entry->last_attr = NULL;
741 if (first_abbrev == NULL)
742 first_abbrev = entry;
744 last_abbrev->next = entry;
750 add_abbrev_attr (unsigned long attribute, unsigned long form)
754 attr = (abbrev_attr *) malloc (sizeof (*attr));
759 attr->attribute = attribute;
763 if (last_abbrev->first_attr == NULL)
764 last_abbrev->first_attr = attr;
766 last_abbrev->last_attr->next = attr;
768 last_abbrev->last_attr = attr;
771 /* Processes the (partial) contents of a .debug_abbrev section.
772 Returns NULL if the end of the section was encountered.
773 Returns the address after the last byte read if the end of
774 an abbreviation set was found. */
776 static unsigned char *
777 process_abbrev_section (unsigned char *start, unsigned char *end)
779 if (first_abbrev != NULL)
784 unsigned int bytes_read;
787 unsigned long attribute;
790 entry = read_uleb128 (start, & bytes_read, end);
793 /* A single zero is supposed to end the section according
794 to the standard. If there's more, then signal that to
801 tag = read_uleb128 (start, & bytes_read, end);
808 add_abbrev (entry, tag, children);
814 attribute = read_uleb128 (start, & bytes_read, end);
819 form = read_uleb128 (start, & bytes_read, end);
824 add_abbrev_attr (attribute, form);
826 while (attribute != 0);
829 /* Report the missing single zero which ends the section. */
830 error (_(".debug_abbrev section not zero terminated\n"));
836 get_TAG_name (unsigned long tag)
838 const char *name = get_DW_TAG_name ((unsigned int)tag);
842 static char buffer[100];
844 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
852 get_FORM_name (unsigned long form)
857 return "DW_FORM value: 0";
859 name = get_DW_FORM_name (form);
862 static char buffer[100];
864 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
871 static unsigned char *
872 display_block (unsigned char *data,
874 const unsigned char * const end)
878 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
880 return (unsigned char *) end;
882 maxlen = (dwarf_vma) (end - data);
883 length = length > maxlen ? maxlen : length;
886 printf ("%lx ", (unsigned long) byte_get (data++, 1));
892 decode_location_expression (unsigned char * data,
893 unsigned int pointer_size,
894 unsigned int offset_size,
898 struct dwarf_section * section)
901 unsigned int bytes_read;
903 dwarf_signed_vma svalue;
904 unsigned char *end = data + length;
905 int need_frame_base = 0;
914 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
915 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
918 printf ("DW_OP_deref");
921 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
922 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
925 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
926 printf ("DW_OP_const1s: %ld", (long) svalue);
929 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
930 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
933 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
934 printf ("DW_OP_const2s: %ld", (long) svalue);
937 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
938 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
941 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
942 printf ("DW_OP_const4s: %ld", (long) svalue);
945 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
946 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
947 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
948 printf ("%lu", (unsigned long) uvalue);
951 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
952 printf ("DW_OP_const8s: %ld ", (long) svalue);
953 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
954 printf ("%ld", (long) svalue);
957 printf ("DW_OP_constu: %s",
958 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
962 printf ("DW_OP_consts: %s",
963 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
967 printf ("DW_OP_dup");
970 printf ("DW_OP_drop");
973 printf ("DW_OP_over");
976 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
977 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
980 printf ("DW_OP_swap");
983 printf ("DW_OP_rot");
986 printf ("DW_OP_xderef");
989 printf ("DW_OP_abs");
992 printf ("DW_OP_and");
995 printf ("DW_OP_div");
998 printf ("DW_OP_minus");
1001 printf ("DW_OP_mod");
1004 printf ("DW_OP_mul");
1007 printf ("DW_OP_neg");
1010 printf ("DW_OP_not");
1013 printf ("DW_OP_or");
1016 printf ("DW_OP_plus");
1018 case DW_OP_plus_uconst:
1019 printf ("DW_OP_plus_uconst: %s",
1020 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1024 printf ("DW_OP_shl");
1027 printf ("DW_OP_shr");
1030 printf ("DW_OP_shra");
1033 printf ("DW_OP_xor");
1036 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1037 printf ("DW_OP_bra: %ld", (long) svalue);
1040 printf ("DW_OP_eq");
1043 printf ("DW_OP_ge");
1046 printf ("DW_OP_gt");
1049 printf ("DW_OP_le");
1052 printf ("DW_OP_lt");
1055 printf ("DW_OP_ne");
1058 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1059 printf ("DW_OP_skip: %ld", (long) svalue);
1094 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1129 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1130 regname (op - DW_OP_reg0, 1));
1165 printf ("DW_OP_breg%d (%s): %s",
1167 regname (op - DW_OP_breg0, 1),
1168 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1173 uvalue = read_uleb128 (data, &bytes_read, end);
1175 printf ("DW_OP_regx: %s (%s)",
1176 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1179 need_frame_base = 1;
1180 printf ("DW_OP_fbreg: %s",
1181 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1185 uvalue = read_uleb128 (data, &bytes_read, end);
1187 printf ("DW_OP_bregx: %s (%s) %s",
1188 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1189 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1193 printf ("DW_OP_piece: %s",
1194 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1197 case DW_OP_deref_size:
1198 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1199 printf ("DW_OP_deref_size: %ld", (long) uvalue);
1201 case DW_OP_xderef_size:
1202 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1203 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1206 printf ("DW_OP_nop");
1209 /* DWARF 3 extensions. */
1210 case DW_OP_push_object_address:
1211 printf ("DW_OP_push_object_address");
1214 /* XXX: Strictly speaking for 64-bit DWARF3 files
1215 this ought to be an 8-byte wide computation. */
1216 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1217 printf ("DW_OP_call2: <0x%s>",
1218 dwarf_vmatoa ("x", svalue + cu_offset));
1221 /* XXX: Strictly speaking for 64-bit DWARF3 files
1222 this ought to be an 8-byte wide computation. */
1223 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1224 printf ("DW_OP_call4: <0x%s>",
1225 dwarf_vmatoa ("x", svalue + cu_offset));
1227 case DW_OP_call_ref:
1228 /* XXX: Strictly speaking for 64-bit DWARF3 files
1229 this ought to be an 8-byte wide computation. */
1230 if (dwarf_version == -1)
1232 printf (_("(DW_OP_call_ref in frame info)"));
1233 /* No way to tell where the next op is, so just bail. */
1234 return need_frame_base;
1236 if (dwarf_version == 2)
1238 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1242 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1244 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1246 case DW_OP_form_tls_address:
1247 printf ("DW_OP_form_tls_address");
1249 case DW_OP_call_frame_cfa:
1250 printf ("DW_OP_call_frame_cfa");
1252 case DW_OP_bit_piece:
1253 printf ("DW_OP_bit_piece: ");
1254 printf (_("size: %s "),
1255 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1257 printf (_("offset: %s "),
1258 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1262 /* DWARF 4 extensions. */
1263 case DW_OP_stack_value:
1264 printf ("DW_OP_stack_value");
1267 case DW_OP_implicit_value:
1268 printf ("DW_OP_implicit_value");
1269 uvalue = read_uleb128 (data, &bytes_read, end);
1271 data = display_block (data, uvalue, end);
1274 /* GNU extensions. */
1275 case DW_OP_GNU_push_tls_address:
1276 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1278 case DW_OP_GNU_uninit:
1279 printf ("DW_OP_GNU_uninit");
1280 /* FIXME: Is there data associated with this OP ? */
1282 case DW_OP_GNU_encoded_addr:
1289 addr = get_encoded_value (&data, encoding, section, end);
1291 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1292 print_dwarf_vma (addr, pointer_size);
1295 case DW_OP_GNU_implicit_pointer:
1296 /* XXX: Strictly speaking for 64-bit DWARF3 files
1297 this ought to be an 8-byte wide computation. */
1298 if (dwarf_version == -1)
1300 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1301 /* No way to tell where the next op is, so just bail. */
1302 return need_frame_base;
1304 if (dwarf_version == 2)
1306 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1310 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1312 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1313 dwarf_vmatoa ("x", uvalue),
1314 dwarf_vmatoa ("d", read_sleb128 (data,
1315 &bytes_read, end)));
1318 case DW_OP_GNU_entry_value:
1319 uvalue = read_uleb128 (data, &bytes_read, end);
1321 /* PR 17531: file: 0cc9cd00. */
1322 if (uvalue > (dwarf_vma) (end - data))
1323 uvalue = end - data;
1324 printf ("DW_OP_GNU_entry_value: (");
1325 if (decode_location_expression (data, pointer_size, offset_size,
1326 dwarf_version, uvalue,
1327 cu_offset, section))
1328 need_frame_base = 1;
1334 case DW_OP_GNU_const_type:
1335 uvalue = read_uleb128 (data, &bytes_read, end);
1337 printf ("DW_OP_GNU_const_type: <0x%s> ",
1338 dwarf_vmatoa ("x", cu_offset + uvalue));
1339 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1340 data = display_block (data, uvalue, end);
1342 case DW_OP_GNU_regval_type:
1343 uvalue = read_uleb128 (data, &bytes_read, end);
1345 printf ("DW_OP_GNU_regval_type: %s (%s)",
1346 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1347 uvalue = read_uleb128 (data, &bytes_read, end);
1349 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1351 case DW_OP_GNU_deref_type:
1352 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1353 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue);
1354 uvalue = read_uleb128 (data, &bytes_read, end);
1356 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1358 case DW_OP_GNU_convert:
1359 uvalue = read_uleb128 (data, &bytes_read, end);
1361 printf ("DW_OP_GNU_convert <0x%s>",
1362 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1364 case DW_OP_GNU_reinterpret:
1365 uvalue = read_uleb128 (data, &bytes_read, end);
1367 printf ("DW_OP_GNU_reinterpret <0x%s>",
1368 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1370 case DW_OP_GNU_parameter_ref:
1371 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1372 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1373 dwarf_vmatoa ("x", cu_offset + uvalue));
1375 case DW_OP_GNU_addr_index:
1376 uvalue = read_uleb128 (data, &bytes_read, end);
1378 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1380 case DW_OP_GNU_const_index:
1381 uvalue = read_uleb128 (data, &bytes_read, end);
1383 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1386 /* HP extensions. */
1387 case DW_OP_HP_is_value:
1388 printf ("DW_OP_HP_is_value");
1389 /* FIXME: Is there data associated with this OP ? */
1391 case DW_OP_HP_fltconst4:
1392 printf ("DW_OP_HP_fltconst4");
1393 /* FIXME: Is there data associated with this OP ? */
1395 case DW_OP_HP_fltconst8:
1396 printf ("DW_OP_HP_fltconst8");
1397 /* FIXME: Is there data associated with this OP ? */
1399 case DW_OP_HP_mod_range:
1400 printf ("DW_OP_HP_mod_range");
1401 /* FIXME: Is there data associated with this OP ? */
1403 case DW_OP_HP_unmod_range:
1404 printf ("DW_OP_HP_unmod_range");
1405 /* FIXME: Is there data associated with this OP ? */
1408 printf ("DW_OP_HP_tls");
1409 /* FIXME: Is there data associated with this OP ? */
1412 /* PGI (STMicroelectronics) extensions. */
1413 case DW_OP_PGI_omp_thread_num:
1414 /* Pushes the thread number for the current thread as it would be
1415 returned by the standard OpenMP library function:
1416 omp_get_thread_num(). The "current thread" is the thread for
1417 which the expression is being evaluated. */
1418 printf ("DW_OP_PGI_omp_thread_num");
1422 if (op >= DW_OP_lo_user
1423 && op <= DW_OP_hi_user)
1424 printf (_("(User defined location op)"));
1426 printf (_("(Unknown location op)"));
1427 /* No way to tell where the next op is, so just bail. */
1428 return need_frame_base;
1431 /* Separate the ops. */
1436 return need_frame_base;
1439 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1440 This is used for DWARF package files. */
1442 static struct cu_tu_set *
1443 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1445 struct cu_tu_set *p;
1447 unsigned int dw_sect;
1453 dw_sect = DW_SECT_TYPES;
1459 dw_sect = DW_SECT_INFO;
1463 if (p->section_offsets [dw_sect] == cu_offset)
1471 /* Add INC to HIGH_BITS:LOW_BITS. */
1473 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1475 dwarf_vma tmp = * low_bits;
1479 /* FIXME: There is probably a better way of handling this:
1481 We need to cope with dwarf_vma being a 32-bit or 64-bit
1482 type. Plus regardless of its size LOW_BITS is meant to
1483 only hold 32-bits, so if there is overflow or wrap around
1484 we must propagate into HIGH_BITS. */
1485 if (tmp < * low_bits)
1489 else if (sizeof (tmp) > 8
1499 static unsigned char *
1500 read_and_display_attr_value (unsigned long attribute,
1502 unsigned char * data,
1503 unsigned char * end,
1504 dwarf_vma cu_offset,
1505 dwarf_vma pointer_size,
1506 dwarf_vma offset_size,
1508 debug_info * debug_info_p,
1510 struct dwarf_section * section,
1511 struct cu_tu_set * this_set)
1513 dwarf_vma uvalue = 0;
1514 unsigned char *block_start = NULL;
1515 unsigned char * orig_data = data;
1516 unsigned int bytes_read;
1518 if (data > end || (data == end && form != DW_FORM_flag_present))
1520 warn (_("Corrupt attribute\n"));
1529 case DW_FORM_ref_addr:
1530 if (dwarf_version == 2)
1531 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1532 else if (dwarf_version == 3 || dwarf_version == 4)
1533 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1535 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1540 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1544 case DW_FORM_sec_offset:
1545 case DW_FORM_GNU_ref_alt:
1546 case DW_FORM_GNU_strp_alt:
1547 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1550 case DW_FORM_flag_present:
1557 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1562 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1567 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1571 uvalue = read_sleb128 (data, & bytes_read, end);
1575 case DW_FORM_GNU_str_index:
1576 uvalue = read_uleb128 (data, & bytes_read, end);
1580 case DW_FORM_ref_udata:
1582 uvalue = read_uleb128 (data, & bytes_read, end);
1586 case DW_FORM_indirect:
1587 form = read_uleb128 (data, & bytes_read, end);
1590 printf (" %s", get_FORM_name (form));
1591 return read_and_display_attr_value (attribute, form, data, end,
1592 cu_offset, pointer_size,
1593 offset_size, dwarf_version,
1594 debug_info_p, do_loc,
1596 case DW_FORM_GNU_addr_index:
1597 uvalue = read_uleb128 (data, & bytes_read, end);
1604 case DW_FORM_ref_addr:
1606 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1609 case DW_FORM_GNU_ref_alt:
1611 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue));
1617 case DW_FORM_ref_udata:
1619 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1624 case DW_FORM_sec_offset:
1626 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1629 case DW_FORM_flag_present:
1636 printf (" %s", dwarf_vmatoa ("d", uvalue));
1643 dwarf_vma high_bits;
1647 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1649 if (form == DW_FORM_ref8)
1650 add64 (& high_bits, & utmp, cu_offset);
1652 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1655 if ((do_loc || do_debug_loc || do_debug_ranges)
1656 && num_debug_info_entries == 0)
1658 if (sizeof (uvalue) == 8)
1659 SAFE_BYTE_GET (uvalue, data, 8, end);
1661 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1667 case DW_FORM_string:
1669 printf (" %.*s", (int) (end - data), data);
1670 data += strnlen ((char *) data, end - data) + 1;
1674 case DW_FORM_exprloc:
1675 uvalue = read_uleb128 (data, & bytes_read, end);
1676 block_start = data + bytes_read;
1677 if (block_start >= end)
1679 warn (_("Block ends prematurely\n"));
1683 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1684 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1685 block_start + uvalue here. */
1686 data = block_start + uvalue;
1687 /* PR 17512: file: 008-103549-0.001:0.1. */
1688 if (block_start + uvalue > end || data < block_start)
1690 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1691 uvalue = end - block_start;
1694 data = block_start + uvalue;
1696 data = display_block (block_start, uvalue, end);
1699 case DW_FORM_block1:
1700 SAFE_BYTE_GET (uvalue, data, 1, end);
1701 block_start = data + 1;
1702 if (block_start >= end)
1704 warn (_("Block ends prematurely\n"));
1708 data = block_start + uvalue;
1709 if (block_start + uvalue > end || data < block_start)
1711 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1712 uvalue = end - block_start;
1715 data = block_start + uvalue;
1717 data = display_block (block_start, uvalue, end);
1720 case DW_FORM_block2:
1721 SAFE_BYTE_GET (uvalue, data, 2, end);
1722 block_start = data + 2;
1723 if (block_start >= end)
1725 warn (_("Block ends prematurely\n"));
1729 data = block_start + uvalue;
1730 if (block_start + uvalue > end || data < block_start)
1732 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1733 uvalue = end - block_start;
1736 data = block_start + uvalue;
1738 data = display_block (block_start, uvalue, end);
1741 case DW_FORM_block4:
1742 SAFE_BYTE_GET (uvalue, data, 4, end);
1743 block_start = data + 4;
1744 /* PR 17512: file: 3371-3907-0.004. */
1745 if (block_start >= end)
1747 warn (_("Block ends prematurely\n"));
1751 data = block_start + uvalue;
1752 if (block_start + uvalue > end
1753 /* PR 17531: file: 5b5f0592. */
1754 || data < block_start)
1756 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1757 uvalue = end - block_start;
1760 data = block_start + uvalue;
1762 data = display_block (block_start, uvalue, end);
1767 printf (_(" (indirect string, offset: 0x%s): %s"),
1768 dwarf_vmatoa ("x", uvalue),
1769 fetch_indirect_string (uvalue));
1772 case DW_FORM_GNU_str_index:
1775 const char *suffix = strrchr (section->name, '.');
1776 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1778 printf (_(" (indexed string: 0x%s): %s"),
1779 dwarf_vmatoa ("x", uvalue),
1780 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1784 case DW_FORM_GNU_strp_alt:
1786 printf (_(" (alt indirect string, offset: 0x%s)"),
1787 dwarf_vmatoa ("x", uvalue));
1790 case DW_FORM_indirect:
1791 /* Handled above. */
1794 case DW_FORM_ref_sig8:
1797 dwarf_vma high_bits;
1800 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1801 printf (" signature: 0x%s",
1802 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
1807 case DW_FORM_GNU_addr_index:
1809 printf (_(" (addr_index: 0x%s): %s"),
1810 dwarf_vmatoa ("x", uvalue),
1811 fetch_indexed_value (uvalue * pointer_size, pointer_size));
1815 warn (_("Unrecognized form: %lu\n"), form);
1819 if ((do_loc || do_debug_loc || do_debug_ranges)
1820 && num_debug_info_entries == 0
1821 && debug_info_p != NULL)
1825 case DW_AT_frame_base:
1826 have_frame_base = 1;
1827 case DW_AT_location:
1828 case DW_AT_string_length:
1829 case DW_AT_return_addr:
1830 case DW_AT_data_member_location:
1831 case DW_AT_vtable_elem_location:
1833 case DW_AT_static_link:
1834 case DW_AT_use_location:
1835 case DW_AT_GNU_call_site_value:
1836 case DW_AT_GNU_call_site_data_value:
1837 case DW_AT_GNU_call_site_target:
1838 case DW_AT_GNU_call_site_target_clobbered:
1839 if ((dwarf_version < 4
1840 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1841 || form == DW_FORM_sec_offset)
1843 /* Process location list. */
1844 unsigned int lmax = debug_info_p->max_loc_offsets;
1845 unsigned int num = debug_info_p->num_loc_offsets;
1847 if (lmax == 0 || num >= lmax)
1850 debug_info_p->loc_offsets = (dwarf_vma *)
1851 xcrealloc (debug_info_p->loc_offsets,
1852 lmax, sizeof (*debug_info_p->loc_offsets));
1853 debug_info_p->have_frame_base = (int *)
1854 xcrealloc (debug_info_p->have_frame_base,
1855 lmax, sizeof (*debug_info_p->have_frame_base));
1856 debug_info_p->max_loc_offsets = lmax;
1858 if (this_set != NULL)
1859 uvalue += this_set->section_offsets [DW_SECT_LOC];
1860 debug_info_p->loc_offsets [num] = uvalue;
1861 debug_info_p->have_frame_base [num] = have_frame_base;
1862 debug_info_p->num_loc_offsets++;
1867 if (need_base_address)
1868 debug_info_p->base_address = uvalue;
1871 case DW_AT_GNU_addr_base:
1872 debug_info_p->addr_base = uvalue;
1875 case DW_AT_GNU_ranges_base:
1876 debug_info_p->ranges_base = uvalue;
1880 if ((dwarf_version < 4
1881 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1882 || form == DW_FORM_sec_offset)
1884 /* Process range list. */
1885 unsigned int lmax = debug_info_p->max_range_lists;
1886 unsigned int num = debug_info_p->num_range_lists;
1888 if (lmax == 0 || num >= lmax)
1891 debug_info_p->range_lists = (dwarf_vma *)
1892 xcrealloc (debug_info_p->range_lists,
1893 lmax, sizeof (*debug_info_p->range_lists));
1894 debug_info_p->max_range_lists = lmax;
1896 debug_info_p->range_lists [num] = uvalue;
1897 debug_info_p->num_range_lists++;
1906 if (do_loc || attribute == 0)
1909 /* For some attributes we can display further information. */
1916 case DW_INL_not_inlined:
1917 printf (_("(not inlined)"));
1919 case DW_INL_inlined:
1920 printf (_("(inlined)"));
1922 case DW_INL_declared_not_inlined:
1923 printf (_("(declared as inline but ignored)"));
1925 case DW_INL_declared_inlined:
1926 printf (_("(declared as inline and inlined)"));
1929 printf (_(" (Unknown inline attribute value: %s)"),
1930 dwarf_vmatoa ("x", uvalue));
1935 case DW_AT_language:
1939 /* Ordered by the numeric value of these constants. */
1940 case DW_LANG_C89: printf ("(ANSI C)"); break;
1941 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1942 case DW_LANG_Ada83: printf ("(Ada)"); break;
1943 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1944 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1945 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1946 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1947 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1948 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1949 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1950 /* DWARF 2.1 values. */
1951 case DW_LANG_Java: printf ("(Java)"); break;
1952 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1953 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1954 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1955 /* DWARF 3 values. */
1956 case DW_LANG_PLI: printf ("(PLI)"); break;
1957 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1958 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1959 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1960 case DW_LANG_D: printf ("(D)"); break;
1961 /* DWARF 4 values. */
1962 case DW_LANG_Python: printf ("(Python)"); break;
1963 /* DWARF 5 values. */
1964 case DW_LANG_Go: printf ("(Go)"); break;
1965 case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break;
1966 case DW_LANG_C11: printf ("(C11)"); break;
1967 case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break;
1968 case DW_LANG_Fortran03: printf ("(Fortran 03)"); break;
1969 case DW_LANG_Fortran08: printf ("(Fortran 08)"); break;
1970 /* MIPS extension. */
1971 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1972 /* UPC extension. */
1973 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1975 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1976 printf (_("(implementation defined: %s)"),
1977 dwarf_vmatoa ("x", uvalue));
1979 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
1984 case DW_AT_encoding:
1988 case DW_ATE_void: printf ("(void)"); break;
1989 case DW_ATE_address: printf ("(machine address)"); break;
1990 case DW_ATE_boolean: printf ("(boolean)"); break;
1991 case DW_ATE_complex_float: printf ("(complex float)"); break;
1992 case DW_ATE_float: printf ("(float)"); break;
1993 case DW_ATE_signed: printf ("(signed)"); break;
1994 case DW_ATE_signed_char: printf ("(signed char)"); break;
1995 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1996 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1997 /* DWARF 2.1 values: */
1998 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1999 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
2000 /* DWARF 3 values: */
2001 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
2002 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
2003 case DW_ATE_edited: printf ("(edited)"); break;
2004 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
2005 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
2006 /* HP extensions: */
2007 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
2008 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
2009 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
2010 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
2011 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
2012 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
2013 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
2014 /* DWARF 4 values: */
2015 case DW_ATE_UTF: printf ("(unicode string)"); break;
2018 if (uvalue >= DW_ATE_lo_user
2019 && uvalue <= DW_ATE_hi_user)
2020 printf (_("(user defined type)"));
2022 printf (_("(unknown type)"));
2027 case DW_AT_accessibility:
2031 case DW_ACCESS_public: printf ("(public)"); break;
2032 case DW_ACCESS_protected: printf ("(protected)"); break;
2033 case DW_ACCESS_private: printf ("(private)"); break;
2035 printf (_("(unknown accessibility)"));
2040 case DW_AT_visibility:
2044 case DW_VIS_local: printf ("(local)"); break;
2045 case DW_VIS_exported: printf ("(exported)"); break;
2046 case DW_VIS_qualified: printf ("(qualified)"); break;
2047 default: printf (_("(unknown visibility)")); break;
2051 case DW_AT_virtuality:
2055 case DW_VIRTUALITY_none: printf ("(none)"); break;
2056 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2057 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2058 default: printf (_("(unknown virtuality)")); break;
2062 case DW_AT_identifier_case:
2066 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2067 case DW_ID_up_case: printf ("(up_case)"); break;
2068 case DW_ID_down_case: printf ("(down_case)"); break;
2069 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
2070 default: printf (_("(unknown case)")); break;
2074 case DW_AT_calling_convention:
2078 case DW_CC_normal: printf ("(normal)"); break;
2079 case DW_CC_program: printf ("(program)"); break;
2080 case DW_CC_nocall: printf ("(nocall)"); break;
2082 if (uvalue >= DW_CC_lo_user
2083 && uvalue <= DW_CC_hi_user)
2084 printf (_("(user defined)"));
2086 printf (_("(unknown convention)"));
2090 case DW_AT_ordering:
2094 case -1: printf (_("(undefined)")); break;
2095 case 0: printf ("(row major)"); break;
2096 case 1: printf ("(column major)"); break;
2100 case DW_AT_frame_base:
2101 have_frame_base = 1;
2102 case DW_AT_location:
2103 case DW_AT_string_length:
2104 case DW_AT_return_addr:
2105 case DW_AT_data_member_location:
2106 case DW_AT_vtable_elem_location:
2108 case DW_AT_static_link:
2109 case DW_AT_use_location:
2110 case DW_AT_GNU_call_site_value:
2111 case DW_AT_GNU_call_site_data_value:
2112 case DW_AT_GNU_call_site_target:
2113 case DW_AT_GNU_call_site_target_clobbered:
2114 if ((dwarf_version < 4
2115 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2116 || form == DW_FORM_sec_offset)
2117 printf (_(" (location list)"));
2119 case DW_AT_allocated:
2120 case DW_AT_associated:
2121 case DW_AT_data_location:
2123 case DW_AT_upper_bound:
2124 case DW_AT_lower_bound:
2127 int need_frame_base;
2130 need_frame_base = decode_location_expression (block_start,
2135 cu_offset, section);
2137 if (need_frame_base && !have_frame_base)
2138 printf (_(" [without DW_AT_frame_base]"));
2144 if (form == DW_FORM_ref_sig8
2145 || form == DW_FORM_GNU_ref_alt)
2148 if (form == DW_FORM_ref1
2149 || form == DW_FORM_ref2
2150 || form == DW_FORM_ref4
2151 || form == DW_FORM_ref_udata)
2152 uvalue += cu_offset;
2154 if (uvalue >= section->size)
2155 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2156 dwarf_vmatoa ("x", uvalue),
2157 (unsigned long) (orig_data - section->start));
2160 unsigned long abbrev_number;
2161 abbrev_entry * entry;
2163 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2165 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2166 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2167 use different abbrev table, and we don't track .debug_info chunks
2169 if (form != DW_FORM_ref_addr)
2171 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2172 if (entry->entry == abbrev_number)
2175 printf (" (%s)", get_TAG_name (entry->tag));
2190 get_AT_name (unsigned long attribute)
2195 return "DW_AT value: 0";
2197 /* One value is shared by the MIPS and HP extensions: */
2198 if (attribute == DW_AT_MIPS_fde)
2199 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2201 name = get_DW_AT_name (attribute);
2205 static char buffer[100];
2207 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2215 static unsigned char *
2216 read_and_display_attr (unsigned long attribute,
2218 unsigned char * data,
2219 unsigned char * end,
2220 dwarf_vma cu_offset,
2221 dwarf_vma pointer_size,
2222 dwarf_vma offset_size,
2224 debug_info * debug_info_p,
2226 struct dwarf_section * section,
2227 struct cu_tu_set * this_set)
2230 printf (" %-18s:", get_AT_name (attribute));
2231 data = read_and_display_attr_value (attribute, form, data, end,
2232 cu_offset, pointer_size, offset_size,
2233 dwarf_version, debug_info_p,
2234 do_loc, section, this_set);
2240 /* Process the contents of a .debug_info section. If do_loc is non-zero
2241 then we are scanning for location lists and we do not want to display
2242 anything to the user. If do_types is non-zero, we are processing
2243 a .debug_types section instead of a .debug_info section. */
2246 process_debug_info (struct dwarf_section *section,
2248 enum dwarf_section_display_enum abbrev_sec,
2252 unsigned char *start = section->start;
2253 unsigned char *end = start + section->size;
2254 unsigned char *section_begin;
2256 unsigned int num_units = 0;
2258 if ((do_loc || do_debug_loc || do_debug_ranges)
2259 && num_debug_info_entries == 0
2264 /* First scan the section to get the number of comp units. */
2265 for (section_begin = start, num_units = 0; section_begin < end;
2268 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2269 will be the length. For a 64-bit DWARF section, it'll be
2270 the escape code 0xffffffff followed by an 8 byte length. */
2271 SAFE_BYTE_GET (length, section_begin, 4, end);
2273 if (length == 0xffffffff)
2275 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2276 section_begin += length + 12;
2278 else if (length >= 0xfffffff0 && length < 0xffffffff)
2280 warn (_("Reserved length value (0x%s) found in section %s\n"),
2281 dwarf_vmatoa ("x", length), section->name);
2285 section_begin += length + 4;
2287 /* Negative values are illegal, they may even cause infinite
2288 looping. This can happen if we can't accurately apply
2289 relocations to an object file, or if the file is corrupt. */
2290 if ((signed long) length <= 0 || section_begin < start)
2292 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2293 dwarf_vmatoa ("x", length), section->name);
2300 error (_("No comp units in %s section ?\n"), section->name);
2304 /* Then allocate an array to hold the information. */
2305 debug_information = (debug_info *) cmalloc (num_units,
2306 sizeof (* debug_information));
2307 if (debug_information == NULL)
2309 error (_("Not enough memory for a debug info array of %u entries\n"),
2311 alloc_num_debug_info_entries = num_debug_info_entries = 0;
2314 /* PR 17531: file: 92ca3797.
2315 We cannot rely upon the debug_information array being initialised
2316 before it is used. A corrupt file could easily contain references
2317 to a unit for which information has not been made available. So
2318 we ensure that the array is zeroed here. */
2319 memset (debug_information, 0, num_units * sizeof (*debug_information));
2321 alloc_num_debug_info_entries = num_units;
2326 if (dwarf_start_die == 0)
2327 printf (_("Contents of the %s section:\n\n"), section->name);
2329 load_debug_section (str, file);
2330 load_debug_section (str_dwo, file);
2331 load_debug_section (str_index, file);
2332 load_debug_section (str_index_dwo, file);
2333 load_debug_section (debug_addr, file);
2336 load_debug_section (abbrev_sec, file);
2337 if (debug_displays [abbrev_sec].section.start == NULL)
2339 warn (_("Unable to locate %s section!\n"),
2340 debug_displays [abbrev_sec].section.name);
2344 for (section_begin = start, unit = 0; start < end; unit++)
2346 DWARF2_Internal_CompUnit compunit;
2347 unsigned char *hdrptr;
2348 unsigned char *tags;
2349 int level, last_level, saved_level;
2350 dwarf_vma cu_offset;
2351 unsigned int offset_size;
2352 int initial_length_size;
2353 dwarf_vma signature_high = 0;
2354 dwarf_vma signature_low = 0;
2355 dwarf_vma type_offset = 0;
2356 struct cu_tu_set *this_set;
2357 dwarf_vma abbrev_base;
2362 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2364 if (compunit.cu_length == 0xffffffff)
2366 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2368 initial_length_size = 12;
2373 initial_length_size = 4;
2376 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2378 cu_offset = start - section_begin;
2380 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2382 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2384 if (this_set == NULL)
2387 abbrev_size = debug_displays [abbrev_sec].section.size;
2391 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2392 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2395 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2396 /* PR 17512: file: 001-108546-0.001:0.1. */
2397 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2399 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2400 compunit.cu_pointer_size, offset_size);
2401 compunit.cu_pointer_size = offset_size;
2406 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2408 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2411 if ((do_loc || do_debug_loc || do_debug_ranges)
2412 && num_debug_info_entries == 0
2415 debug_information [unit].cu_offset = cu_offset;
2416 debug_information [unit].pointer_size
2417 = compunit.cu_pointer_size;
2418 debug_information [unit].offset_size = offset_size;
2419 debug_information [unit].dwarf_version = compunit.cu_version;
2420 debug_information [unit].base_address = 0;
2421 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2422 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2423 debug_information [unit].loc_offsets = NULL;
2424 debug_information [unit].have_frame_base = NULL;
2425 debug_information [unit].max_loc_offsets = 0;
2426 debug_information [unit].num_loc_offsets = 0;
2427 debug_information [unit].range_lists = NULL;
2428 debug_information [unit].max_range_lists= 0;
2429 debug_information [unit].num_range_lists = 0;
2432 if (!do_loc && dwarf_start_die == 0)
2434 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2435 dwarf_vmatoa ("x", cu_offset));
2436 printf (_(" Length: 0x%s (%s)\n"),
2437 dwarf_vmatoa ("x", compunit.cu_length),
2438 offset_size == 8 ? "64-bit" : "32-bit");
2439 printf (_(" Version: %d\n"), compunit.cu_version);
2440 printf (_(" Abbrev Offset: 0x%s\n"),
2441 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2442 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2447 printf (_(" Signature: 0x%s\n"),
2448 dwarf_vmatoa64 (signature_high, signature_low,
2449 buf, sizeof (buf)));
2450 printf (_(" Type Offset: 0x%s\n"),
2451 dwarf_vmatoa ("x", type_offset));
2453 if (this_set != NULL)
2455 dwarf_vma *offsets = this_set->section_offsets;
2456 size_t *sizes = this_set->section_sizes;
2458 printf (_(" Section contributions:\n"));
2459 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2460 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2461 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2462 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2463 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2464 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2465 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2466 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2467 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2468 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2469 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2470 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2474 if (cu_offset + compunit.cu_length + initial_length_size
2477 warn (_("Debug info is corrupted, length of CU at %s"
2478 " extends beyond end of section (length = %s)\n"),
2479 dwarf_vmatoa ("x", cu_offset),
2480 dwarf_vmatoa ("x", compunit.cu_length));
2485 start += compunit.cu_length + initial_length_size;
2489 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2490 dwarf_vmatoa ("x", cu_offset));
2494 if (compunit.cu_version != 2
2495 && compunit.cu_version != 3
2496 && compunit.cu_version != 4)
2498 warn (_("CU at offset %s contains corrupt or "
2499 "unsupported version number: %d.\n"),
2500 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2506 /* Process the abbrevs used by this compilation unit. */
2507 if (compunit.cu_abbrev_offset >= abbrev_size)
2508 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2509 (unsigned long) compunit.cu_abbrev_offset,
2510 (unsigned long) abbrev_size);
2511 /* PR 17531: file:4bcd9ce9. */
2512 else if ((abbrev_base + abbrev_size)
2513 > debug_displays [abbrev_sec].section.size)
2514 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2515 (unsigned long) abbrev_base + abbrev_size,
2516 (unsigned long) debug_displays [abbrev_sec].section.size);
2518 process_abbrev_section
2519 (((unsigned char *) debug_displays [abbrev_sec].section.start
2520 + abbrev_base + compunit.cu_abbrev_offset),
2521 ((unsigned char *) debug_displays [abbrev_sec].section.start
2522 + abbrev_base + abbrev_size));
2527 while (tags < start)
2529 unsigned int bytes_read;
2530 unsigned long abbrev_number;
2531 unsigned long die_offset;
2532 abbrev_entry *entry;
2534 int do_printing = 1;
2536 die_offset = tags - section_begin;
2538 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2541 /* A null DIE marks the end of a list of siblings or it may also be
2542 a section padding. */
2543 if (abbrev_number == 0)
2545 /* Check if it can be a section padding for the last CU. */
2546 if (level == 0 && start == end)
2550 for (chk = tags; chk < start; chk++)
2557 if (!do_loc && die_offset >= dwarf_start_die
2558 && (dwarf_cutoff_level == -1
2559 || level < dwarf_cutoff_level))
2560 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2566 static unsigned num_bogus_warns = 0;
2568 if (num_bogus_warns < 3)
2570 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2571 die_offset, section->name);
2573 if (num_bogus_warns == 3)
2574 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2577 if (dwarf_start_die != 0 && level < saved_level)
2584 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2588 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2589 saved_level = level;
2590 do_printing = (dwarf_cutoff_level == -1
2591 || level < dwarf_cutoff_level);
2593 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2594 level, die_offset, abbrev_number);
2595 else if (dwarf_cutoff_level == -1
2596 || last_level < dwarf_cutoff_level)
2597 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2602 /* Scan through the abbreviation list until we reach the
2604 for (entry = first_abbrev;
2605 entry && entry->entry != abbrev_number;
2606 entry = entry->next)
2611 if (!do_loc && do_printing)
2616 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2617 die_offset, abbrev_number);
2621 if (!do_loc && do_printing)
2622 printf (" (%s)\n", get_TAG_name (entry->tag));
2627 need_base_address = 0;
2629 case DW_TAG_compile_unit:
2630 need_base_address = 1;
2632 case DW_TAG_entry_point:
2633 case DW_TAG_subprogram:
2634 need_base_address = 0;
2635 /* Assuming that there is no DW_AT_frame_base. */
2636 have_frame_base = 0;
2640 for (attr = entry->first_attr;
2641 attr && attr->attribute;
2646 if (! do_loc && do_printing)
2647 /* Show the offset from where the tag was extracted. */
2648 printf (" <%lx>", (unsigned long)(tags - section_begin));
2650 if (debug_information && unit < alloc_num_debug_info_entries)
2651 arg = debug_information + unit;
2655 tags = read_and_display_attr (attr->attribute,
2660 compunit.cu_pointer_size,
2662 compunit.cu_version,
2664 do_loc || ! do_printing,
2669 if (entry->children)
2674 /* Set num_debug_info_entries here so that it can be used to check if
2675 we need to process .debug_loc and .debug_ranges sections. */
2676 if ((do_loc || do_debug_loc || do_debug_ranges)
2677 && num_debug_info_entries == 0
2680 if (num_units > alloc_num_debug_info_entries)
2681 num_debug_info_entries = alloc_num_debug_info_entries;
2683 num_debug_info_entries = num_units;
2692 /* Locate and scan the .debug_info section in the file and record the pointer
2693 sizes and offsets for the compilation units in it. Usually an executable
2694 will have just one pointer size, but this is not guaranteed, and so we try
2695 not to make any assumptions. Returns zero upon failure, or the number of
2696 compilation units upon success. */
2699 load_debug_info (void * file)
2701 /* Reset the last pointer size so that we can issue correct error
2702 messages if we are displaying the contents of more than one section. */
2703 last_pointer_size = 0;
2704 warned_about_missing_comp_units = FALSE;
2706 /* If we have already tried and failed to load the .debug_info
2707 section then do not bother to repeat the task. */
2708 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2711 /* If we already have the information there is nothing else to do. */
2712 if (num_debug_info_entries > 0)
2713 return num_debug_info_entries;
2715 /* If this is a DWARF package file, load the CU and TU indexes. */
2716 load_cu_tu_indexes (file);
2718 if (load_debug_section (info, file)
2719 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2720 return num_debug_info_entries;
2722 if (load_debug_section (info_dwo, file)
2723 && process_debug_info (&debug_displays [info_dwo].section, file,
2725 return num_debug_info_entries;
2727 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2731 /* Read a DWARF .debug_line section header starting at DATA.
2732 Upon success returns an updated DATA pointer and the LINFO
2733 structure and the END_OF_SEQUENCE pointer will be filled in.
2734 Otherwise returns NULL. */
2736 static unsigned char *
2737 read_debug_line_header (struct dwarf_section * section,
2738 unsigned char * data,
2739 unsigned char * end,
2740 DWARF2_Internal_LineInfo * linfo,
2741 unsigned char ** end_of_sequence)
2743 unsigned char *hdrptr;
2744 unsigned int offset_size;
2745 unsigned int initial_length_size;
2747 /* Extract information from the Line Number Program Header.
2748 (section 6.2.4 in the Dwarf3 doc). */
2751 /* Get and check the length of the block. */
2752 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2754 if (linfo->li_length == 0xffffffff)
2756 /* This section is 64-bit DWARF 3. */
2757 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2759 initial_length_size = 12;
2764 initial_length_size = 4;
2767 if (linfo->li_length + initial_length_size > section->size)
2769 /* If the length field has a relocation against it, then we should
2770 not complain if it is inaccurate (and probably negative). This
2771 happens in object files when the .debug_line section is actually
2772 comprised of several different .debug_line.* sections, (some of
2773 which may be removed by linker garbage collection), and a relocation
2774 is used to compute the correct length once that is done. */
2775 if (reloc_at (section, (hdrptr - section->start) - offset_size))
2777 linfo->li_length = (end - data) - initial_length_size;
2781 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
2782 (long) linfo->li_length);
2787 /* Get and check the version number. */
2788 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2790 if (linfo->li_version != 2
2791 && linfo->li_version != 3
2792 && linfo->li_version != 4)
2794 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2798 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2799 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2801 if (linfo->li_version >= 4)
2803 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2805 if (linfo->li_max_ops_per_insn == 0)
2807 warn (_("Invalid maximum operations per insn.\n"));
2812 linfo->li_max_ops_per_insn = 1;
2814 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2815 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2816 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2817 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2819 * end_of_sequence = data + linfo->li_length + initial_length_size;
2820 /* PR 17512: file:002-117414-0.004. */
2821 if (* end_of_sequence > end)
2823 warn (_("Line length %s extends beyond end of section\n"),
2824 dwarf_vmatoa ("u", linfo->li_length));
2825 * end_of_sequence = end;
2833 display_debug_lines_raw (struct dwarf_section *section,
2834 unsigned char *data,
2837 unsigned char *start = section->start;
2839 printf (_("Raw dump of debug contents of section %s:\n\n"),
2844 static DWARF2_Internal_LineInfo saved_linfo;
2845 DWARF2_Internal_LineInfo linfo;
2846 unsigned char *standard_opcodes;
2847 unsigned char *end_of_sequence;
2848 unsigned int last_dir_entry = 0;
2851 if (const_strneq (section->name, ".debug_line.")
2852 /* Note: the following does not apply to .debug_line.dwo sections.
2853 These are full debug_line sections. */
2854 && strcmp (section->name, ".debug_line.dwo") != 0)
2856 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2857 section containing just the Line Number Statements. They are
2858 created by the assembler and intended to be used alongside gcc's
2859 -ffunction-sections command line option. When the linker's
2860 garbage collection decides to discard a .text.<foo> section it
2861 can then also discard the line number information in .debug_line.<foo>.
2863 Since the section is a fragment it does not have the details
2864 needed to fill out a LineInfo structure, so instead we use the
2865 details from the last full debug_line section that we processed. */
2866 end_of_sequence = end;
2867 standard_opcodes = NULL;
2868 linfo = saved_linfo;
2869 /* PR 17531: file: 0522b371. */
2870 if (linfo.li_line_range == 0)
2872 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2875 reset_state_machine (linfo.li_default_is_stmt);
2879 unsigned char * hdrptr;
2881 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2882 & end_of_sequence)) == NULL)
2885 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
2886 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2887 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2888 printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length);
2889 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2890 if (linfo.li_version >= 4)
2891 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2892 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2893 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2894 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2895 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2897 /* PR 17512: file: 1665-6428-0.004. */
2898 if (linfo.li_line_range == 0)
2900 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2901 linfo.li_line_range = 1;
2904 reset_state_machine (linfo.li_default_is_stmt);
2906 /* Display the contents of the Opcodes table. */
2907 standard_opcodes = hdrptr;
2909 /* PR 17512: file: 002-417945-0.004. */
2910 if (standard_opcodes + linfo.li_opcode_base >= end)
2912 warn (_("Line Base extends beyond end of section\n"));
2916 printf (_("\n Opcodes:\n"));
2918 for (i = 1; i < linfo.li_opcode_base; i++)
2919 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2921 /* Display the contents of the Directory table. */
2922 data = standard_opcodes + linfo.li_opcode_base - 1;
2925 printf (_("\n The Directory Table is empty.\n"));
2928 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2929 (long)(data - start));
2931 while (data < end && *data != 0)
2933 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2935 data += strnlen ((char *) data, end - data) + 1;
2938 /* PR 17512: file: 002-132094-0.004. */
2939 if (data >= end - 1)
2943 /* Skip the NUL at the end of the table. */
2946 /* Display the contents of the File Name table. */
2948 printf (_("\n The File Name Table is empty.\n"));
2951 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2952 (long)(data - start));
2953 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2955 while (data < end && *data != 0)
2957 unsigned char *name;
2958 unsigned int bytes_read;
2960 printf (" %d\t", ++state_machine_regs.last_file_entry);
2962 data += strnlen ((char *) data, end - data) + 1;
2965 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2968 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2971 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2973 printf ("%.*s\n", (int)(end - name), name);
2977 warn (_("Corrupt file name table entry\n"));
2983 /* Skip the NUL at the end of the table. */
2986 saved_linfo = linfo;
2989 /* Now display the statements. */
2990 if (data >= end_of_sequence)
2991 printf (_(" No Line Number Statements.\n"));
2994 printf (_(" Line Number Statements:\n"));
2996 while (data < end_of_sequence)
2998 unsigned char op_code;
2999 dwarf_signed_vma adv;
3001 unsigned int bytes_read;
3003 printf (" [0x%08lx]", (long)(data - start));
3007 if (op_code >= linfo.li_opcode_base)
3009 op_code -= linfo.li_opcode_base;
3010 uladv = (op_code / linfo.li_line_range);
3011 if (linfo.li_max_ops_per_insn == 1)
3013 uladv *= linfo.li_min_insn_length;
3014 state_machine_regs.address += uladv;
3015 printf (_(" Special opcode %d: "
3016 "advance Address by %s to 0x%s"),
3017 op_code, dwarf_vmatoa ("u", uladv),
3018 dwarf_vmatoa ("x", state_machine_regs.address));
3022 state_machine_regs.address
3023 += ((state_machine_regs.op_index + uladv)
3024 / linfo.li_max_ops_per_insn)
3025 * linfo.li_min_insn_length;
3026 state_machine_regs.op_index
3027 = (state_machine_regs.op_index + uladv)
3028 % linfo.li_max_ops_per_insn;
3029 printf (_(" Special opcode %d: "
3030 "advance Address by %s to 0x%s[%d]"),
3031 op_code, dwarf_vmatoa ("u", uladv),
3032 dwarf_vmatoa ("x", state_machine_regs.address),
3033 state_machine_regs.op_index);
3035 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3036 state_machine_regs.line += adv;
3037 printf (_(" and Line by %s to %d\n"),
3038 dwarf_vmatoa ("d", adv), state_machine_regs.line);
3040 else switch (op_code)
3042 case DW_LNS_extended_op:
3043 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3047 printf (_(" Copy\n"));
3050 case DW_LNS_advance_pc:
3051 uladv = read_uleb128 (data, & bytes_read, end);
3053 if (linfo.li_max_ops_per_insn == 1)
3055 uladv *= linfo.li_min_insn_length;
3056 state_machine_regs.address += uladv;
3057 printf (_(" Advance PC by %s to 0x%s\n"),
3058 dwarf_vmatoa ("u", uladv),
3059 dwarf_vmatoa ("x", state_machine_regs.address));
3063 state_machine_regs.address
3064 += ((state_machine_regs.op_index + uladv)
3065 / linfo.li_max_ops_per_insn)
3066 * linfo.li_min_insn_length;
3067 state_machine_regs.op_index
3068 = (state_machine_regs.op_index + uladv)
3069 % linfo.li_max_ops_per_insn;
3070 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3071 dwarf_vmatoa ("u", uladv),
3072 dwarf_vmatoa ("x", state_machine_regs.address),
3073 state_machine_regs.op_index);
3077 case DW_LNS_advance_line:
3078 adv = read_sleb128 (data, & bytes_read, end);
3080 state_machine_regs.line += adv;
3081 printf (_(" Advance Line by %s to %d\n"),
3082 dwarf_vmatoa ("d", adv),
3083 state_machine_regs.line);
3086 case DW_LNS_set_file:
3087 adv = read_uleb128 (data, & bytes_read, end);
3089 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3090 dwarf_vmatoa ("d", adv));
3091 state_machine_regs.file = adv;
3094 case DW_LNS_set_column:
3095 uladv = read_uleb128 (data, & bytes_read, end);
3097 printf (_(" Set column to %s\n"),
3098 dwarf_vmatoa ("u", uladv));
3099 state_machine_regs.column = uladv;
3102 case DW_LNS_negate_stmt:
3103 adv = state_machine_regs.is_stmt;
3105 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3106 state_machine_regs.is_stmt = adv;
3109 case DW_LNS_set_basic_block:
3110 printf (_(" Set basic block\n"));
3111 state_machine_regs.basic_block = 1;
3114 case DW_LNS_const_add_pc:
3115 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3116 if (linfo.li_max_ops_per_insn)
3118 uladv *= linfo.li_min_insn_length;
3119 state_machine_regs.address += uladv;
3120 printf (_(" Advance PC by constant %s to 0x%s\n"),
3121 dwarf_vmatoa ("u", uladv),
3122 dwarf_vmatoa ("x", state_machine_regs.address));
3126 state_machine_regs.address
3127 += ((state_machine_regs.op_index + uladv)
3128 / linfo.li_max_ops_per_insn)
3129 * linfo.li_min_insn_length;
3130 state_machine_regs.op_index
3131 = (state_machine_regs.op_index + uladv)
3132 % linfo.li_max_ops_per_insn;
3133 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3134 dwarf_vmatoa ("u", uladv),
3135 dwarf_vmatoa ("x", state_machine_regs.address),
3136 state_machine_regs.op_index);
3140 case DW_LNS_fixed_advance_pc:
3141 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3142 state_machine_regs.address += uladv;
3143 state_machine_regs.op_index = 0;
3144 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3145 dwarf_vmatoa ("u", uladv),
3146 dwarf_vmatoa ("x", state_machine_regs.address));
3149 case DW_LNS_set_prologue_end:
3150 printf (_(" Set prologue_end to true\n"));
3153 case DW_LNS_set_epilogue_begin:
3154 printf (_(" Set epilogue_begin to true\n"));
3157 case DW_LNS_set_isa:
3158 uladv = read_uleb128 (data, & bytes_read, end);
3160 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3164 printf (_(" Unknown opcode %d with operands: "), op_code);
3166 if (standard_opcodes != NULL)
3167 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3169 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3171 i == 1 ? "" : ", ");
3187 unsigned char *name;
3188 unsigned int directory_index;
3189 unsigned int modification_date;
3190 unsigned int length;
3193 /* Output a decoded representation of the .debug_line section. */
3196 display_debug_lines_decoded (struct dwarf_section *section,
3197 unsigned char *data,
3200 static DWARF2_Internal_LineInfo saved_linfo;
3202 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3207 /* This loop amounts to one iteration per compilation unit. */
3208 DWARF2_Internal_LineInfo linfo;
3209 unsigned char *standard_opcodes;
3210 unsigned char *end_of_sequence;
3212 File_Entry *file_table = NULL;
3213 unsigned int n_files = 0;
3214 unsigned char **directory_table = NULL;
3215 unsigned int n_directories = 0;
3217 if (const_strneq (section->name, ".debug_line.")
3218 /* Note: the following does not apply to .debug_line.dwo sections.
3219 These are full debug_line sections. */
3220 && strcmp (section->name, ".debug_line.dwo") != 0)
3222 /* See comment in display_debug_lines_raw(). */
3223 end_of_sequence = end;
3224 standard_opcodes = NULL;
3225 linfo = saved_linfo;
3226 /* PR 17531: file: 0522b371. */
3227 if (linfo.li_line_range == 0)
3229 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3232 reset_state_machine (linfo.li_default_is_stmt);
3236 unsigned char *hdrptr;
3238 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3239 & end_of_sequence)) == NULL)
3242 /* PR 17531: file: 0522b371. */
3243 if (linfo.li_line_range == 0)
3245 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3246 linfo.li_line_range = 1;
3248 reset_state_machine (linfo.li_default_is_stmt);
3250 /* Save a pointer to the contents of the Opcodes table. */
3251 standard_opcodes = hdrptr;
3253 /* Traverse the Directory table just to count entries. */
3254 data = standard_opcodes + linfo.li_opcode_base - 1;
3257 unsigned char *ptr_directory_table = data;
3261 data += strnlen ((char *) data, end - data) + 1;
3265 /* Go through the directory table again to save the directories. */
3266 directory_table = (unsigned char **)
3267 xmalloc (n_directories * sizeof (unsigned char *));
3270 while (*ptr_directory_table != 0)
3272 directory_table[i] = ptr_directory_table;
3273 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3274 ptr_directory_table - end) + 1;
3278 /* Skip the NUL at the end of the table. */
3281 /* Traverse the File Name table just to count the entries. */
3284 unsigned char *ptr_file_name_table = data;
3288 unsigned int bytes_read;
3290 /* Skip Name, directory index, last modification time and length
3292 data += strnlen ((char *) data, end - data) + 1;
3293 read_uleb128 (data, & bytes_read, end);
3295 read_uleb128 (data, & bytes_read, end);
3297 read_uleb128 (data, & bytes_read, end);
3303 /* Go through the file table again to save the strings. */
3304 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3307 while (*ptr_file_name_table != 0)
3309 unsigned int bytes_read;
3311 file_table[i].name = ptr_file_name_table;
3312 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3313 end - ptr_file_name_table) + 1;
3315 /* We are not interested in directory, time or size. */
3316 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3318 ptr_file_name_table += bytes_read;
3319 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3321 ptr_file_name_table += bytes_read;
3322 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3323 ptr_file_name_table += bytes_read;
3328 /* Print the Compilation Unit's name and a header. */
3329 if (directory_table == NULL)
3331 printf (_("CU: %s:\n"), file_table[0].name);
3332 printf (_("File name Line number Starting address\n"));
3336 unsigned int ix = file_table[0].directory_index;
3337 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3339 if (do_wide || strlen (directory) < 76)
3340 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3342 printf ("%s:\n", file_table[0].name);
3344 printf (_("File name Line number Starting address\n"));
3348 /* Skip the NUL at the end of the table. */
3351 saved_linfo = linfo;
3354 /* This loop iterates through the Dwarf Line Number Program. */
3355 while (data < end_of_sequence)
3357 unsigned char op_code;
3359 unsigned long int uladv;
3360 unsigned int bytes_read;
3361 int is_special_opcode = 0;
3365 if (op_code >= linfo.li_opcode_base)
3367 op_code -= linfo.li_opcode_base;
3368 uladv = (op_code / linfo.li_line_range);
3369 if (linfo.li_max_ops_per_insn == 1)
3371 uladv *= linfo.li_min_insn_length;
3372 state_machine_regs.address += uladv;
3376 state_machine_regs.address
3377 += ((state_machine_regs.op_index + uladv)
3378 / linfo.li_max_ops_per_insn)
3379 * linfo.li_min_insn_length;
3380 state_machine_regs.op_index
3381 = (state_machine_regs.op_index + uladv)
3382 % linfo.li_max_ops_per_insn;
3385 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3386 state_machine_regs.line += adv;
3387 is_special_opcode = 1;
3389 else switch (op_code)
3391 case DW_LNS_extended_op:
3393 unsigned int ext_op_code_len;
3394 unsigned char ext_op_code;
3395 unsigned char *op_code_data = data;
3397 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3399 op_code_data += bytes_read;
3401 if (ext_op_code_len == 0)
3403 warn (_("Badly formed extended line op encountered!\n"));
3406 ext_op_code_len += bytes_read;
3407 ext_op_code = *op_code_data++;
3409 switch (ext_op_code)
3411 case DW_LNE_end_sequence:
3412 reset_state_machine (linfo.li_default_is_stmt);
3414 case DW_LNE_set_address:
3415 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3417 ext_op_code_len - bytes_read - 1,
3419 state_machine_regs.op_index = 0;
3421 case DW_LNE_define_file:
3423 file_table = (File_Entry *) xrealloc
3424 (file_table, (n_files + 1) * sizeof (File_Entry));
3426 ++state_machine_regs.last_file_entry;
3427 /* Source file name. */
3428 file_table[n_files].name = op_code_data;
3429 op_code_data += strlen ((char *) op_code_data) + 1;
3430 /* Directory index. */
3431 file_table[n_files].directory_index =
3432 read_uleb128 (op_code_data, & bytes_read,
3434 op_code_data += bytes_read;
3435 /* Last modification time. */
3436 file_table[n_files].modification_date =
3437 read_uleb128 (op_code_data, & bytes_read,
3439 op_code_data += bytes_read;
3441 file_table[n_files].length =
3442 read_uleb128 (op_code_data, & bytes_read,
3448 case DW_LNE_set_discriminator:
3449 case DW_LNE_HP_set_sequence:
3450 /* Simply ignored. */
3454 printf (_("UNKNOWN (%u): length %d\n"),
3455 ext_op_code, ext_op_code_len - bytes_read);
3458 data += ext_op_code_len;
3464 case DW_LNS_advance_pc:
3465 uladv = read_uleb128 (data, & bytes_read, end);
3467 if (linfo.li_max_ops_per_insn == 1)
3469 uladv *= linfo.li_min_insn_length;
3470 state_machine_regs.address += uladv;
3474 state_machine_regs.address
3475 += ((state_machine_regs.op_index + uladv)
3476 / linfo.li_max_ops_per_insn)
3477 * linfo.li_min_insn_length;
3478 state_machine_regs.op_index
3479 = (state_machine_regs.op_index + uladv)
3480 % linfo.li_max_ops_per_insn;
3484 case DW_LNS_advance_line:
3485 adv = read_sleb128 (data, & bytes_read, end);
3487 state_machine_regs.line += adv;
3490 case DW_LNS_set_file:
3491 adv = read_uleb128 (data, & bytes_read, end);
3493 state_machine_regs.file = adv;
3495 if (file_table == NULL)
3496 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3497 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3498 /* If directory index is 0, that means current directory. */
3499 printf ("\n./%s:[++]\n",
3500 file_table[state_machine_regs.file - 1].name);
3501 else if (directory_table == NULL)
3502 printf (_("\n [Use directory table entry %d]\n"),
3503 file_table[state_machine_regs.file - 1].directory_index - 1);
3505 /* The directory index starts counting at 1. */
3506 printf ("\n%s/%s:\n",
3507 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3508 file_table[state_machine_regs.file - 1].name);
3511 case DW_LNS_set_column:
3512 uladv = read_uleb128 (data, & bytes_read, end);
3514 state_machine_regs.column = uladv;
3517 case DW_LNS_negate_stmt:
3518 adv = state_machine_regs.is_stmt;
3520 state_machine_regs.is_stmt = adv;
3523 case DW_LNS_set_basic_block:
3524 state_machine_regs.basic_block = 1;
3527 case DW_LNS_const_add_pc:
3528 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3529 if (linfo.li_max_ops_per_insn == 1)
3531 uladv *= linfo.li_min_insn_length;
3532 state_machine_regs.address += uladv;
3536 state_machine_regs.address
3537 += ((state_machine_regs.op_index + uladv)
3538 / linfo.li_max_ops_per_insn)
3539 * linfo.li_min_insn_length;
3540 state_machine_regs.op_index
3541 = (state_machine_regs.op_index + uladv)
3542 % linfo.li_max_ops_per_insn;
3546 case DW_LNS_fixed_advance_pc:
3547 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3548 state_machine_regs.address += uladv;
3549 state_machine_regs.op_index = 0;
3552 case DW_LNS_set_prologue_end:
3555 case DW_LNS_set_epilogue_begin:
3558 case DW_LNS_set_isa:
3559 uladv = read_uleb128 (data, & bytes_read, end);
3561 printf (_(" Set ISA to %lu\n"), uladv);
3565 printf (_(" Unknown opcode %d with operands: "), op_code);
3567 if (standard_opcodes != NULL)
3568 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3570 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3572 i == 1 ? "" : ", ");
3579 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3580 to the DWARF address/line matrix. */
3581 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3582 || (op_code == DW_LNS_copy))
3584 const unsigned int MAX_FILENAME_LENGTH = 35;
3586 char *newFileName = NULL;
3587 size_t fileNameLength;
3590 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3592 fileName = "<unknown>";
3594 fileNameLength = strlen (fileName);
3596 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3598 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3599 /* Truncate file name */
3600 strncpy (newFileName,
3601 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3602 MAX_FILENAME_LENGTH + 1);
3606 newFileName = (char *) xmalloc (fileNameLength + 1);
3607 strncpy (newFileName, fileName, fileNameLength + 1);
3610 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3612 if (linfo.li_max_ops_per_insn == 1)
3613 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3614 newFileName, state_machine_regs.line,
3615 state_machine_regs.address);
3617 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3618 newFileName, state_machine_regs.line,
3619 state_machine_regs.address,
3620 state_machine_regs.op_index);
3624 if (linfo.li_max_ops_per_insn == 1)
3625 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3626 newFileName, state_machine_regs.line,
3627 state_machine_regs.address);
3629 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3630 newFileName, state_machine_regs.line,
3631 state_machine_regs.address,
3632 state_machine_regs.op_index);
3635 if (op_code == DW_LNE_end_sequence)
3649 if (directory_table)
3651 free (directory_table);
3652 directory_table = NULL;
3663 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3665 unsigned char *data = section->start;
3666 unsigned char *end = data + section->size;
3668 int retValDecoded = 1;
3670 if (do_debug_lines == 0)
3671 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3673 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3674 retValRaw = display_debug_lines_raw (section, data, end);
3676 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3677 retValDecoded = display_debug_lines_decoded (section, data, end);
3679 if (!retValRaw || !retValDecoded)
3686 find_debug_info_for_offset (unsigned long offset)
3690 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3693 for (i = 0; i < num_debug_info_entries; i++)
3694 if (debug_information[i].cu_offset == offset)
3695 return debug_information + i;
3701 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3703 /* See gdb/gdb-index.h. */
3704 static const char * const kinds[] =
3716 return _ (kinds[kind]);
3720 display_debug_pubnames_worker (struct dwarf_section *section,
3721 void *file ATTRIBUTE_UNUSED,
3724 DWARF2_Internal_PubNames names;
3725 unsigned char *start = section->start;
3726 unsigned char *end = start + section->size;
3728 /* It does not matter if this load fails,
3729 we test for that later on. */
3730 load_debug_info (file);
3732 printf (_("Contents of the %s section:\n\n"), section->name);
3736 unsigned char *data;
3739 unsigned int offset_size, initial_length_size;
3743 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3744 if (names.pn_length == 0xffffffff)
3746 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3748 initial_length_size = 12;
3753 initial_length_size = 4;
3756 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3757 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3759 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3760 && num_debug_info_entries > 0
3761 && find_debug_info_for_offset (names.pn_offset) == NULL)
3762 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3763 (unsigned long) names.pn_offset, section->name);
3765 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3767 adr = start + names.pn_length + initial_length_size;
3768 /* PR 17531: file: 7615b6b2. */
3769 if ((dwarf_signed_vma) names.pn_length < 0
3770 /* PR 17531: file: a5dbeaa7. */
3773 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3779 printf (_(" Length: %ld\n"),
3780 (long) names.pn_length);
3781 printf (_(" Version: %d\n"),
3783 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3784 (unsigned long) names.pn_offset);
3785 printf (_(" Size of area in .debug_info section: %ld\n"),
3786 (long) names.pn_size);
3788 if (names.pn_version != 2 && names.pn_version != 3)
3790 static int warned = 0;
3794 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3802 printf (_("\n Offset Kind Name\n"));
3804 printf (_("\n Offset\tName\n"));
3808 bfd_size_type maxprint;
3810 SAFE_BYTE_GET (offset, data, offset_size, end);
3814 data += offset_size;
3817 maxprint = (end - data) - 1;
3821 unsigned int kind_data;
3822 gdb_index_symbol_kind kind;
3823 const char *kind_name;
3826 SAFE_BYTE_GET (kind_data, data, 1, end);
3829 /* GCC computes the kind as the upper byte in the CU index
3830 word, and then right shifts it by the CU index size.
3831 Left shift KIND to where the gdb-index.h accessor macros
3833 kind_data <<= GDB_INDEX_CU_BITSIZE;
3834 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3835 kind_name = get_gdb_index_symbol_kind_name (kind);
3836 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3837 printf (" %-6lx %s,%-10s %.*s\n",
3838 (unsigned long) offset, is_static ? _("s") : _("g"),
3839 kind_name, (int) maxprint, data);
3842 printf (" %-6lx\t%.*s\n",
3843 (unsigned long) offset, (int) maxprint, data);
3845 data += strnlen ((char *) data, maxprint) + 1;
3850 while (offset != 0);
3858 display_debug_pubnames (struct dwarf_section *section, void *file)
3860 return display_debug_pubnames_worker (section, file, 0);
3864 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3866 return display_debug_pubnames_worker (section, file, 1);
3870 display_debug_macinfo (struct dwarf_section *section,
3871 void *file ATTRIBUTE_UNUSED)
3873 unsigned char *start = section->start;
3874 unsigned char *end = start + section->size;
3875 unsigned char *curr = start;
3876 unsigned int bytes_read;
3877 enum dwarf_macinfo_record_type op;
3879 printf (_("Contents of the %s section:\n\n"), section->name);
3883 unsigned int lineno;
3884 const unsigned char *string;
3886 op = (enum dwarf_macinfo_record_type) *curr;
3891 case DW_MACINFO_start_file:
3893 unsigned int filenum;
3895 lineno = read_uleb128 (curr, & bytes_read, end);
3897 filenum = read_uleb128 (curr, & bytes_read, end);
3900 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3905 case DW_MACINFO_end_file:
3906 printf (_(" DW_MACINFO_end_file\n"));
3909 case DW_MACINFO_define:
3910 lineno = read_uleb128 (curr, & bytes_read, end);
3913 curr += strnlen ((char *) string, end - string) + 1;
3914 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3918 case DW_MACINFO_undef:
3919 lineno = read_uleb128 (curr, & bytes_read, end);
3922 curr += strnlen ((char *) string, end - string) + 1;
3923 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3927 case DW_MACINFO_vendor_ext:
3929 unsigned int constant;
3931 constant = read_uleb128 (curr, & bytes_read, end);
3934 curr += strnlen ((char *) string, end - string) + 1;
3935 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3945 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3946 filename and dirname corresponding to file name table entry with index
3947 FILEIDX. Return NULL on failure. */
3949 static unsigned char *
3950 get_line_filename_and_dirname (dwarf_vma line_offset,
3952 unsigned char **dir_name)
3954 struct dwarf_section *section = &debug_displays [line].section;
3955 unsigned char *hdrptr, *dirtable, *file_name;
3956 unsigned int offset_size, initial_length_size;
3957 unsigned int version, opcode_base, bytes_read;
3958 dwarf_vma length, diridx;
3959 const unsigned char * end;
3962 if (section->start == NULL
3963 || line_offset >= section->size
3967 hdrptr = section->start + line_offset;
3968 end = section->start + section->size;
3970 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3971 if (length == 0xffffffff)
3973 /* This section is 64-bit DWARF 3. */
3974 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3976 initial_length_size = 12;
3981 initial_length_size = 4;
3983 if (length + initial_length_size > section->size)
3986 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3987 if (version != 2 && version != 3 && version != 4)
3989 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3991 hdrptr++; /* Skip max_ops_per_insn. */
3992 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3994 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3995 if (opcode_base == 0)
3998 hdrptr += opcode_base - 1;
4000 /* Skip over dirname table. */
4001 while (*hdrptr != '\0')
4002 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4003 hdrptr++; /* Skip the NUL at the end of the table. */
4004 /* Now skip over preceding filename table entries. */
4005 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
4007 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4008 read_uleb128 (hdrptr, &bytes_read, end);
4009 hdrptr += bytes_read;
4010 read_uleb128 (hdrptr, &bytes_read, end);
4011 hdrptr += bytes_read;
4012 read_uleb128 (hdrptr, &bytes_read, end);
4013 hdrptr += bytes_read;
4015 if (hdrptr == end || *hdrptr == '\0')
4018 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4019 diridx = read_uleb128 (hdrptr, &bytes_read, end);
4022 for (; *dirtable != '\0' && diridx > 1; diridx--)
4023 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4024 if (*dirtable == '\0')
4026 *dir_name = dirtable;
4031 display_debug_macro (struct dwarf_section *section,
4034 unsigned char *start = section->start;
4035 unsigned char *end = start + section->size;
4036 unsigned char *curr = start;
4037 unsigned char *extended_op_buf[256];
4038 unsigned int bytes_read;
4040 load_debug_section (str, file);
4041 load_debug_section (line, file);
4043 printf (_("Contents of the %s section:\n\n"), section->name);
4047 unsigned int lineno, version, flags;
4048 unsigned int offset_size = 4;
4049 const unsigned char *string;
4050 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4051 unsigned char **extended_ops = NULL;
4053 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4056 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4061 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4064 printf (_(" Offset: 0x%lx\n"),
4065 (unsigned long) sec_offset);
4066 printf (_(" Version: %d\n"), version);
4067 printf (_(" Offset size: %d\n"), offset_size);
4070 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4071 printf (_(" Offset into .debug_line: 0x%lx\n"),
4072 (unsigned long) line_offset);
4076 unsigned int i, count, op;
4079 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4081 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4082 extended_ops = extended_op_buf;
4085 printf (_(" Extension opcode arguments:\n"));
4086 for (i = 0; i < count; i++)
4088 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4089 extended_ops[op] = curr;
4090 nargs = read_uleb128 (curr, &bytes_read, end);
4093 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
4096 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
4097 for (n = 0; n < nargs; n++)
4101 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4102 printf ("%s%s", get_FORM_name (form),
4103 n == nargs - 1 ? "\n" : ", ");
4113 case DW_FORM_block1:
4114 case DW_FORM_block2:
4115 case DW_FORM_block4:
4117 case DW_FORM_string:
4119 case DW_FORM_sec_offset:
4122 error (_("Invalid extension opcode form %s\n"),
4123 get_FORM_name (form));
4139 error (_(".debug_macro section not zero terminated\n"));
4143 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4149 case DW_MACRO_GNU_start_file:
4151 unsigned int filenum;
4152 unsigned char *file_name = NULL, *dir_name = NULL;
4154 lineno = read_uleb128 (curr, &bytes_read, end);
4156 filenum = read_uleb128 (curr, &bytes_read, end);
4159 if ((flags & 2) == 0)
4160 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4163 = get_line_filename_and_dirname (line_offset, filenum,
4165 if (file_name == NULL)
4166 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4169 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4171 dir_name != NULL ? (const char *) dir_name : "",
4172 dir_name != NULL ? "/" : "", file_name);
4176 case DW_MACRO_GNU_end_file:
4177 printf (_(" DW_MACRO_GNU_end_file\n"));
4180 case DW_MACRO_GNU_define:
4181 lineno = read_uleb128 (curr, &bytes_read, end);
4184 curr += strnlen ((char *) string, end - string) + 1;
4185 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4189 case DW_MACRO_GNU_undef:
4190 lineno = read_uleb128 (curr, &bytes_read, end);
4193 curr += strnlen ((char *) string, end - string) + 1;
4194 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4198 case DW_MACRO_GNU_define_indirect:
4199 lineno = read_uleb128 (curr, &bytes_read, end);
4201 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4202 string = fetch_indirect_string (offset);
4203 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4207 case DW_MACRO_GNU_undef_indirect:
4208 lineno = read_uleb128 (curr, &bytes_read, end);
4210 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4211 string = fetch_indirect_string (offset);
4212 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4216 case DW_MACRO_GNU_transparent_include:
4217 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4218 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4219 (unsigned long) offset);
4222 case DW_MACRO_GNU_define_indirect_alt:
4223 lineno = read_uleb128 (curr, &bytes_read, end);
4225 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4226 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4227 lineno, (unsigned long) offset);
4230 case DW_MACRO_GNU_undef_indirect_alt:
4231 lineno = read_uleb128 (curr, &bytes_read, end);
4233 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4234 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4235 lineno, (unsigned long) offset);
4238 case DW_MACRO_GNU_transparent_include_alt:
4239 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4240 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4241 (unsigned long) offset);
4245 if (extended_ops == NULL || extended_ops[op] == NULL)
4247 error (_(" Unknown macro opcode %02x seen\n"), op);
4252 /* Skip over unhandled opcodes. */
4254 unsigned char *desc = extended_ops[op];
4255 nargs = read_uleb128 (desc, &bytes_read, end);
4259 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4262 printf (_(" DW_MACRO_GNU_%02x -"), op);
4263 for (n = 0; n < nargs; n++)
4267 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4269 = read_and_display_attr_value (0, val,
4270 curr, end, 0, 0, offset_size,
4271 version, NULL, 0, NULL,
4289 display_debug_abbrev (struct dwarf_section *section,
4290 void *file ATTRIBUTE_UNUSED)
4292 abbrev_entry *entry;
4293 unsigned char *start = section->start;
4294 unsigned char *end = start + section->size;
4296 printf (_("Contents of the %s section:\n\n"), section->name);
4300 unsigned char *last;
4305 start = process_abbrev_section (start, end);
4307 if (first_abbrev == NULL)
4310 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
4312 for (entry = first_abbrev; entry; entry = entry->next)
4316 printf (" %ld %s [%s]\n",
4318 get_TAG_name (entry->tag),
4319 entry->children ? _("has children") : _("no children"));
4321 for (attr = entry->first_attr; attr; attr = attr->next)
4322 printf (" %-18s %s\n",
4323 get_AT_name (attr->attribute),
4324 get_FORM_name (attr->form));
4334 /* Return true when ADDR is the maximum address, when addresses are
4335 POINTER_SIZE bytes long. */
4338 is_max_address (dwarf_vma addr, unsigned int pointer_size)
4340 dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
4341 return ((addr & mask) == mask);
4344 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4347 display_loc_list (struct dwarf_section *section,
4348 unsigned char **start_ptr,
4349 unsigned int debug_info_entry,
4350 unsigned long offset,
4351 unsigned long base_address,
4354 unsigned char *start = *start_ptr;
4355 unsigned char *section_end = section->start + section->size;
4356 unsigned long cu_offset;
4357 unsigned int pointer_size;
4358 unsigned int offset_size;
4363 unsigned short length;
4364 int need_frame_base;
4366 if (debug_info_entry >= num_debug_info_entries)
4368 warn (_("No debug information available for loc lists of entry: %u\n"),
4373 cu_offset = debug_information [debug_info_entry].cu_offset;
4374 pointer_size = debug_information [debug_info_entry].pointer_size;
4375 offset_size = debug_information [debug_info_entry].offset_size;
4376 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4378 if (pointer_size < 2 || pointer_size > 8)
4380 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4381 pointer_size, debug_info_entry);
4387 unsigned long off = offset + (start - *start_ptr);
4389 if (start + 2 * pointer_size > section_end)
4391 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4396 printf (" %8.8lx ", off);
4398 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4399 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4401 if (begin == 0 && end == 0)
4403 /* PR 18374: In a object file we can have a location list that
4404 starts with a begin and end of 0 because there are relocations
4405 that need to be applied to the addresses. Actually applying
4406 the relocations now does not help as they will probably resolve
4407 to 0, since the object file has not been fully linked. Real
4408 end of list markers will not have any relocations against them. */
4409 if (! reloc_at (section, off)
4410 && ! reloc_at (section, off + pointer_size))
4412 printf (_("<End of list>\n"));
4417 /* Check base address specifiers. */
4418 if (is_max_address (begin, pointer_size)
4419 && !is_max_address (end, pointer_size))
4422 print_dwarf_vma (begin, pointer_size);
4423 print_dwarf_vma (end, pointer_size);
4424 printf (_("(base address)\n"));
4428 if (start + 2 > section_end)
4430 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4435 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4437 if (start + length > section_end)
4439 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4444 print_dwarf_vma (begin + base_address, pointer_size);
4445 print_dwarf_vma (end + base_address, pointer_size);
4448 need_frame_base = decode_location_expression (start,
4453 cu_offset, section);
4456 if (need_frame_base && !has_frame_base)
4457 printf (_(" [without DW_AT_frame_base]"));
4460 fputs (_(" (start == end)"), stdout);
4461 else if (begin > end)
4462 fputs (_(" (start > end)"), stdout);
4472 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4473 right-adjusted in a field of length LEN, and followed by a space. */
4476 print_addr_index (unsigned int idx, unsigned int len)
4478 static char buf[15];
4479 snprintf (buf, sizeof (buf), "[%d]", idx);
4480 printf ("%*s ", len, buf);
4483 /* Display a location list from a .dwo section. It uses address indexes rather
4484 than embedded addresses. This code closely follows display_loc_list, but the
4485 two are sufficiently different that combining things is very ugly. */
4488 display_loc_list_dwo (struct dwarf_section *section,
4489 unsigned char **start_ptr,
4490 unsigned int debug_info_entry,
4491 unsigned long offset,
4494 unsigned char *start = *start_ptr;
4495 unsigned char *section_end = section->start + section->size;
4496 unsigned long cu_offset;
4497 unsigned int pointer_size;
4498 unsigned int offset_size;
4501 unsigned short length;
4502 int need_frame_base;
4504 unsigned int bytes_read;
4506 if (debug_info_entry >= num_debug_info_entries)
4508 warn (_("No debug information for loc lists of entry: %u\n"),
4513 cu_offset = debug_information [debug_info_entry].cu_offset;
4514 pointer_size = debug_information [debug_info_entry].pointer_size;
4515 offset_size = debug_information [debug_info_entry].offset_size;
4516 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4518 if (pointer_size < 2 || pointer_size > 8)
4520 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4521 pointer_size, debug_info_entry);
4527 printf (" %8.8lx ", offset + (start - *start_ptr));
4529 if (start >= section_end)
4531 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4536 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4539 case 0: /* A terminating entry. */
4541 printf (_("<End of list>\n"));
4543 case 1: /* A base-address entry. */
4544 idx = read_uleb128 (start, &bytes_read, section_end);
4545 start += bytes_read;
4546 print_addr_index (idx, 8);
4548 printf (_("(base address selection entry)\n"));
4550 case 2: /* A start/end entry. */
4551 idx = read_uleb128 (start, &bytes_read, section_end);
4552 start += bytes_read;
4553 print_addr_index (idx, 8);
4554 idx = read_uleb128 (start, &bytes_read, section_end);
4555 start += bytes_read;
4556 print_addr_index (idx, 8);
4558 case 3: /* A start/length entry. */
4559 idx = read_uleb128 (start, &bytes_read, section_end);
4560 start += bytes_read;
4561 print_addr_index (idx, 8);
4562 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4563 printf ("%08x ", idx);
4565 case 4: /* An offset pair entry. */
4566 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4567 printf ("%08x ", idx);
4568 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4569 printf ("%08x ", idx);
4572 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4577 if (start + 2 > section_end)
4579 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4584 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4585 if (start + length > section_end)
4587 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4593 need_frame_base = decode_location_expression (start,
4598 cu_offset, section);
4601 if (need_frame_base && !has_frame_base)
4602 printf (_(" [without DW_AT_frame_base]"));
4612 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4614 static dwarf_vma *loc_offsets;
4617 loc_offsets_compar (const void *ap, const void *bp)
4619 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4620 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4622 return (a > b) - (b > a);
4626 display_debug_loc (struct dwarf_section *section, void *file)
4628 unsigned char *start = section->start;
4629 unsigned long bytes;
4630 unsigned char *section_begin = start;
4631 unsigned int num_loc_list = 0;
4632 unsigned long last_offset = 0;
4633 unsigned int first = 0;
4636 int seen_first_offset = 0;
4637 int locs_sorted = 1;
4638 unsigned char *next;
4639 unsigned int *array = NULL;
4640 const char *suffix = strrchr (section->name, '.');
4643 if (suffix && strcmp (suffix, ".dwo") == 0)
4646 bytes = section->size;
4650 printf (_("\nThe %s section is empty.\n"), section->name);
4654 if (load_debug_info (file) == 0)
4656 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4661 /* Check the order of location list in .debug_info section. If
4662 offsets of location lists are in the ascending order, we can
4663 use `debug_information' directly. */
4664 for (i = 0; i < num_debug_info_entries; i++)
4668 num = debug_information [i].num_loc_offsets;
4669 if (num > num_loc_list)
4672 /* Check if we can use `debug_information' directly. */
4673 if (locs_sorted && num != 0)
4675 if (!seen_first_offset)
4677 /* This is the first location list. */
4678 last_offset = debug_information [i].loc_offsets [0];
4680 seen_first_offset = 1;
4686 for (; j < num; j++)
4689 debug_information [i].loc_offsets [j])
4694 last_offset = debug_information [i].loc_offsets [j];
4699 if (!seen_first_offset)
4700 error (_("No location lists in .debug_info section!\n"));
4702 if (debug_information [first].num_loc_offsets > 0
4703 && debug_information [first].loc_offsets [0] != 0)
4704 warn (_("Location lists in %s section start at 0x%s\n"),
4706 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4709 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4710 printf (_("Contents of the %s section:\n\n"), section->name);
4711 if (reloc_at (section, 0))
4712 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
4713 printf (_(" Offset Begin End Expression\n"));
4715 seen_first_offset = 0;
4716 for (i = first; i < num_debug_info_entries; i++)
4718 unsigned long offset;
4719 unsigned long base_address;
4725 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4727 loc_offsets = debug_information [i].loc_offsets;
4728 qsort (array, debug_information [i].num_loc_offsets,
4729 sizeof (*array), loc_offsets_compar);
4732 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4734 j = locs_sorted ? k : array[k];
4736 && debug_information [i].loc_offsets [locs_sorted
4737 ? k - 1 : array [k - 1]]
4738 == debug_information [i].loc_offsets [j])
4740 has_frame_base = debug_information [i].have_frame_base [j];
4741 offset = debug_information [i].loc_offsets [j];
4742 next = section_begin + offset;
4743 base_address = debug_information [i].base_address;
4745 if (!seen_first_offset)
4746 seen_first_offset = 1;
4750 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4751 (unsigned long) (start - section_begin),
4752 (unsigned long) offset);
4753 else if (start > next)
4754 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4755 (unsigned long) (start - section_begin),
4756 (unsigned long) offset);
4760 if (offset >= bytes)
4762 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4768 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4770 display_loc_list (section, &start, i, offset, base_address,
4775 if (start < section->start + section->size)
4776 warn (_("There are %ld unused bytes at the end of section %s\n"),
4777 (long) (section->start + section->size - start), section->name);
4784 display_debug_str (struct dwarf_section *section,
4785 void *file ATTRIBUTE_UNUSED)
4787 unsigned char *start = section->start;
4788 unsigned long bytes = section->size;
4789 dwarf_vma addr = section->address;
4793 printf (_("\nThe %s section is empty.\n"), section->name);
4797 printf (_("Contents of the %s section:\n\n"), section->name);
4805 lbytes = (bytes > 16 ? 16 : bytes);
4807 printf (" 0x%8.8lx ", (unsigned long) addr);
4809 for (j = 0; j < 16; j++)
4812 printf ("%2.2x", start[j]);
4820 for (j = 0; j < lbytes; j++)
4823 if (k >= ' ' && k < 0x80)
4842 display_debug_info (struct dwarf_section *section, void *file)
4844 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4848 display_debug_types (struct dwarf_section *section, void *file)
4850 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4854 display_trace_info (struct dwarf_section *section, void *file)
4856 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4860 display_debug_aranges (struct dwarf_section *section,
4861 void *file ATTRIBUTE_UNUSED)
4863 unsigned char *start = section->start;
4864 unsigned char *end = start + section->size;
4866 printf (_("Contents of the %s section:\n\n"), section->name);
4868 /* It does not matter if this load fails,
4869 we test for that later on. */
4870 load_debug_info (file);
4874 unsigned char *hdrptr;
4875 DWARF2_Internal_ARange arange;
4876 unsigned char *addr_ranges;
4879 unsigned char address_size;
4881 unsigned int offset_size;
4882 unsigned int initial_length_size;
4886 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4887 if (arange.ar_length == 0xffffffff)
4889 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4891 initial_length_size = 12;
4896 initial_length_size = 4;
4899 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4900 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4902 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4903 && num_debug_info_entries > 0
4904 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4905 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4906 (unsigned long) arange.ar_info_offset, section->name);
4908 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4909 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4911 if (arange.ar_version != 2 && arange.ar_version != 3)
4913 /* PR 19872: A version number of 0 probably means that there is
4914 padding at the end of the .debug_aranges section. Gold puts
4915 it there when performing an incremental link, for example.
4916 So do not generate a warning in this case. */
4917 if (arange.ar_version)
4918 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4922 printf (_(" Length: %ld\n"),
4923 (long) arange.ar_length);
4924 printf (_(" Version: %d\n"), arange.ar_version);
4925 printf (_(" Offset into .debug_info: 0x%lx\n"),
4926 (unsigned long) arange.ar_info_offset);
4927 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4928 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4930 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4932 /* PR 17512: file: 001-108546-0.001:0.1. */
4933 if (address_size == 0 || address_size > 8)
4935 error (_("Invalid address size in %s section!\n"),
4940 /* The DWARF spec does not require that the address size be a power
4941 of two, but we do. This will have to change if we ever encounter
4942 an uneven architecture. */
4943 if ((address_size & (address_size - 1)) != 0)
4945 warn (_("Pointer size + Segment size is not a power of two.\n"));
4949 if (address_size > 4)
4950 printf (_("\n Address Length\n"));
4952 printf (_("\n Address Length\n"));
4954 addr_ranges = hdrptr;
4956 /* Must pad to an alignment boundary that is twice the address size. */
4957 excess = (hdrptr - start) % (2 * address_size);
4959 addr_ranges += (2 * address_size) - excess;
4961 hdrptr = start + arange.ar_length + initial_length_size;
4962 if (hdrptr < start || hdrptr > end)
4964 error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
4969 while (addr_ranges + 2 * address_size <= start)
4971 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4972 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4975 print_dwarf_vma (address, address_size);
4976 print_dwarf_vma (length, address_size);
4986 /* Comparison function for qsort. */
4988 comp_addr_base (const void * v0, const void * v1)
4990 debug_info * info0 = (debug_info *) v0;
4991 debug_info * info1 = (debug_info *) v1;
4992 return info0->addr_base - info1->addr_base;
4995 /* Display the debug_addr section. */
4997 display_debug_addr (struct dwarf_section *section,
5000 debug_info **debug_addr_info;
5001 unsigned char *entry;
5006 if (section->size == 0)
5008 printf (_("\nThe %s section is empty.\n"), section->name);
5012 if (load_debug_info (file) == 0)
5014 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5019 printf (_("Contents of the %s section:\n\n"), section->name);
5021 /* PR 17531: file: cf38d01b.
5022 We use xcalloc because a corrupt file may not have initialised all of the
5023 fields in the debug_info structure, which means that the sort below might
5024 try to move uninitialised data. */
5025 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
5026 sizeof (debug_info *));
5029 for (i = 0; i < num_debug_info_entries; i++)
5030 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
5032 /* PR 17531: file: cf38d01b. */
5033 if (debug_information[i].addr_base >= section->size)
5034 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5035 (unsigned long) debug_information[i].addr_base, i);
5037 debug_addr_info [count++] = debug_information + i;
5040 /* Add a sentinel to make iteration convenient. */
5041 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5042 debug_addr_info [count]->addr_base = section->size;
5043 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
5045 for (i = 0; i < count; i++)
5048 unsigned int address_size = debug_addr_info [i]->pointer_size;
5050 printf (_(" For compilation unit at offset 0x%s:\n"),
5051 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5053 printf (_("\tIndex\tAddress\n"));
5054 entry = section->start + debug_addr_info [i]->addr_base;
5055 end = section->start + debug_addr_info [i + 1]->addr_base;
5059 dwarf_vma base = byte_get (entry, address_size);
5060 printf (_("\t%d:\t"), idx);
5061 print_dwarf_vma (base, address_size);
5063 entry += address_size;
5069 free (debug_addr_info);
5073 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5075 display_debug_str_offsets (struct dwarf_section *section,
5076 void *file ATTRIBUTE_UNUSED)
5078 if (section->size == 0)
5080 printf (_("\nThe %s section is empty.\n"), section->name);
5083 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5084 what the offset size is for this section. */
5088 /* Each debug_information[x].range_lists[y] gets this representation for
5089 sorting purposes. */
5093 /* The debug_information[x].range_lists[y] value. */
5094 unsigned long ranges_offset;
5096 /* Original debug_information to find parameters of the data. */
5097 debug_info *debug_info_p;
5100 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5103 range_entry_compar (const void *ap, const void *bp)
5105 const struct range_entry *a_re = (const struct range_entry *) ap;
5106 const struct range_entry *b_re = (const struct range_entry *) bp;
5107 const unsigned long a = a_re->ranges_offset;
5108 const unsigned long b = b_re->ranges_offset;
5110 return (a > b) - (b > a);
5114 display_debug_ranges (struct dwarf_section *section,
5115 void *file ATTRIBUTE_UNUSED)
5117 unsigned char *start = section->start;
5118 unsigned char *last_start = start;
5119 unsigned long bytes = section->size;
5120 unsigned char *section_begin = start;
5121 unsigned char *finish = start + bytes;
5122 unsigned int num_range_list, i;
5123 struct range_entry *range_entries, *range_entry_fill;
5127 printf (_("\nThe %s section is empty.\n"), section->name);
5131 if (load_debug_info (file) == 0)
5133 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5139 for (i = 0; i < num_debug_info_entries; i++)
5140 num_range_list += debug_information [i].num_range_lists;
5142 if (num_range_list == 0)
5144 /* This can happen when the file was compiled with -gsplit-debug
5145 which removes references to range lists from the primary .o file. */
5146 printf (_("No range lists in .debug_info section.\n"));
5150 range_entries = (struct range_entry *)
5151 xmalloc (sizeof (*range_entries) * num_range_list);
5152 range_entry_fill = range_entries;
5154 for (i = 0; i < num_debug_info_entries; i++)
5156 debug_info *debug_info_p = &debug_information[i];
5159 for (j = 0; j < debug_info_p->num_range_lists; j++)
5161 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5162 range_entry_fill->debug_info_p = debug_info_p;
5167 qsort (range_entries, num_range_list, sizeof (*range_entries),
5168 range_entry_compar);
5170 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5171 warn (_("Range lists in %s section start at 0x%lx\n"),
5172 section->name, range_entries[0].ranges_offset);
5174 printf (_("Contents of the %s section:\n\n"), section->name);
5175 printf (_(" Offset Begin End\n"));
5177 for (i = 0; i < num_range_list; i++)
5179 struct range_entry *range_entry = &range_entries[i];
5180 debug_info *debug_info_p = range_entry->debug_info_p;
5181 unsigned int pointer_size;
5182 unsigned long offset;
5183 unsigned char *next;
5184 unsigned long base_address;
5186 pointer_size = debug_info_p->pointer_size;
5187 offset = range_entry->ranges_offset;
5188 next = section_begin + offset;
5189 base_address = debug_info_p->base_address;
5191 /* PR 17512: file: 001-101485-0.001:0.1. */
5192 if (pointer_size < 2 || pointer_size > 8)
5194 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5195 pointer_size, offset);
5199 if (dwarf_check != 0 && i > 0)
5202 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5203 (unsigned long) (start - section_begin),
5204 (unsigned long) (next - section_begin), section->name);
5205 else if (start > next)
5207 if (next == last_start)
5209 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5210 (unsigned long) (start - section_begin),
5211 (unsigned long) (next - section_begin), section->name);
5217 while (start < finish)
5222 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5223 if (start >= finish)
5225 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5227 printf (" %8.8lx ", offset);
5229 if (begin == 0 && end == 0)
5231 printf (_("<End of list>\n"));
5235 /* Check base address specifiers. */
5236 if (is_max_address (begin, pointer_size)
5237 && !is_max_address (end, pointer_size))
5240 print_dwarf_vma (begin, pointer_size);
5241 print_dwarf_vma (end, pointer_size);
5242 printf ("(base address)\n");
5246 print_dwarf_vma (begin + base_address, pointer_size);
5247 print_dwarf_vma (end + base_address, pointer_size);
5250 fputs (_("(start == end)"), stdout);
5251 else if (begin > end)
5252 fputs (_("(start > end)"), stdout);
5259 free (range_entries);
5264 typedef struct Frame_Chunk
5266 struct Frame_Chunk *next;
5267 unsigned char *chunk_start;
5269 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5270 short int *col_type;
5273 unsigned int code_factor;
5278 dwarf_vma cfa_offset;
5280 unsigned char fde_encoding;
5281 unsigned char cfa_exp;
5282 unsigned char ptr_size;
5283 unsigned char segment_size;
5287 static const char *const *dwarf_regnames;
5288 static unsigned int dwarf_regnames_count;
5290 /* A marker for a col_type that means this column was never referenced
5291 in the frame info. */
5292 #define DW_CFA_unreferenced (-1)
5294 /* Return 0 if no more space is needed, 1 if more space is needed,
5295 -1 for invalid reg. */
5298 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5300 unsigned int prev = fc->ncols;
5302 if (reg < (unsigned int) fc->ncols)
5305 if (dwarf_regnames_count
5306 && reg > dwarf_regnames_count)
5309 fc->ncols = reg + 1;
5310 /* PR 17512: file: 10450-2643-0.004.
5311 If reg == -1 then this can happen... */
5315 /* PR 17512: file: 2844a11d. */
5316 if (fc->ncols > 1024)
5318 error (_("Unfeasibly large register number: %u\n"), reg);
5320 /* FIXME: 1024 is an arbitrary limit. Increase it if
5321 we ever encounter a valid binary that exceeds it. */
5325 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5326 sizeof (short int));
5327 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5328 /* PR 17512: file:002-10025-0.005. */
5329 if (fc->col_type == NULL || fc->col_offset == NULL)
5331 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5337 while (prev < fc->ncols)
5339 fc->col_type[prev] = DW_CFA_unreferenced;
5340 fc->col_offset[prev] = 0;
5346 static const char *const dwarf_regnames_i386[] =
5348 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5349 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5350 "eip", "eflags", NULL, /* 8 - 10 */
5351 "st0", "st1", "st2", "st3", /* 11 - 14 */
5352 "st4", "st5", "st6", "st7", /* 15 - 18 */
5353 NULL, NULL, /* 19 - 20 */
5354 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5355 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5356 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5357 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5358 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5359 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5360 "tr", "ldtr", /* 48 - 49 */
5361 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5362 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5363 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5364 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5365 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5366 NULL, NULL, NULL, /* 90 - 92 */
5367 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5370 static const char *const dwarf_regnames_iamcu[] =
5372 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5373 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5374 "eip", "eflags", NULL, /* 8 - 10 */
5375 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18 */
5376 NULL, NULL, /* 19 - 20 */
5377 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28 */
5378 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36 */
5379 NULL, NULL, NULL, /* 37 - 39 */
5380 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5381 "tr", "ldtr", /* 48 - 49 */
5382 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5383 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5384 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5385 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5386 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5387 NULL, NULL, NULL, /* 90 - 92 */
5388 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL /* 93 - 100 */
5392 init_dwarf_regnames_i386 (void)
5394 dwarf_regnames = dwarf_regnames_i386;
5395 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5399 init_dwarf_regnames_iamcu (void)
5401 dwarf_regnames = dwarf_regnames_iamcu;
5402 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
5405 static const char *const dwarf_regnames_x86_64[] =
5407 "rax", "rdx", "rcx", "rbx",
5408 "rsi", "rdi", "rbp", "rsp",
5409 "r8", "r9", "r10", "r11",
5410 "r12", "r13", "r14", "r15",
5412 "xmm0", "xmm1", "xmm2", "xmm3",
5413 "xmm4", "xmm5", "xmm6", "xmm7",
5414 "xmm8", "xmm9", "xmm10", "xmm11",
5415 "xmm12", "xmm13", "xmm14", "xmm15",
5416 "st0", "st1", "st2", "st3",
5417 "st4", "st5", "st6", "st7",
5418 "mm0", "mm1", "mm2", "mm3",
5419 "mm4", "mm5", "mm6", "mm7",
5421 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5422 "fs.base", "gs.base", NULL, NULL,
5424 "mxcsr", "fcw", "fsw",
5425 "xmm16", "xmm17", "xmm18", "xmm19",
5426 "xmm20", "xmm21", "xmm22", "xmm23",
5427 "xmm24", "xmm25", "xmm26", "xmm27",
5428 "xmm28", "xmm29", "xmm30", "xmm31",
5429 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5430 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5431 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5432 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5433 NULL, NULL, NULL, /* 115 - 117 */
5434 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5438 init_dwarf_regnames_x86_64 (void)
5440 dwarf_regnames = dwarf_regnames_x86_64;
5441 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5444 static const char *const dwarf_regnames_aarch64[] =
5446 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5447 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5448 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5449 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5450 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5451 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5452 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5453 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5454 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5455 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5456 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5457 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5461 init_dwarf_regnames_aarch64 (void)
5463 dwarf_regnames = dwarf_regnames_aarch64;
5464 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5467 static const char *const dwarf_regnames_s390[] =
5469 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
5470 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5471 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5472 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
5473 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
5474 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
5475 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
5476 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
5477 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
5480 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
5481 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
5485 init_dwarf_regnames_s390 (void)
5487 dwarf_regnames = dwarf_regnames_s390;
5488 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
5492 init_dwarf_regnames (unsigned int e_machine)
5497 init_dwarf_regnames_i386 ();
5501 init_dwarf_regnames_iamcu ();
5507 init_dwarf_regnames_x86_64 ();
5511 init_dwarf_regnames_aarch64 ();
5515 init_dwarf_regnames_s390 ();
5524 regname (unsigned int regno, int row)
5526 static char reg[64];
5528 && regno < dwarf_regnames_count
5529 && dwarf_regnames [regno] != NULL)
5532 return dwarf_regnames [regno];
5533 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5534 dwarf_regnames [regno]);
5537 snprintf (reg, sizeof (reg), "r%d", regno);
5542 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5547 if (*max_regs < fc->ncols)
5548 *max_regs = fc->ncols;
5550 if (*need_col_headers)
5552 static const char *sloc = " LOC";
5554 *need_col_headers = 0;
5556 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5558 for (r = 0; r < *max_regs; r++)
5559 if (fc->col_type[r] != DW_CFA_unreferenced)
5564 printf ("%-5s ", regname (r, 1));
5570 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5572 strcpy (tmp, "exp");
5574 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
5575 printf ("%-8s ", tmp);
5577 for (r = 0; r < fc->ncols; r++)
5579 if (fc->col_type[r] != DW_CFA_unreferenced)
5581 switch (fc->col_type[r])
5583 case DW_CFA_undefined:
5586 case DW_CFA_same_value:
5590 sprintf (tmp, "c%+d", fc->col_offset[r]);
5592 case DW_CFA_val_offset:
5593 sprintf (tmp, "v%+d", fc->col_offset[r]);
5595 case DW_CFA_register:
5596 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5598 case DW_CFA_expression:
5599 strcpy (tmp, "exp");
5601 case DW_CFA_val_expression:
5602 strcpy (tmp, "vexp");
5605 strcpy (tmp, "n/a");
5608 printf ("%-5s ", tmp);
5614 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5615 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5616 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5618 static unsigned char *
5619 read_cie (unsigned char *start, unsigned char *end,
5620 Frame_Chunk **p_cie, int *p_version,
5621 unsigned long *p_aug_len, unsigned char **p_aug)
5625 unsigned int length_return;
5626 unsigned char *augmentation_data = NULL;
5627 unsigned long augmentation_data_len = 0;
5630 /* PR 17512: file: 001-228113-0.004. */
5634 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5635 memset (fc, 0, sizeof (Frame_Chunk));
5637 fc->col_type = (short int *) xmalloc (sizeof (short int));
5638 fc->col_offset = (int *) xmalloc (sizeof (int));
5642 fc->augmentation = (char *) start;
5643 /* PR 17512: file: 001-228113-0.004.
5644 Skip past augmentation name, but avoid running off the end of the data. */
5646 if (* start ++ == '\0')
5650 warn (_("No terminator for augmentation name\n"));
5654 if (strcmp (fc->augmentation, "eh") == 0)
5655 start += eh_addr_size;
5659 GET (fc->ptr_size, 1);
5660 if (fc->ptr_size < 1 || fc->ptr_size > 8)
5662 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5666 GET (fc->segment_size, 1);
5667 /* PR 17512: file: e99d2804. */
5668 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5670 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5674 eh_addr_size = fc->ptr_size;
5678 fc->ptr_size = eh_addr_size;
5679 fc->segment_size = 0;
5681 fc->code_factor = LEB ();
5682 fc->data_factor = SLEB ();
5692 if (fc->augmentation[0] == 'z')
5694 augmentation_data_len = LEB ();
5695 augmentation_data = start;
5696 start += augmentation_data_len;
5697 /* PR 17512: file: 11042-2589-0.004. */
5700 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5705 if (augmentation_data_len)
5709 unsigned char *qend;
5711 p = (unsigned char *) fc->augmentation + 1;
5712 q = augmentation_data;
5713 qend = q + augmentation_data_len;
5715 /* PR 17531: file: 015adfaa. */
5718 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5719 augmentation_data_len = 0;
5722 while (p < end && q < augmentation_data + augmentation_data_len)
5727 q += 1 + size_of_encoded_value (*q);
5729 fc->fde_encoding = *q++;
5736 /* Note - it is OK if this loop terminates with q < qend.
5737 Padding may have been inserted to align the end of the CIE. */
5742 *p_version = version;
5745 *p_aug_len = augmentation_data_len;
5746 *p_aug = augmentation_data;
5752 display_debug_frames (struct dwarf_section *section,
5753 void *file ATTRIBUTE_UNUSED)
5755 unsigned char *start = section->start;
5756 unsigned char *end = start + section->size;
5757 unsigned char *section_start = start;
5758 Frame_Chunk *chunks = 0, *forward_refs = 0;
5759 Frame_Chunk *remembered_state = 0;
5761 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5762 unsigned int length_return;
5763 unsigned int max_regs = 0;
5764 const char *bad_reg = _("bad register: ");
5765 unsigned int saved_eh_addr_size = eh_addr_size;
5767 printf (_("Contents of the %s section:\n"), section->name);
5771 unsigned char *saved_start;
5772 unsigned char *block_end;
5777 int need_col_headers = 1;
5778 unsigned char *augmentation_data = NULL;
5779 unsigned long augmentation_data_len = 0;
5780 unsigned int encoded_ptr_size = saved_eh_addr_size;
5781 unsigned int offset_size;
5782 unsigned int initial_length_size;
5784 saved_start = start;
5786 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5790 printf ("\n%08lx ZERO terminator\n\n",
5791 (unsigned long)(saved_start - section_start));
5792 /* Skip any zero terminators that directly follow.
5793 A corrupt section size could have loaded a whole
5794 slew of zero filled memory bytes. eg
5795 PR 17512: file: 070-19381-0.004. */
5796 while (start < end && * start == 0)
5801 if (length == 0xffffffff)
5803 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5805 initial_length_size = 12;
5810 initial_length_size = 4;
5813 block_end = saved_start + length + initial_length_size;
5814 if (block_end > end || block_end < start)
5816 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5817 dwarf_vmatoa_1 (NULL, length, offset_size),
5818 (unsigned long) (saved_start - section_start));
5822 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5824 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5825 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5830 start = read_cie (start, end, &cie, &version,
5831 &augmentation_data_len, &augmentation_data);
5832 /* PR 17512: file: 027-135133-0.005. */
5839 fc->chunk_start = saved_start;
5840 mreg = max_regs > 0 ? max_regs - 1 : 0;
5843 if (frame_need_space (fc, mreg) < 0)
5845 if (fc->fde_encoding)
5846 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5848 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5849 print_dwarf_vma (length, fc->ptr_size);
5850 print_dwarf_vma (cie_id, offset_size);
5852 if (do_debug_frames_interp)
5854 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5855 fc->code_factor, fc->data_factor, fc->ra);
5860 printf (" Version: %d\n", version);
5861 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5864 printf (" Pointer Size: %u\n", fc->ptr_size);
5865 printf (" Segment Size: %u\n", fc->segment_size);
5867 printf (" Code alignment factor: %u\n", fc->code_factor);
5868 printf (" Data alignment factor: %d\n", fc->data_factor);
5869 printf (" Return address column: %d\n", fc->ra);
5871 if (augmentation_data_len)
5875 printf (" Augmentation data: ");
5876 for (i = 0; i < augmentation_data_len; ++i)
5877 /* FIXME: If do_wide is FALSE, then we should
5878 add carriage returns at 80 columns... */
5879 printf (" %02x", augmentation_data[i]);
5887 unsigned char *look_for;
5888 static Frame_Chunk fde_fc;
5889 unsigned long segment_selector;
5893 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5894 look_for = start - 4 - ((cie_id ^ sign) - sign);
5897 look_for = section_start + cie_id;
5899 if (look_for <= saved_start)
5901 for (cie = chunks; cie ; cie = cie->next)
5902 if (cie->chunk_start == look_for)
5907 for (cie = forward_refs; cie ; cie = cie->next)
5908 if (cie->chunk_start == look_for)
5912 unsigned int off_size;
5913 unsigned char *cie_scan;
5915 cie_scan = look_for;
5917 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5918 if (length == 0xffffffff)
5920 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5927 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5930 : ((off_size == 4 && c_id == DW_CIE_ID)
5931 || (off_size == 8 && c_id == DW64_CIE_ID)))
5936 read_cie (cie_scan, end, &cie, &version,
5937 &augmentation_data_len, &augmentation_data);
5938 /* PR 17512: file: 3450-2098-0.004. */
5941 warn (_("Failed to read CIE information\n"));
5944 cie->next = forward_refs;
5946 cie->chunk_start = look_for;
5947 mreg = max_regs > 0 ? max_regs - 1 : 0;
5950 if (frame_need_space (cie, mreg) < 0)
5952 warn (_("Invalid max register\n"));
5955 if (cie->fde_encoding)
5957 = size_of_encoded_value (cie->fde_encoding);
5964 memset (fc, 0, sizeof (Frame_Chunk));
5968 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5969 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5970 (unsigned long) (saved_start - section_start));
5972 fc->col_type = (short int *) xmalloc (sizeof (short int));
5973 fc->col_offset = (int *) xmalloc (sizeof (int));
5974 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5976 warn (_("Invalid max register\n"));
5980 fc->augmentation = "";
5981 fc->fde_encoding = 0;
5982 fc->ptr_size = eh_addr_size;
5983 fc->segment_size = 0;
5987 fc->ncols = cie->ncols;
5988 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5989 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
5990 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5991 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5992 fc->augmentation = cie->augmentation;
5993 fc->ptr_size = cie->ptr_size;
5994 eh_addr_size = cie->ptr_size;
5995 fc->segment_size = cie->segment_size;
5996 fc->code_factor = cie->code_factor;
5997 fc->data_factor = cie->data_factor;
5998 fc->cfa_reg = cie->cfa_reg;
5999 fc->cfa_offset = cie->cfa_offset;
6001 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
6003 warn (_("Invalid max register\n"));
6006 fc->fde_encoding = cie->fde_encoding;
6009 if (fc->fde_encoding)
6010 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
6012 segment_selector = 0;
6013 if (fc->segment_size)
6015 if (fc->segment_size > sizeof (segment_selector))
6017 /* PR 17512: file: 9e196b3e. */
6018 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
6019 fc->segment_size = 4;
6021 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
6024 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
6026 /* FIXME: It appears that sometimes the final pc_range value is
6027 encoded in less than encoded_ptr_size bytes. See the x86_64
6028 run of the "objcopy on compressed debug sections" test for an
6030 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
6032 if (cie->augmentation[0] == 'z')
6034 augmentation_data_len = LEB ();
6035 augmentation_data = start;
6036 start += augmentation_data_len;
6037 /* PR 17512: file: 722-8446-0.004. */
6038 if (start >= end || ((signed long) augmentation_data_len) < 0)
6040 warn (_("Corrupt augmentation data length: %lx\n"),
6041 augmentation_data_len);
6043 augmentation_data = NULL;
6044 augmentation_data_len = 0;
6048 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
6049 (unsigned long)(saved_start - section_start),
6050 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
6051 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
6052 (unsigned long)(cie->chunk_start - section_start));
6054 if (fc->segment_size)
6055 printf ("%04lx:", segment_selector);
6058 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
6059 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
6061 if (! do_debug_frames_interp && augmentation_data_len)
6065 printf (" Augmentation data: ");
6066 for (i = 0; i < augmentation_data_len; ++i)
6067 printf (" %02x", augmentation_data[i]);
6073 /* At this point, fc is the current chunk, cie (if any) is set, and
6074 we're about to interpret instructions for the chunk. */
6075 /* ??? At present we need to do this always, since this sizes the
6076 fc->col_type and fc->col_offset arrays, which we write into always.
6077 We should probably split the interpreted and non-interpreted bits
6078 into two different routines, since there's so much that doesn't
6079 really overlap between them. */
6080 if (1 || do_debug_frames_interp)
6082 /* Start by making a pass over the chunk, allocating storage
6083 and taking note of what registers are used. */
6084 unsigned char *tmp = start;
6086 while (start < block_end)
6088 unsigned int reg, op, opa;
6090 unsigned char * new_start;
6097 /* Warning: if you add any more cases to this switch, be
6098 sure to add them to the corresponding switch below. */
6101 case DW_CFA_advance_loc:
6105 if (frame_need_space (fc, opa) >= 0)
6106 fc->col_type[opa] = DW_CFA_undefined;
6108 case DW_CFA_restore:
6109 if (frame_need_space (fc, opa) >= 0)
6110 fc->col_type[opa] = DW_CFA_undefined;
6112 case DW_CFA_set_loc:
6113 start += encoded_ptr_size;
6115 case DW_CFA_advance_loc1:
6118 case DW_CFA_advance_loc2:
6121 case DW_CFA_advance_loc4:
6124 case DW_CFA_offset_extended:
6125 case DW_CFA_val_offset:
6126 reg = LEB (); LEB ();
6127 if (frame_need_space (fc, reg) >= 0)
6128 fc->col_type[reg] = DW_CFA_undefined;
6130 case DW_CFA_restore_extended:
6132 if (frame_need_space (fc, reg) >= 0)
6133 fc->col_type[reg] = DW_CFA_undefined;
6135 case DW_CFA_undefined:
6137 if (frame_need_space (fc, reg) >= 0)
6138 fc->col_type[reg] = DW_CFA_undefined;
6140 case DW_CFA_same_value:
6142 if (frame_need_space (fc, reg) >= 0)
6143 fc->col_type[reg] = DW_CFA_undefined;
6145 case DW_CFA_register:
6146 reg = LEB (); LEB ();
6147 if (frame_need_space (fc, reg) >= 0)
6148 fc->col_type[reg] = DW_CFA_undefined;
6150 case DW_CFA_def_cfa:
6153 case DW_CFA_def_cfa_register:
6156 case DW_CFA_def_cfa_offset:
6159 case DW_CFA_def_cfa_expression:
6161 new_start = start + temp;
6162 if (new_start < start)
6164 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6170 case DW_CFA_expression:
6171 case DW_CFA_val_expression:
6174 new_start = start + temp;
6175 if (new_start < start)
6177 /* PR 17512: file:306-192417-0.005. */
6178 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6183 if (frame_need_space (fc, reg) >= 0)
6184 fc->col_type[reg] = DW_CFA_undefined;
6186 case DW_CFA_offset_extended_sf:
6187 case DW_CFA_val_offset_sf:
6188 reg = LEB (); SLEB ();
6189 if (frame_need_space (fc, reg) >= 0)
6190 fc->col_type[reg] = DW_CFA_undefined;
6192 case DW_CFA_def_cfa_sf:
6195 case DW_CFA_def_cfa_offset_sf:
6198 case DW_CFA_MIPS_advance_loc8:
6201 case DW_CFA_GNU_args_size:
6204 case DW_CFA_GNU_negative_offset_extended:
6205 reg = LEB (); LEB ();
6206 if (frame_need_space (fc, reg) >= 0)
6207 fc->col_type[reg] = DW_CFA_undefined;
6216 /* Now we know what registers are used, make a second pass over
6217 the chunk, this time actually printing out the info. */
6219 while (start < block_end)
6221 unsigned char * tmp;
6223 unsigned long ul, reg, roffs;
6227 const char *reg_prefix = "";
6234 /* Warning: if you add any more cases to this switch, be
6235 sure to add them to the corresponding switch above. */
6238 case DW_CFA_advance_loc:
6239 if (do_debug_frames_interp)
6240 frame_display_row (fc, &need_col_headers, &max_regs);
6242 printf (" DW_CFA_advance_loc: %d to %s\n",
6243 opa * fc->code_factor,
6244 dwarf_vmatoa_1 (NULL,
6245 fc->pc_begin + opa * fc->code_factor,
6247 fc->pc_begin += opa * fc->code_factor;
6252 if (opa >= (unsigned int) fc->ncols)
6253 reg_prefix = bad_reg;
6254 if (! do_debug_frames_interp || *reg_prefix != '\0')
6255 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6256 reg_prefix, regname (opa, 0),
6257 roffs * fc->data_factor);
6258 if (*reg_prefix == '\0')
6260 fc->col_type[opa] = DW_CFA_offset;
6261 fc->col_offset[opa] = roffs * fc->data_factor;
6265 case DW_CFA_restore:
6266 if (opa >= (unsigned int) cie->ncols
6267 || opa >= (unsigned int) fc->ncols)
6268 reg_prefix = bad_reg;
6269 if (! do_debug_frames_interp || *reg_prefix != '\0')
6270 printf (" DW_CFA_restore: %s%s\n",
6271 reg_prefix, regname (opa, 0));
6272 if (*reg_prefix == '\0')
6274 fc->col_type[opa] = cie->col_type[opa];
6275 fc->col_offset[opa] = cie->col_offset[opa];
6276 if (do_debug_frames_interp
6277 && fc->col_type[opa] == DW_CFA_unreferenced)
6278 fc->col_type[opa] = DW_CFA_undefined;
6282 case DW_CFA_set_loc:
6283 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6284 if (do_debug_frames_interp)
6285 frame_display_row (fc, &need_col_headers, &max_regs);
6287 printf (" DW_CFA_set_loc: %s\n",
6288 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6292 case DW_CFA_advance_loc1:
6293 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6294 if (do_debug_frames_interp)
6295 frame_display_row (fc, &need_col_headers, &max_regs);
6297 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6298 (unsigned long) (ofs * fc->code_factor),
6299 dwarf_vmatoa_1 (NULL,
6300 fc->pc_begin + ofs * fc->code_factor,
6302 fc->pc_begin += ofs * fc->code_factor;
6305 case DW_CFA_advance_loc2:
6306 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6307 if (do_debug_frames_interp)
6308 frame_display_row (fc, &need_col_headers, &max_regs);
6310 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6311 (unsigned long) (ofs * fc->code_factor),
6312 dwarf_vmatoa_1 (NULL,
6313 fc->pc_begin + ofs * fc->code_factor,
6315 fc->pc_begin += ofs * fc->code_factor;
6318 case DW_CFA_advance_loc4:
6319 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6320 if (do_debug_frames_interp)
6321 frame_display_row (fc, &need_col_headers, &max_regs);
6323 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6324 (unsigned long) (ofs * fc->code_factor),
6325 dwarf_vmatoa_1 (NULL,
6326 fc->pc_begin + ofs * fc->code_factor,
6328 fc->pc_begin += ofs * fc->code_factor;
6331 case DW_CFA_offset_extended:
6334 if (reg >= (unsigned int) fc->ncols)
6335 reg_prefix = bad_reg;
6336 if (! do_debug_frames_interp || *reg_prefix != '\0')
6337 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6338 reg_prefix, regname (reg, 0),
6339 roffs * fc->data_factor);
6340 if (*reg_prefix == '\0')
6342 fc->col_type[reg] = DW_CFA_offset;
6343 fc->col_offset[reg] = roffs * fc->data_factor;
6347 case DW_CFA_val_offset:
6350 if (reg >= (unsigned int) fc->ncols)
6351 reg_prefix = bad_reg;
6352 if (! do_debug_frames_interp || *reg_prefix != '\0')
6353 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6354 reg_prefix, regname (reg, 0),
6355 roffs * fc->data_factor);
6356 if (*reg_prefix == '\0')
6358 fc->col_type[reg] = DW_CFA_val_offset;
6359 fc->col_offset[reg] = roffs * fc->data_factor;
6363 case DW_CFA_restore_extended:
6365 if (reg >= (unsigned int) cie->ncols
6366 || reg >= (unsigned int) fc->ncols)
6367 reg_prefix = bad_reg;
6368 if (! do_debug_frames_interp || *reg_prefix != '\0')
6369 printf (" DW_CFA_restore_extended: %s%s\n",
6370 reg_prefix, regname (reg, 0));
6371 if (*reg_prefix == '\0')
6373 fc->col_type[reg] = cie->col_type[reg];
6374 fc->col_offset[reg] = cie->col_offset[reg];
6378 case DW_CFA_undefined:
6380 if (reg >= (unsigned int) fc->ncols)
6381 reg_prefix = bad_reg;
6382 if (! do_debug_frames_interp || *reg_prefix != '\0')
6383 printf (" DW_CFA_undefined: %s%s\n",
6384 reg_prefix, regname (reg, 0));
6385 if (*reg_prefix == '\0')
6387 fc->col_type[reg] = DW_CFA_undefined;
6388 fc->col_offset[reg] = 0;
6392 case DW_CFA_same_value:
6394 if (reg >= (unsigned int) fc->ncols)
6395 reg_prefix = bad_reg;
6396 if (! do_debug_frames_interp || *reg_prefix != '\0')
6397 printf (" DW_CFA_same_value: %s%s\n",
6398 reg_prefix, regname (reg, 0));
6399 if (*reg_prefix == '\0')
6401 fc->col_type[reg] = DW_CFA_same_value;
6402 fc->col_offset[reg] = 0;
6406 case DW_CFA_register:
6409 if (reg >= (unsigned int) fc->ncols)
6410 reg_prefix = bad_reg;
6411 if (! do_debug_frames_interp || *reg_prefix != '\0')
6413 printf (" DW_CFA_register: %s%s in ",
6414 reg_prefix, regname (reg, 0));
6415 puts (regname (roffs, 0));
6417 if (*reg_prefix == '\0')
6419 fc->col_type[reg] = DW_CFA_register;
6420 fc->col_offset[reg] = roffs;
6424 case DW_CFA_remember_state:
6425 if (! do_debug_frames_interp)
6426 printf (" DW_CFA_remember_state\n");
6427 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6428 rs->cfa_offset = fc->cfa_offset;
6429 rs->cfa_reg = fc->cfa_reg;
6431 rs->cfa_exp = fc->cfa_exp;
6432 rs->ncols = fc->ncols;
6433 rs->col_type = (short int *) xcmalloc (rs->ncols,
6434 sizeof (* rs->col_type));
6435 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6436 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6437 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6438 rs->next = remembered_state;
6439 remembered_state = rs;
6442 case DW_CFA_restore_state:
6443 if (! do_debug_frames_interp)
6444 printf (" DW_CFA_restore_state\n");
6445 rs = remembered_state;
6448 remembered_state = rs->next;
6449 fc->cfa_offset = rs->cfa_offset;
6450 fc->cfa_reg = rs->cfa_reg;
6452 fc->cfa_exp = rs->cfa_exp;
6453 if (frame_need_space (fc, rs->ncols - 1) < 0)
6455 warn (_("Invalid column number in saved frame state\n"));
6459 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6460 memcpy (fc->col_offset, rs->col_offset,
6461 rs->ncols * sizeof (* rs->col_offset));
6462 free (rs->col_type);
6463 free (rs->col_offset);
6466 else if (do_debug_frames_interp)
6467 printf ("Mismatched DW_CFA_restore_state\n");
6470 case DW_CFA_def_cfa:
6471 fc->cfa_reg = LEB ();
6472 fc->cfa_offset = LEB ();
6474 if (! do_debug_frames_interp)
6475 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6476 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6479 case DW_CFA_def_cfa_register:
6480 fc->cfa_reg = LEB ();
6482 if (! do_debug_frames_interp)
6483 printf (" DW_CFA_def_cfa_register: %s\n",
6484 regname (fc->cfa_reg, 0));
6487 case DW_CFA_def_cfa_offset:
6488 fc->cfa_offset = LEB ();
6489 if (! do_debug_frames_interp)
6490 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
6494 if (! do_debug_frames_interp)
6495 printf (" DW_CFA_nop\n");
6498 case DW_CFA_def_cfa_expression:
6500 if (start >= block_end || ul > (unsigned long) (block_end - start))
6502 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6505 if (! do_debug_frames_interp)
6507 printf (" DW_CFA_def_cfa_expression (");
6508 decode_location_expression (start, eh_addr_size, 0, -1,
6516 case DW_CFA_expression:
6519 if (reg >= (unsigned int) fc->ncols)
6520 reg_prefix = bad_reg;
6521 /* PR 17512: file: 069-133014-0.006. */
6522 /* PR 17512: file: 98c02eb4. */
6524 if (start >= block_end || tmp > block_end || tmp < start)
6526 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6529 if (! do_debug_frames_interp || *reg_prefix != '\0')
6531 printf (" DW_CFA_expression: %s%s (",
6532 reg_prefix, regname (reg, 0));
6533 decode_location_expression (start, eh_addr_size, 0, -1,
6537 if (*reg_prefix == '\0')
6538 fc->col_type[reg] = DW_CFA_expression;
6542 case DW_CFA_val_expression:
6545 if (reg >= (unsigned int) fc->ncols)
6546 reg_prefix = bad_reg;
6548 if (start >= block_end || tmp > block_end || tmp < start)
6550 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6553 if (! do_debug_frames_interp || *reg_prefix != '\0')
6555 printf (" DW_CFA_val_expression: %s%s (",
6556 reg_prefix, regname (reg, 0));
6557 decode_location_expression (start, eh_addr_size, 0, -1,
6561 if (*reg_prefix == '\0')
6562 fc->col_type[reg] = DW_CFA_val_expression;
6566 case DW_CFA_offset_extended_sf:
6569 if (frame_need_space (fc, reg) < 0)
6570 reg_prefix = bad_reg;
6571 if (! do_debug_frames_interp || *reg_prefix != '\0')
6572 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6573 reg_prefix, regname (reg, 0),
6574 (long)(l * fc->data_factor));
6575 if (*reg_prefix == '\0')
6577 fc->col_type[reg] = DW_CFA_offset;
6578 fc->col_offset[reg] = l * fc->data_factor;
6582 case DW_CFA_val_offset_sf:
6585 if (frame_need_space (fc, reg) < 0)
6586 reg_prefix = bad_reg;
6587 if (! do_debug_frames_interp || *reg_prefix != '\0')
6588 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6589 reg_prefix, regname (reg, 0),
6590 (long)(l * fc->data_factor));
6591 if (*reg_prefix == '\0')
6593 fc->col_type[reg] = DW_CFA_val_offset;
6594 fc->col_offset[reg] = l * fc->data_factor;
6598 case DW_CFA_def_cfa_sf:
6599 fc->cfa_reg = LEB ();
6600 fc->cfa_offset = SLEB ();
6601 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6603 if (! do_debug_frames_interp)
6604 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6605 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6608 case DW_CFA_def_cfa_offset_sf:
6609 fc->cfa_offset = SLEB ();
6610 fc->cfa_offset *= fc->data_factor;
6611 if (! do_debug_frames_interp)
6612 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
6615 case DW_CFA_MIPS_advance_loc8:
6616 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6617 if (do_debug_frames_interp)
6618 frame_display_row (fc, &need_col_headers, &max_regs);
6620 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6621 (unsigned long) (ofs * fc->code_factor),
6622 dwarf_vmatoa_1 (NULL,
6623 fc->pc_begin + ofs * fc->code_factor,
6625 fc->pc_begin += ofs * fc->code_factor;
6628 case DW_CFA_GNU_window_save:
6629 if (! do_debug_frames_interp)
6630 printf (" DW_CFA_GNU_window_save\n");
6633 case DW_CFA_GNU_args_size:
6635 if (! do_debug_frames_interp)
6636 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6639 case DW_CFA_GNU_negative_offset_extended:
6642 if (frame_need_space (fc, reg) < 0)
6643 reg_prefix = bad_reg;
6644 if (! do_debug_frames_interp || *reg_prefix != '\0')
6645 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6646 reg_prefix, regname (reg, 0),
6647 (long)(l * fc->data_factor));
6648 if (*reg_prefix == '\0')
6650 fc->col_type[reg] = DW_CFA_offset;
6651 fc->col_offset[reg] = l * fc->data_factor;
6656 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6657 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6659 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6664 if (do_debug_frames_interp)
6665 frame_display_row (fc, &need_col_headers, &max_regs);
6668 eh_addr_size = saved_eh_addr_size;
6681 display_gdb_index (struct dwarf_section *section,
6682 void *file ATTRIBUTE_UNUSED)
6684 unsigned char *start = section->start;
6686 uint32_t cu_list_offset, tu_list_offset;
6687 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6688 unsigned int cu_list_elements, tu_list_elements;
6689 unsigned int address_table_size, symbol_table_slots;
6690 unsigned char *cu_list, *tu_list;
6691 unsigned char *address_table, *symbol_table, *constant_pool;
6694 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6696 printf (_("Contents of the %s section:\n"), section->name);
6698 if (section->size < 6 * sizeof (uint32_t))
6700 warn (_("Truncated header in the %s section.\n"), section->name);
6704 version = byte_get_little_endian (start, 4);
6705 printf (_("Version %ld\n"), (long) version);
6707 /* Prior versions are obsolete, and future versions may not be
6708 backwards compatible. */
6709 if (version < 3 || version > 8)
6711 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6715 warn (_("The address table data in version 3 may be wrong.\n"));
6717 warn (_("Version 4 does not support case insensitive lookups.\n"));
6719 warn (_("Version 5 does not include inlined functions.\n"));
6721 warn (_("Version 6 does not include symbol attributes.\n"));
6722 /* Version 7 indices generated by Gold have bad type unit references,
6723 PR binutils/15021. But we don't know if the index was generated by
6724 Gold or not, so to avoid worrying users with gdb-generated indices
6725 we say nothing for version 7 here. */
6727 cu_list_offset = byte_get_little_endian (start + 4, 4);
6728 tu_list_offset = byte_get_little_endian (start + 8, 4);
6729 address_table_offset = byte_get_little_endian (start + 12, 4);
6730 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6731 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6733 if (cu_list_offset > section->size
6734 || tu_list_offset > section->size
6735 || address_table_offset > section->size
6736 || symbol_table_offset > section->size
6737 || constant_pool_offset > section->size)
6739 warn (_("Corrupt header in the %s section.\n"), section->name);
6743 /* PR 17531: file: 418d0a8a. */
6744 if (tu_list_offset < cu_list_offset)
6746 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6747 tu_list_offset, cu_list_offset);
6751 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6753 if (address_table_offset < tu_list_offset)
6755 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6756 address_table_offset, tu_list_offset);
6760 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6762 /* PR 17531: file: 18a47d3d. */
6763 if (symbol_table_offset < address_table_offset)
6765 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6766 symbol_table_offset, address_table_offset);
6770 address_table_size = symbol_table_offset - address_table_offset;
6772 if (constant_pool_offset < symbol_table_offset)
6774 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6775 constant_pool_offset, symbol_table_offset);
6779 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6781 cu_list = start + cu_list_offset;
6782 tu_list = start + tu_list_offset;
6783 address_table = start + address_table_offset;
6784 symbol_table = start + symbol_table_offset;
6785 constant_pool = start + constant_pool_offset;
6787 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6789 warn (_("Address table extends beyond end of section.\n"));
6793 printf (_("\nCU table:\n"));
6794 for (i = 0; i < cu_list_elements; i += 2)
6796 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6797 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6799 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6800 (unsigned long) cu_offset,
6801 (unsigned long) (cu_offset + cu_length - 1));
6804 printf (_("\nTU table:\n"));
6805 for (i = 0; i < tu_list_elements; i += 3)
6807 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6808 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6809 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6811 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6812 (unsigned long) tu_offset,
6813 (unsigned long) type_offset);
6814 print_dwarf_vma (signature, 8);
6818 printf (_("\nAddress table:\n"));
6819 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6822 uint64_t low = byte_get_little_endian (address_table + i, 8);
6823 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6824 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6826 print_dwarf_vma (low, 8);
6827 print_dwarf_vma (high, 8);
6828 printf (_("%lu\n"), (unsigned long) cu_index);
6831 printf (_("\nSymbol table:\n"));
6832 for (i = 0; i < symbol_table_slots; ++i)
6834 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6835 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6836 uint32_t num_cus, cu;
6838 if (name_offset != 0
6839 || cu_vector_offset != 0)
6842 unsigned char * adr;
6844 adr = constant_pool + name_offset;
6845 /* PR 17531: file: 5b7b07ad. */
6846 if (adr < constant_pool || adr >= section->start + section->size)
6848 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6849 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6853 printf ("[%3u] %.*s:", i,
6854 (int) (section->size - (constant_pool_offset + name_offset)),
6855 constant_pool + name_offset);
6857 adr = constant_pool + cu_vector_offset;
6858 if (adr < constant_pool || adr >= section->start + section->size - 3)
6860 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6861 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6862 cu_vector_offset, i);
6866 num_cus = byte_get_little_endian (adr, 4);
6868 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
6869 if (num_cus * 4 < num_cus
6870 || adr >= section->start + section->size
6871 || adr < constant_pool)
6873 printf ("<invalid number of CUs: %d>\n", num_cus);
6874 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6882 for (j = 0; j < num_cus; ++j)
6885 gdb_index_symbol_kind kind;
6887 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6888 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6889 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6890 cu = GDB_INDEX_CU_VALUE (cu);
6891 /* Convert to TU number if it's for a type unit. */
6892 if (cu >= cu_list_elements / 2)
6893 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6894 (unsigned long) (cu - cu_list_elements / 2));
6896 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6898 printf (" [%s, %s]",
6899 is_static ? _("static") : _("global"),
6900 get_gdb_index_symbol_kind_name (kind));
6912 /* Pre-allocate enough space for the CU/TU sets needed. */
6915 prealloc_cu_tu_list (unsigned int nshndx)
6917 if (shndx_pool == NULL)
6919 shndx_pool_size = nshndx;
6920 shndx_pool_used = 0;
6921 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6922 sizeof (unsigned int));
6926 shndx_pool_size = shndx_pool_used + nshndx;
6927 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6928 sizeof (unsigned int));
6933 add_shndx_to_cu_tu_entry (unsigned int shndx)
6935 if (shndx_pool_used >= shndx_pool_size)
6937 error (_("Internal error: out of space in the shndx pool.\n"));
6940 shndx_pool [shndx_pool_used++] = shndx;
6944 end_cu_tu_entry (void)
6946 if (shndx_pool_used >= shndx_pool_size)
6948 error (_("Internal error: out of space in the shndx pool.\n"));
6951 shndx_pool [shndx_pool_used++] = 0;
6954 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6957 get_DW_SECT_short_name (unsigned int dw_sect)
6959 static char buf[16];
6967 case DW_SECT_ABBREV:
6973 case DW_SECT_STR_OFFSETS:
6975 case DW_SECT_MACINFO:
6983 snprintf (buf, sizeof (buf), "%d", dw_sect);
6987 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6988 These sections are extensions for Fission.
6989 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6992 process_cu_tu_index (struct dwarf_section *section, int do_display)
6994 unsigned char *phdr = section->start;
6995 unsigned char *limit = phdr + section->size;
6996 unsigned char *phash;
6997 unsigned char *pindex;
6998 unsigned char *ppool;
6999 unsigned int version;
7000 unsigned int ncols = 0;
7002 unsigned int nslots;
7005 dwarf_vma signature_high;
7006 dwarf_vma signature_low;
7009 /* PR 17512: file: 002-168123-0.004. */
7012 warn (_("Section %s is empty\n"), section->name);
7015 /* PR 17512: file: 002-376-0.004. */
7016 if (section->size < 24)
7018 warn (_("Section %s is too small to contain a CU/TU header\n"),
7023 SAFE_BYTE_GET (version, phdr, 4, limit);
7025 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
7026 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
7027 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
7030 pindex = phash + nslots * 8;
7031 ppool = pindex + nslots * 4;
7033 /* PR 17531: file: 45d69832. */
7034 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
7036 warn (_("Section %s is too small for %d slots\n"),
7037 section->name, nslots);
7043 printf (_("Contents of the %s section:\n\n"), section->name);
7044 printf (_(" Version: %d\n"), version);
7046 printf (_(" Number of columns: %d\n"), ncols);
7047 printf (_(" Number of used entries: %d\n"), nused);
7048 printf (_(" Number of slots: %d\n\n"), nslots);
7051 if (ppool > limit || ppool < phdr)
7053 warn (_("Section %s too small for %d hash table entries\n"),
7054 section->name, nslots);
7061 prealloc_cu_tu_list ((limit - ppool) / 4);
7062 for (i = 0; i < nslots; i++)
7064 unsigned char *shndx_list;
7067 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
7068 if (signature_high != 0 || signature_low != 0)
7070 SAFE_BYTE_GET (j, pindex, 4, limit);
7071 shndx_list = ppool + j * 4;
7072 /* PR 17531: file: 705e010d. */
7073 if (shndx_list < ppool)
7075 warn (_("Section index pool located before start of section\n"));
7080 printf (_(" [%3d] Signature: 0x%s Sections: "),
7081 i, dwarf_vmatoa64 (signature_high, signature_low,
7082 buf, sizeof (buf)));
7085 if (shndx_list >= limit)
7087 warn (_("Section %s too small for shndx pool\n"),
7091 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
7095 printf (" %d", shndx);
7097 add_shndx_to_cu_tu_entry (shndx);
7109 else if (version == 2)
7112 unsigned int dw_sect;
7113 unsigned char *ph = phash;
7114 unsigned char *pi = pindex;
7115 unsigned char *poffsets = ppool + ncols * 4;
7116 unsigned char *psizes = poffsets + nused * ncols * 4;
7117 unsigned char *pend = psizes + nused * ncols * 4;
7118 bfd_boolean is_tu_index;
7119 struct cu_tu_set *this_set = NULL;
7121 unsigned char *prow;
7123 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7125 /* PR 17531: file: 0dd159bf.
7126 Check for wraparound with an overlarge ncols value. */
7127 if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
7129 warn (_("Overlarge number of columns: %x\n"), ncols);
7135 warn (_("Section %s too small for offset and size tables\n"),
7142 printf (_(" Offset table\n"));
7143 printf (" slot %-16s ",
7144 is_tu_index ? _("signature") : _("dwo_id"));
7151 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7157 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7164 for (j = 0; j < ncols; j++)
7166 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7167 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7172 for (i = 0; i < nslots; i++)
7174 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7176 SAFE_BYTE_GET (row, pi, 4, limit);
7179 /* PR 17531: file: a05f6ab3. */
7182 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7188 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7190 prow = poffsets + (row - 1) * ncols * 4;
7191 /* PR 17531: file: b8ce60a8. */
7192 if (prow < poffsets || prow > limit)
7194 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7200 printf (_(" [%3d] 0x%s"),
7201 i, dwarf_vmatoa64 (signature_high, signature_low,
7202 buf, sizeof (buf)));
7203 for (j = 0; j < ncols; j++)
7205 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7207 printf (" %8d", val);
7210 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7212 /* PR 17531: file: 10796eb3. */
7213 if (dw_sect >= DW_SECT_MAX)
7214 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7216 this_set [row - 1].section_offsets [dw_sect] = val;
7232 printf (_(" Size table\n"));
7233 printf (" slot %-16s ",
7234 is_tu_index ? _("signature") : _("dwo_id"));
7237 for (j = 0; j < ncols; j++)
7239 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7241 printf (" %8s", get_DW_SECT_short_name (val));
7247 for (i = 0; i < nslots; i++)
7249 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7251 SAFE_BYTE_GET (row, pi, 4, limit);
7254 prow = psizes + (row - 1) * ncols * 4;
7257 printf (_(" [%3d] 0x%s"),
7258 i, dwarf_vmatoa64 (signature_high, signature_low,
7259 buf, sizeof (buf)));
7261 for (j = 0; j < ncols; j++)
7263 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7265 printf (" %8d", val);
7268 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7269 if (dw_sect >= DW_SECT_MAX)
7270 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7272 this_set [row - 1].section_sizes [dw_sect] = val;
7284 else if (do_display)
7285 printf (_(" Unsupported version (%d)\n"), version);
7293 /* Load the CU and TU indexes if present. This will build a list of
7294 section sets that we can use to associate a .debug_info.dwo section
7295 with its associated .debug_abbrev.dwo section in a .dwp file. */
7298 load_cu_tu_indexes (void *file)
7300 /* If we have already loaded (or tried to load) the CU and TU indexes
7301 then do not bother to repeat the task. */
7302 if (cu_tu_indexes_read)
7305 if (load_debug_section (dwp_cu_index, file))
7306 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7308 if (load_debug_section (dwp_tu_index, file))
7309 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7311 cu_tu_indexes_read = 1;
7314 /* Find the set of sections that includes section SHNDX. */
7317 find_cu_tu_set (void *file, unsigned int shndx)
7321 load_cu_tu_indexes (file);
7323 /* Find SHNDX in the shndx pool. */
7324 for (i = 0; i < shndx_pool_used; i++)
7325 if (shndx_pool [i] == shndx)
7328 if (i >= shndx_pool_used)
7331 /* Now backup to find the first entry in the set. */
7332 while (i > 0 && shndx_pool [i - 1] != 0)
7335 return shndx_pool + i;
7338 /* Display a .debug_cu_index or .debug_tu_index section. */
7341 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7343 return process_cu_tu_index (section, 1);
7347 display_debug_not_supported (struct dwarf_section *section,
7348 void *file ATTRIBUTE_UNUSED)
7350 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7356 /* Like malloc, but takes two parameters like calloc.
7357 Verifies that the first parameter is not too large.
7358 Note: does *not* initialise the allocated memory to zero. */
7360 cmalloc (size_t nmemb, size_t size)
7362 /* Check for overflow. */
7363 if (nmemb >= ~(size_t) 0 / size)
7366 return xmalloc (nmemb * size);
7369 /* Like xmalloc, but takes two parameters like calloc.
7370 Verifies that the first parameter is not too large.
7371 Note: does *not* initialise the allocated memory to zero. */
7373 xcmalloc (size_t nmemb, size_t size)
7375 /* Check for overflow. */
7376 if (nmemb >= ~(size_t) 0 / size)
7379 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7384 return xmalloc (nmemb * size);
7387 /* Like xrealloc, but takes three parameters.
7388 Verifies that the second parameter is not too large.
7389 Note: does *not* initialise any new memory to zero. */
7391 xcrealloc (void *ptr, size_t nmemb, size_t size)
7393 /* Check for overflow. */
7394 if (nmemb >= ~(size_t) 0 / size)
7397 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7402 return xrealloc (ptr, nmemb * size);
7405 /* Like xcalloc, but verifies that the first parameter is not too large. */
7407 xcalloc2 (size_t nmemb, size_t size)
7409 /* Check for overflow. */
7410 if (nmemb >= ~(size_t) 0 / size)
7413 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7418 return xcalloc (nmemb, size);
7422 free_debug_memory (void)
7428 for (i = 0; i < max; i++)
7429 free_debug_section ((enum dwarf_section_display_enum) i);
7431 if (debug_information != NULL)
7433 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7435 for (i = 0; i < num_debug_info_entries; i++)
7437 if (!debug_information [i].max_loc_offsets)
7439 free (debug_information [i].loc_offsets);
7440 free (debug_information [i].have_frame_base);
7442 if (!debug_information [i].max_range_lists)
7443 free (debug_information [i].range_lists);
7446 free (debug_information);
7447 debug_information = NULL;
7448 alloc_num_debug_info_entries = num_debug_info_entries = 0;
7453 dwarf_select_sections_by_names (const char *names)
7457 const char * option;
7461 debug_dump_long_opts;
7463 static const debug_dump_long_opts opts_table [] =
7465 /* Please keep this table alpha- sorted. */
7466 { "Ranges", & do_debug_ranges, 1 },
7467 { "abbrev", & do_debug_abbrevs, 1 },
7468 { "addr", & do_debug_addr, 1 },
7469 { "aranges", & do_debug_aranges, 1 },
7470 { "cu_index", & do_debug_cu_index, 1 },
7471 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7472 { "frames", & do_debug_frames, 1 },
7473 { "frames-interp", & do_debug_frames_interp, 1 },
7474 /* The special .gdb_index section. */
7475 { "gdb_index", & do_gdb_index, 1 },
7476 { "info", & do_debug_info, 1 },
7477 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
7478 { "loc", & do_debug_loc, 1 },
7479 { "macro", & do_debug_macinfo, 1 },
7480 { "pubnames", & do_debug_pubnames, 1 },
7481 { "pubtypes", & do_debug_pubtypes, 1 },
7482 /* This entry is for compatability
7483 with earlier versions of readelf. */
7484 { "ranges", & do_debug_aranges, 1 },
7485 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7486 { "str", & do_debug_str, 1 },
7487 /* These trace_* sections are used by Itanium VMS. */
7488 { "trace_abbrev", & do_trace_abbrevs, 1 },
7489 { "trace_aranges", & do_trace_aranges, 1 },
7490 { "trace_info", & do_trace_info, 1 },
7499 const debug_dump_long_opts * entry;
7501 for (entry = opts_table; entry->option; entry++)
7503 size_t len = strlen (entry->option);
7505 if (strncmp (p, entry->option, len) == 0
7506 && (p[len] == ',' || p[len] == '\0'))
7508 * entry->variable |= entry->val;
7510 /* The --debug-dump=frames-interp option also
7511 enables the --debug-dump=frames option. */
7512 if (do_debug_frames_interp)
7513 do_debug_frames = 1;
7520 if (entry->option == NULL)
7522 warn (_("Unrecognized debug option '%s'\n"), p);
7523 p = strchr (p, ',');
7534 dwarf_select_sections_by_letters (const char *letters)
7536 unsigned int lindex = 0;
7538 while (letters[lindex])
7539 switch (letters[lindex++])
7546 do_debug_abbrevs = 1;
7550 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7554 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7558 do_debug_pubnames = 1;
7562 do_debug_pubtypes = 1;
7566 do_debug_aranges = 1;
7570 do_debug_ranges = 1;
7574 do_debug_frames_interp = 1;
7576 do_debug_frames = 1;
7580 do_debug_macinfo = 1;
7592 warn (_("Unrecognized debug option '%s'\n"), letters);
7598 dwarf_select_sections_all (void)
7601 do_debug_abbrevs = 1;
7602 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7603 do_debug_pubnames = 1;
7604 do_debug_pubtypes = 1;
7605 do_debug_aranges = 1;
7606 do_debug_ranges = 1;
7607 do_debug_frames = 1;
7608 do_debug_macinfo = 1;
7613 do_trace_abbrevs = 1;
7614 do_trace_aranges = 1;
7616 do_debug_cu_index = 1;
7619 struct dwarf_section_display debug_displays[] =
7621 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7622 display_debug_abbrev, &do_debug_abbrevs, FALSE },
7623 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7624 display_debug_aranges, &do_debug_aranges, TRUE },
7625 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7626 display_debug_frames, &do_debug_frames, TRUE },
7627 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
7628 display_debug_info, &do_debug_info, TRUE },
7629 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7630 display_debug_lines, &do_debug_lines, TRUE },
7631 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7632 display_debug_pubnames, &do_debug_pubnames, FALSE },
7633 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7634 display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
7635 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7636 display_debug_frames, &do_debug_frames, TRUE },
7637 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7638 display_debug_macinfo, &do_debug_macinfo, FALSE },
7639 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7640 display_debug_macro, &do_debug_macinfo, TRUE },
7641 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7642 display_debug_str, &do_debug_str, FALSE },
7643 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7644 display_debug_loc, &do_debug_loc, TRUE },
7645 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7646 display_debug_pubnames, &do_debug_pubtypes, FALSE },
7647 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7648 display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
7649 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7650 display_debug_ranges, &do_debug_ranges, TRUE },
7651 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7652 display_debug_not_supported, NULL, FALSE },
7653 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7654 display_debug_not_supported, NULL, FALSE },
7655 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
7656 display_debug_types, &do_debug_info, TRUE },
7657 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7658 display_debug_not_supported, NULL, FALSE },
7659 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7660 display_gdb_index, &do_gdb_index, FALSE },
7661 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
7662 display_trace_info, &do_trace_info, TRUE },
7663 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7664 display_debug_abbrev, &do_trace_abbrevs, FALSE },
7665 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7666 display_debug_aranges, &do_trace_aranges, FALSE },
7667 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
7668 display_debug_info, &do_debug_info, TRUE },
7669 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7670 display_debug_abbrev, &do_debug_abbrevs, FALSE },
7671 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
7672 display_debug_types, &do_debug_info, TRUE },
7673 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7674 display_debug_lines, &do_debug_lines, TRUE },
7675 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7676 display_debug_loc, &do_debug_loc, TRUE },
7677 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7678 display_debug_macro, &do_debug_macinfo, TRUE },
7679 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7680 display_debug_macinfo, &do_debug_macinfo, FALSE },
7681 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7682 display_debug_str, &do_debug_str, TRUE },
7683 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7684 display_debug_str_offsets, NULL, FALSE },
7685 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7686 display_debug_str_offsets, NULL, FALSE },
7687 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7688 display_debug_addr, &do_debug_addr, TRUE },
7689 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7690 display_cu_index, &do_debug_cu_index, FALSE },
7691 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7692 display_cu_index, &do_debug_cu_index, FALSE },