1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2020 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"
31 #include "filenames.h"
32 #include "safe-ctype.h"
35 #ifdef HAVE_LIBDEBUGINFOD
36 #include <elfutils/debuginfod.h>
41 #define MAX(a, b) ((a) > (b) ? (a) : (b))
42 #define MIN(a, b) ((a) < (b) ? (a) : (b))
44 static const char *regname (unsigned int regno
, int row
);
45 static const char *regname_internal_by_table_only (unsigned int regno
);
47 static int have_frame_base
;
48 static int need_base_address
;
50 static unsigned int num_debug_info_entries
= 0;
51 static unsigned int alloc_num_debug_info_entries
= 0;
52 static debug_info
*debug_information
= NULL
;
53 /* Special value for num_debug_info_entries to indicate
54 that the .debug_info section could not be loaded/parsed. */
55 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
57 /* A .debug_info section can contain multiple links to separate
58 DWO object files. We use these structures to record these links. */
66 typedef struct dwo_info
70 struct dwo_info
* next
;
73 static dwo_info
* first_dwo_info
= NULL
;
74 static bfd_boolean need_dwo_info
;
76 separate_info
* first_separate_info
= NULL
;
78 unsigned int eh_addr_size
;
83 int do_debug_pubnames
;
84 int do_debug_pubtypes
;
88 int do_debug_frames_interp
;
97 int do_debug_cu_index
;
101 bfd_boolean do_checks
;
103 int dwarf_cutoff_level
= -1;
104 unsigned long dwarf_start_die
;
108 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
109 testing whether e.g. a locview list is present. */
110 static const dwarf_vma vm1
= -1;
112 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
113 sections. For version 1 package files, each set is stored in SHNDX_POOL
114 as a zero-terminated list of section indexes comprising one set of debug
115 sections from a .dwo file. */
117 static unsigned int *shndx_pool
= NULL
;
118 static unsigned int shndx_pool_size
= 0;
119 static unsigned int shndx_pool_used
= 0;
121 /* For version 2 package files, each set contains an array of section offsets
122 and an array of section sizes, giving the offset and size of the
123 contribution from a CU or TU within one of the debug sections.
124 When displaying debug info from a package file, we need to use these
125 tables to locate the corresponding contributions to each section. */
130 dwarf_vma section_offsets
[DW_SECT_MAX
];
131 size_t section_sizes
[DW_SECT_MAX
];
134 static int cu_count
= 0;
135 static int tu_count
= 0;
136 static struct cu_tu_set
*cu_sets
= NULL
;
137 static struct cu_tu_set
*tu_sets
= NULL
;
139 static bfd_boolean
load_cu_tu_indexes (void *);
141 /* An array that indicates for a given level of CU nesting whether
142 the latest DW_AT_type seen for that level was a signed type or
144 #define MAX_CU_NESTING (1 << 8)
145 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
147 /* Values for do_debug_lines. */
148 #define FLAG_DEBUG_LINES_RAW 1
149 #define FLAG_DEBUG_LINES_DECODED 2
152 size_of_encoded_value (int encoding
)
154 switch (encoding
& 0x7)
157 case 0: return eh_addr_size
;
165 get_encoded_value (unsigned char **pdata
,
167 struct dwarf_section
*section
,
170 unsigned char * data
= * pdata
;
171 unsigned int size
= size_of_encoded_value (encoding
);
174 if (data
+ size
>= end
)
176 warn (_("Encoded value extends past end of section\n"));
181 /* PR 17512: file: 002-829853-0.004. */
184 warn (_("Encoded size of %d is too large to read\n"), size
);
189 /* PR 17512: file: 1085-5603-0.004. */
192 warn (_("Encoded size of 0 is too small to read\n"));
197 if (encoding
& DW_EH_PE_signed
)
198 val
= byte_get_signed (data
, size
);
200 val
= byte_get (data
, size
);
202 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
203 val
+= section
->address
+ (data
- section
->start
);
205 * pdata
= data
+ size
;
209 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
211 # define DWARF_VMA_FMT "ll"
212 # define DWARF_VMA_FMT_LONG "%16.16llx"
214 # define DWARF_VMA_FMT "I64"
215 # define DWARF_VMA_FMT_LONG "%016I64x"
218 # define DWARF_VMA_FMT "l"
219 # define DWARF_VMA_FMT_LONG "%16.16lx"
222 /* Convert a dwarf vma value into a string. Returns a pointer to a static
223 buffer containing the converted VALUE. The value is converted according
224 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
225 it specifies the maximum number of bytes to be displayed in the converted
226 value and FMTCH is ignored - hex is always used. */
229 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
231 /* As dwarf_vmatoa is used more then once in a printf call
232 for output, we are cycling through an fixed array of pointers
233 for return address. */
234 static int buf_pos
= 0;
235 static struct dwarf_vmatoa_buf
241 ret
= buf
[buf_pos
++].place
;
242 buf_pos
%= ARRAY_SIZE (buf
);
246 /* Printf does not have a way of specifying a maximum field width for an
247 integer value, so we print the full value into a buffer and then select
248 the precision we need. */
249 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
252 return ret
+ (16 - 2 * num_bytes
);
259 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
261 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
262 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
267 static inline const char *
268 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
270 return dwarf_vmatoa_1 (fmtch
, value
, 0);
273 /* Print a dwarf_vma value (typically an address, offset or length) in
274 hexadecimal format, followed by a space. The length of the VALUE (and
275 hence the precision displayed) is determined by the NUM_BYTES parameter. */
278 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
280 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
283 /* Print a view number in hexadecimal value, with the same width
284 print_dwarf_vma would have printed it with the same num_bytes.
285 Print blanks for zero view, unless force is nonzero. */
288 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
296 assert (value
== (unsigned long) value
);
298 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
300 printf ("%*s", len
+ 1, "");
303 /* Format a 64-bit value, given as two 32-bit values, in hex.
304 For reentrancy, this uses a buffer provided by the caller. */
307 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
308 unsigned int buf_len
)
313 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
316 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
317 snprintf (buf
+ len
, buf_len
- len
,
318 "%08" DWARF_VMA_FMT
"x", lvalue
);
324 /* Read in a LEB128 encoded value starting at address DATA.
325 If SIGN is true, return a signed LEB128 value.
326 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
327 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
328 terminating byte was not found and with bit 1 set if the value
329 overflows a dwarf_vma.
330 No bytes will be read at address END or beyond. */
333 read_leb128 (unsigned char *data
,
334 const unsigned char *const end
,
336 unsigned int *length_return
,
339 dwarf_vma result
= 0;
340 unsigned int num_read
= 0;
341 unsigned int shift
= 0;
346 unsigned char byte
= *data
++;
349 if (shift
< sizeof (result
) * 8)
351 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
352 if ((result
>> shift
) != (byte
& 0x7f))
357 else if ((byte
& 0x7f) != 0)
360 if ((byte
& 0x80) == 0)
363 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
364 result
|= -((dwarf_vma
) 1 << shift
);
369 if (length_return
!= NULL
)
370 *length_return
= num_read
;
371 if (status_return
!= NULL
)
372 *status_return
= status
;
377 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
378 Checks to make sure that the read will not reach or pass END
379 and that VAL is big enough to hold AMOUNT bytes. */
380 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
383 unsigned int amount = (AMOUNT); \
384 if (sizeof (VAL) < amount) \
386 error (ngettext ("internal error: attempt to read %d byte " \
387 "of data in to %d sized variable", \
388 "internal error: attempt to read %d bytes " \
389 "of data in to %d sized variable", \
391 amount, (int) sizeof (VAL)); \
392 amount = sizeof (VAL); \
394 if (((PTR) + amount) >= (END)) \
397 amount = (END) - (PTR); \
401 if (amount == 0 || amount > 8) \
404 VAL = byte_get ((PTR), amount); \
408 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
409 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
412 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
417 /* Like SAFE_BYTE_GET, but reads a signed value. */
418 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
421 unsigned int amount = (AMOUNT); \
422 if (((PTR) + amount) >= (END)) \
425 amount = (END) - (PTR); \
430 VAL = byte_get_signed ((PTR), amount); \
436 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
437 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
440 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
445 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
448 if (((PTR) + 8) <= (END)) \
450 byte_get_64 ((PTR), (HIGH), (LOW)); \
454 * (LOW) = * (HIGH) = 0; \
459 typedef struct State_Machine_Registers
468 unsigned char op_index
;
469 unsigned char end_sequence
;
470 /* This variable hold the number of the last entry seen
471 in the File Table. */
472 unsigned int last_file_entry
;
475 static SMR state_machine_regs
;
478 reset_state_machine (int is_stmt
)
480 state_machine_regs
.address
= 0;
481 state_machine_regs
.view
= 0;
482 state_machine_regs
.op_index
= 0;
483 state_machine_regs
.file
= 1;
484 state_machine_regs
.line
= 1;
485 state_machine_regs
.column
= 0;
486 state_machine_regs
.is_stmt
= is_stmt
;
487 state_machine_regs
.basic_block
= 0;
488 state_machine_regs
.end_sequence
= 0;
489 state_machine_regs
.last_file_entry
= 0;
492 /* Handled an extend line op.
493 Returns the number of bytes read. */
496 process_extended_line_op (unsigned char * data
,
500 unsigned char op_code
;
501 size_t len
, header_len
;
503 unsigned char *orig_data
= data
;
506 READ_ULEB (len
, data
, end
);
507 header_len
= data
- orig_data
;
509 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
511 warn (_("Badly formed extended line op encountered!\n"));
517 printf (_(" Extended opcode %d: "), op_code
);
521 case DW_LNE_end_sequence
:
522 printf (_("End of Sequence\n\n"));
523 reset_state_machine (is_stmt
);
526 case DW_LNE_set_address
:
527 /* PR 17512: file: 002-100480-0.004. */
530 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
531 (unsigned long) len
- 1);
535 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
536 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
537 state_machine_regs
.address
= adr
;
538 state_machine_regs
.view
= 0;
539 state_machine_regs
.op_index
= 0;
542 case DW_LNE_define_file
:
543 printf (_("define new File Table entry\n"));
544 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
545 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
551 l
= strnlen ((char *) data
, end
- data
);
553 READ_ULEB (val
, data
, end
);
554 printf ("%s\t", dwarf_vmatoa ("u", val
));
555 READ_ULEB (val
, data
, end
);
556 printf ("%s\t", dwarf_vmatoa ("u", val
));
557 READ_ULEB (val
, data
, end
);
558 printf ("%s\t", dwarf_vmatoa ("u", val
));
559 printf ("%.*s\n\n", (int) l
, name
);
562 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
563 warn (_("DW_LNE_define_file: Bad opcode length\n"));
566 case DW_LNE_set_discriminator
:
567 READ_ULEB (val
, data
, end
);
568 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
572 case DW_LNE_HP_negate_is_UV_update
:
573 printf ("DW_LNE_HP_negate_is_UV_update\n");
575 case DW_LNE_HP_push_context
:
576 printf ("DW_LNE_HP_push_context\n");
578 case DW_LNE_HP_pop_context
:
579 printf ("DW_LNE_HP_pop_context\n");
581 case DW_LNE_HP_set_file_line_column
:
582 printf ("DW_LNE_HP_set_file_line_column\n");
584 case DW_LNE_HP_set_routine_name
:
585 printf ("DW_LNE_HP_set_routine_name\n");
587 case DW_LNE_HP_set_sequence
:
588 printf ("DW_LNE_HP_set_sequence\n");
590 case DW_LNE_HP_negate_post_semantics
:
591 printf ("DW_LNE_HP_negate_post_semantics\n");
593 case DW_LNE_HP_negate_function_exit
:
594 printf ("DW_LNE_HP_negate_function_exit\n");
596 case DW_LNE_HP_negate_front_end_logical
:
597 printf ("DW_LNE_HP_negate_front_end_logical\n");
599 case DW_LNE_HP_define_proc
:
600 printf ("DW_LNE_HP_define_proc\n");
602 case DW_LNE_HP_source_file_correlation
:
604 unsigned char *edata
= data
+ len
- 1;
606 printf ("DW_LNE_HP_source_file_correlation\n");
612 READ_ULEB (opc
, data
, edata
);
616 case DW_LNE_HP_SFC_formfeed
:
617 printf (" DW_LNE_HP_SFC_formfeed\n");
619 case DW_LNE_HP_SFC_set_listing_line
:
620 READ_ULEB (val
, data
, edata
);
621 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
622 dwarf_vmatoa ("u", val
));
624 case DW_LNE_HP_SFC_associate
:
625 printf (" DW_LNE_HP_SFC_associate ");
626 READ_ULEB (val
, data
, edata
);
627 printf ("(%s", dwarf_vmatoa ("u", val
));
628 READ_ULEB (val
, data
, edata
);
629 printf (",%s", dwarf_vmatoa ("u", val
));
630 READ_ULEB (val
, data
, edata
);
631 printf (",%s)\n", dwarf_vmatoa ("u", val
));
634 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
644 unsigned int rlen
= len
- 1;
646 if (op_code
>= DW_LNE_lo_user
647 /* The test against DW_LNW_hi_user is redundant due to
648 the limited range of the unsigned char data type used
650 /*&& op_code <= DW_LNE_hi_user*/)
651 printf (_("user defined: "));
653 printf (_("UNKNOWN: "));
654 printf (_("length %d ["), rlen
);
656 printf (" %02x", *data
++);
662 return len
+ header_len
;
665 static const unsigned char *
666 fetch_indirect_string (dwarf_vma offset
)
668 struct dwarf_section
*section
= &debug_displays
[str
].section
;
669 const unsigned char * ret
;
671 if (section
->start
== NULL
)
672 return (const unsigned char *) _("<no .debug_str section>");
674 if (offset
>= section
->size
)
676 warn (_("DW_FORM_strp offset too big: %s\n"),
677 dwarf_vmatoa ("x", offset
));
678 return (const unsigned char *) _("<offset is too big>");
681 ret
= section
->start
+ offset
;
682 /* Unfortunately we cannot rely upon the .debug_str section ending with a
683 NUL byte. Since our caller is expecting to receive a well formed C
684 string we test for the lack of a terminating byte here. */
685 if (strnlen ((const char *) ret
, section
->size
- offset
)
686 == section
->size
- offset
)
687 ret
= (const unsigned char *)
688 _("<no NUL byte at end of .debug_str section>");
693 static const unsigned char *
694 fetch_indirect_line_string (dwarf_vma offset
)
696 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
697 const unsigned char * ret
;
699 if (section
->start
== NULL
)
700 return (const unsigned char *) _("<no .debug_line_str section>");
702 if (offset
>= section
->size
)
704 warn (_("DW_FORM_line_strp offset too big: %s\n"),
705 dwarf_vmatoa ("x", offset
));
706 return (const unsigned char *) _("<offset is too big>");
709 ret
= section
->start
+ offset
;
710 /* Unfortunately we cannot rely upon the .debug_line_str section ending
711 with a NUL byte. Since our caller is expecting to receive a well formed
712 C string we test for the lack of a terminating byte here. */
713 if (strnlen ((const char *) ret
, section
->size
- offset
)
714 == section
->size
- offset
)
715 ret
= (const unsigned char *)
716 _("<no NUL byte at end of .debug_line_str section>");
722 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
723 dwarf_vma offset_size
, bfd_boolean dwo
)
725 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
726 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
727 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
728 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
729 dwarf_vma index_offset
= idx
* offset_size
;
730 dwarf_vma str_offset
;
733 if (index_section
->start
== NULL
)
734 return (dwo
? _("<no .debug_str_offsets.dwo section>")
735 : _("<no .debug_str_offsets section>"));
737 if (this_set
!= NULL
)
738 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
739 if (index_offset
>= index_section
->size
)
741 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
742 dwarf_vmatoa ("x", index_offset
));
743 return _("<index offset is too big>");
746 if (str_section
->start
== NULL
)
747 return (dwo
? _("<no .debug_str.dwo section>")
748 : _("<no .debug_str section>"));
750 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
751 str_offset
-= str_section
->address
;
752 if (str_offset
>= str_section
->size
)
754 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
755 dwarf_vmatoa ("x", str_offset
));
756 return _("<indirect index offset is too big>");
759 ret
= (const char *) str_section
->start
+ str_offset
;
760 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
761 Since our caller is expecting to receive a well formed C string we test
762 for the lack of a terminating byte here. */
763 if (strnlen (ret
, str_section
->size
- str_offset
)
764 == str_section
->size
- str_offset
)
765 ret
= (const char *) _("<no NUL byte at end of section>");
771 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
773 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
775 if (section
->start
== NULL
)
776 return (_("<no .debug_addr section>"));
778 if (offset
+ bytes
> section
->size
)
780 warn (_("Offset into section %s too big: %s\n"),
781 section
->name
, dwarf_vmatoa ("x", offset
));
782 return "<offset too big>";
785 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
789 /* FIXME: There are better and more efficient ways to handle
790 these structures. For now though, I just want something that
791 is simple to implement. */
792 typedef struct abbrev_attr
794 unsigned long attribute
;
796 bfd_signed_vma implicit_const
;
797 struct abbrev_attr
*next
;
801 typedef struct abbrev_entry
806 struct abbrev_attr
*first_attr
;
807 struct abbrev_attr
*last_attr
;
808 struct abbrev_entry
*next
;
812 static abbrev_entry
*first_abbrev
= NULL
;
813 static abbrev_entry
*last_abbrev
= NULL
;
820 for (abbrv
= first_abbrev
; abbrv
;)
822 abbrev_entry
*next_abbrev
= abbrv
->next
;
825 for (attr
= abbrv
->first_attr
; attr
;)
827 abbrev_attr
*next_attr
= attr
->next
;
837 last_abbrev
= first_abbrev
= NULL
;
841 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
845 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
850 entry
->entry
= number
;
852 entry
->children
= children
;
853 entry
->first_attr
= NULL
;
854 entry
->last_attr
= NULL
;
857 if (first_abbrev
== NULL
)
858 first_abbrev
= entry
;
860 last_abbrev
->next
= entry
;
866 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
867 bfd_signed_vma implicit_const
)
871 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
876 attr
->attribute
= attribute
;
878 attr
->implicit_const
= implicit_const
;
881 if (last_abbrev
->first_attr
== NULL
)
882 last_abbrev
->first_attr
= attr
;
884 last_abbrev
->last_attr
->next
= attr
;
886 last_abbrev
->last_attr
= attr
;
889 /* Processes the (partial) contents of a .debug_abbrev section.
890 Returns NULL if the end of the section was encountered.
891 Returns the address after the last byte read if the end of
892 an abbreviation set was found. */
894 static unsigned char *
895 process_abbrev_section (unsigned char *start
, unsigned char *end
)
897 if (first_abbrev
!= NULL
)
904 unsigned long attribute
;
907 READ_ULEB (entry
, start
, end
);
909 /* A single zero is supposed to end the section according
910 to the standard. If there's more, then signal that to
917 READ_ULEB (tag
, start
, end
);
923 add_abbrev (entry
, tag
, children
);
928 /* Initialize it due to a false compiler warning. */
929 bfd_signed_vma implicit_const
= -1;
931 READ_ULEB (attribute
, start
, end
);
935 READ_ULEB (form
, start
, end
);
939 if (form
== DW_FORM_implicit_const
)
941 READ_SLEB (implicit_const
, start
, end
);
946 add_abbrev_attr (attribute
, form
, implicit_const
);
948 while (attribute
!= 0);
951 /* Report the missing single zero which ends the section. */
952 error (_(".debug_abbrev section not zero terminated\n"));
958 get_TAG_name (unsigned long tag
)
960 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
964 static char buffer
[100];
966 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
967 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
969 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
977 get_FORM_name (unsigned long form
)
982 return "DW_FORM value: 0";
984 name
= get_DW_FORM_name (form
);
987 static char buffer
[100];
989 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
997 get_IDX_name (unsigned long idx
)
999 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1003 static char buffer
[100];
1005 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1012 static unsigned char *
1013 display_block (unsigned char *data
,
1015 const unsigned char * const end
, char delimiter
)
1019 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1021 return (unsigned char *) end
;
1023 maxlen
= (dwarf_vma
) (end
- data
);
1024 length
= length
> maxlen
? maxlen
: length
;
1027 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1033 decode_location_expression (unsigned char * data
,
1034 unsigned int pointer_size
,
1035 unsigned int offset_size
,
1038 dwarf_vma cu_offset
,
1039 struct dwarf_section
* section
)
1043 dwarf_signed_vma svalue
;
1044 unsigned char *end
= data
+ length
;
1045 int need_frame_base
= 0;
1054 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1055 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1058 printf ("DW_OP_deref");
1061 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1062 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1065 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1066 printf ("DW_OP_const1s: %ld", (long) svalue
);
1069 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1070 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1073 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1074 printf ("DW_OP_const2s: %ld", (long) svalue
);
1077 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1078 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1081 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1082 printf ("DW_OP_const4s: %ld", (long) svalue
);
1085 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1086 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1087 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1088 printf ("%lu", (unsigned long) uvalue
);
1091 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1092 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1093 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1094 printf ("%ld", (long) svalue
);
1097 READ_ULEB (uvalue
, data
, end
);
1098 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1101 READ_SLEB (svalue
, data
, end
);
1102 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1105 printf ("DW_OP_dup");
1108 printf ("DW_OP_drop");
1111 printf ("DW_OP_over");
1114 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1115 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1118 printf ("DW_OP_swap");
1121 printf ("DW_OP_rot");
1124 printf ("DW_OP_xderef");
1127 printf ("DW_OP_abs");
1130 printf ("DW_OP_and");
1133 printf ("DW_OP_div");
1136 printf ("DW_OP_minus");
1139 printf ("DW_OP_mod");
1142 printf ("DW_OP_mul");
1145 printf ("DW_OP_neg");
1148 printf ("DW_OP_not");
1151 printf ("DW_OP_or");
1154 printf ("DW_OP_plus");
1156 case DW_OP_plus_uconst
:
1157 READ_ULEB (uvalue
, data
, end
);
1158 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1161 printf ("DW_OP_shl");
1164 printf ("DW_OP_shr");
1167 printf ("DW_OP_shra");
1170 printf ("DW_OP_xor");
1173 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1174 printf ("DW_OP_bra: %ld", (long) svalue
);
1177 printf ("DW_OP_eq");
1180 printf ("DW_OP_ge");
1183 printf ("DW_OP_gt");
1186 printf ("DW_OP_le");
1189 printf ("DW_OP_lt");
1192 printf ("DW_OP_ne");
1195 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1196 printf ("DW_OP_skip: %ld", (long) svalue
);
1231 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1266 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1267 regname (op
- DW_OP_reg0
, 1));
1302 READ_SLEB (svalue
, data
, end
);
1303 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1304 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1308 READ_ULEB (uvalue
, data
, end
);
1309 printf ("DW_OP_regx: %s (%s)",
1310 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1313 need_frame_base
= 1;
1314 READ_SLEB (svalue
, data
, end
);
1315 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1318 READ_ULEB (uvalue
, data
, end
);
1319 READ_SLEB (svalue
, data
, end
);
1320 printf ("DW_OP_bregx: %s (%s) %s",
1321 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1322 dwarf_vmatoa ("d", svalue
));
1325 READ_ULEB (uvalue
, data
, end
);
1326 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1328 case DW_OP_deref_size
:
1329 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1330 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1332 case DW_OP_xderef_size
:
1333 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1334 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1337 printf ("DW_OP_nop");
1340 /* DWARF 3 extensions. */
1341 case DW_OP_push_object_address
:
1342 printf ("DW_OP_push_object_address");
1345 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1346 this ought to be an 8-byte wide computation. */
1347 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1348 printf ("DW_OP_call2: <0x%s>",
1349 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1352 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1353 this ought to be an 8-byte wide computation. */
1354 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1355 printf ("DW_OP_call4: <0x%s>",
1356 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1358 case DW_OP_call_ref
:
1359 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1360 this ought to be an 8-byte wide computation. */
1361 if (dwarf_version
== -1)
1363 printf (_("(DW_OP_call_ref in frame info)"));
1364 /* No way to tell where the next op is, so just bail. */
1365 return need_frame_base
;
1367 if (dwarf_version
== 2)
1369 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1373 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1375 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1377 case DW_OP_form_tls_address
:
1378 printf ("DW_OP_form_tls_address");
1380 case DW_OP_call_frame_cfa
:
1381 printf ("DW_OP_call_frame_cfa");
1383 case DW_OP_bit_piece
:
1384 printf ("DW_OP_bit_piece: ");
1385 READ_ULEB (uvalue
, data
, end
);
1386 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1387 READ_ULEB (uvalue
, data
, end
);
1388 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1391 /* DWARF 4 extensions. */
1392 case DW_OP_stack_value
:
1393 printf ("DW_OP_stack_value");
1396 case DW_OP_implicit_value
:
1397 printf ("DW_OP_implicit_value");
1398 READ_ULEB (uvalue
, data
, end
);
1399 data
= display_block (data
, uvalue
, end
, ' ');
1402 /* GNU extensions. */
1403 case DW_OP_GNU_push_tls_address
:
1404 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1406 case DW_OP_GNU_uninit
:
1407 printf ("DW_OP_GNU_uninit");
1408 /* FIXME: Is there data associated with this OP ? */
1410 case DW_OP_GNU_encoded_addr
:
1417 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1419 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1420 print_dwarf_vma (addr
, pointer_size
);
1423 case DW_OP_implicit_pointer
:
1424 case DW_OP_GNU_implicit_pointer
:
1425 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1426 this ought to be an 8-byte wide computation. */
1427 if (dwarf_version
== -1)
1429 printf (_("(%s in frame info)"),
1430 (op
== DW_OP_implicit_pointer
1431 ? "DW_OP_implicit_pointer"
1432 : "DW_OP_GNU_implicit_pointer"));
1433 /* No way to tell where the next op is, so just bail. */
1434 return need_frame_base
;
1436 if (dwarf_version
== 2)
1438 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1442 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1444 READ_SLEB (svalue
, data
, end
);
1445 printf ("%s: <0x%s> %s",
1446 (op
== DW_OP_implicit_pointer
1447 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1448 dwarf_vmatoa ("x", uvalue
),
1449 dwarf_vmatoa ("d", svalue
));
1451 case DW_OP_entry_value
:
1452 case DW_OP_GNU_entry_value
:
1453 READ_ULEB (uvalue
, data
, end
);
1454 /* PR 17531: file: 0cc9cd00. */
1455 if (uvalue
> (dwarf_vma
) (end
- data
))
1456 uvalue
= end
- data
;
1457 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1458 : "DW_OP_GNU_entry_value"));
1459 if (decode_location_expression (data
, pointer_size
, offset_size
,
1460 dwarf_version
, uvalue
,
1461 cu_offset
, section
))
1462 need_frame_base
= 1;
1468 case DW_OP_const_type
:
1469 case DW_OP_GNU_const_type
:
1470 READ_ULEB (uvalue
, data
, end
);
1471 printf ("%s: <0x%s> ",
1472 (op
== DW_OP_const_type
? "DW_OP_const_type"
1473 : "DW_OP_GNU_const_type"),
1474 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1475 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1476 data
= display_block (data
, uvalue
, end
, ' ');
1478 case DW_OP_regval_type
:
1479 case DW_OP_GNU_regval_type
:
1480 READ_ULEB (uvalue
, data
, end
);
1481 printf ("%s: %s (%s)",
1482 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1483 : "DW_OP_GNU_regval_type"),
1484 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1485 READ_ULEB (uvalue
, data
, end
);
1486 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1488 case DW_OP_deref_type
:
1489 case DW_OP_GNU_deref_type
:
1490 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1492 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1493 : "DW_OP_GNU_deref_type"),
1495 READ_ULEB (uvalue
, data
, end
);
1496 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1499 case DW_OP_GNU_convert
:
1500 READ_ULEB (uvalue
, data
, end
);
1501 printf ("%s <0x%s>",
1502 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1503 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1505 case DW_OP_reinterpret
:
1506 case DW_OP_GNU_reinterpret
:
1507 READ_ULEB (uvalue
, data
, end
);
1508 printf ("%s <0x%s>",
1509 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1510 : "DW_OP_GNU_reinterpret"),
1511 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1513 case DW_OP_GNU_parameter_ref
:
1514 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1515 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1516 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1518 case DW_OP_GNU_addr_index
:
1519 READ_ULEB (uvalue
, data
, end
);
1520 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1522 case DW_OP_GNU_const_index
:
1523 READ_ULEB (uvalue
, data
, end
);
1524 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1526 case DW_OP_GNU_variable_value
:
1527 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1528 this ought to be an 8-byte wide computation. */
1529 if (dwarf_version
== -1)
1531 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1532 /* No way to tell where the next op is, so just bail. */
1533 return need_frame_base
;
1535 if (dwarf_version
== 2)
1537 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1541 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1543 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1546 /* HP extensions. */
1547 case DW_OP_HP_is_value
:
1548 printf ("DW_OP_HP_is_value");
1549 /* FIXME: Is there data associated with this OP ? */
1551 case DW_OP_HP_fltconst4
:
1552 printf ("DW_OP_HP_fltconst4");
1553 /* FIXME: Is there data associated with this OP ? */
1555 case DW_OP_HP_fltconst8
:
1556 printf ("DW_OP_HP_fltconst8");
1557 /* FIXME: Is there data associated with this OP ? */
1559 case DW_OP_HP_mod_range
:
1560 printf ("DW_OP_HP_mod_range");
1561 /* FIXME: Is there data associated with this OP ? */
1563 case DW_OP_HP_unmod_range
:
1564 printf ("DW_OP_HP_unmod_range");
1565 /* FIXME: Is there data associated with this OP ? */
1568 printf ("DW_OP_HP_tls");
1569 /* FIXME: Is there data associated with this OP ? */
1572 /* PGI (STMicroelectronics) extensions. */
1573 case DW_OP_PGI_omp_thread_num
:
1574 /* Pushes the thread number for the current thread as it would be
1575 returned by the standard OpenMP library function:
1576 omp_get_thread_num(). The "current thread" is the thread for
1577 which the expression is being evaluated. */
1578 printf ("DW_OP_PGI_omp_thread_num");
1582 if (op
>= DW_OP_lo_user
1583 && op
<= DW_OP_hi_user
)
1584 printf (_("(User defined location op 0x%x)"), op
);
1586 printf (_("(Unknown location op 0x%x)"), op
);
1587 /* No way to tell where the next op is, so just bail. */
1588 return need_frame_base
;
1591 /* Separate the ops. */
1596 return need_frame_base
;
1599 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1600 This is used for DWARF package files. */
1602 static struct cu_tu_set
*
1603 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1605 struct cu_tu_set
*p
;
1607 unsigned int dw_sect
;
1613 dw_sect
= DW_SECT_TYPES
;
1619 dw_sect
= DW_SECT_INFO
;
1623 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1631 /* Add INC to HIGH_BITS:LOW_BITS. */
1633 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1635 dwarf_vma tmp
= * low_bits
;
1639 /* FIXME: There is probably a better way of handling this:
1641 We need to cope with dwarf_vma being a 32-bit or 64-bit
1642 type. Plus regardless of its size LOW_BITS is meant to
1643 only hold 32-bits, so if there is overflow or wrap around
1644 we must propagate into HIGH_BITS. */
1645 if (tmp
< * low_bits
)
1649 else if (sizeof (tmp
) > 8
1660 fetch_alt_indirect_string (dwarf_vma offset
)
1664 if (! do_follow_links
)
1667 if (first_separate_info
== NULL
)
1668 return _("<no links available>");
1670 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1672 struct dwarf_section
* section
;
1675 if (! load_debug_section (separate_debug_str
, i
->handle
))
1678 section
= &debug_displays
[separate_debug_str
].section
;
1680 if (section
->start
== NULL
)
1683 if (offset
>= section
->size
)
1686 ret
= (const char *) (section
->start
+ offset
);
1687 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1688 NUL byte. Since our caller is expecting to receive a well formed C
1689 string we test for the lack of a terminating byte here. */
1690 if (strnlen ((const char *) ret
, section
->size
- offset
)
1691 == section
->size
- offset
)
1692 return _("<no NUL byte at end of alt .debug_str section>");
1697 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1698 dwarf_vmatoa ("x", offset
));
1699 return _("<offset is too big>");
1703 get_AT_name (unsigned long attribute
)
1708 return "DW_AT value: 0";
1710 /* One value is shared by the MIPS and HP extensions: */
1711 if (attribute
== DW_AT_MIPS_fde
)
1712 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1714 name
= get_DW_AT_name (attribute
);
1718 static char buffer
[100];
1720 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1729 add_dwo_info (const char * field
, dwo_type type
)
1731 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1733 dwinfo
->type
= type
;
1734 dwinfo
->value
= field
;
1735 dwinfo
->next
= first_dwo_info
;
1736 first_dwo_info
= dwinfo
;
1740 add_dwo_name (const char * name
)
1742 add_dwo_info (name
, DWO_NAME
);
1746 add_dwo_dir (const char * dir
)
1748 add_dwo_info (dir
, DWO_DIR
);
1752 add_dwo_id (const char * id
)
1754 add_dwo_info (id
, DWO_ID
);
1758 free_dwo_info (void)
1763 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1765 next
= dwinfo
->next
;
1768 first_dwo_info
= NULL
;
1771 /* Ensure that START + UVALUE is less than END.
1772 Return an adjusted UVALUE if necessary to ensure this relationship. */
1774 static inline dwarf_vma
1775 check_uvalue (const unsigned char * start
,
1777 const unsigned char * end
)
1779 dwarf_vma max_uvalue
= end
- start
;
1781 /* See PR 17512: file: 008-103549-0.001:0.1.
1782 and PR 24829 for examples of where these tests are triggered. */
1783 if (uvalue
> max_uvalue
)
1785 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1786 uvalue
= max_uvalue
;
1792 static unsigned char *
1793 skip_attr_bytes (unsigned long form
,
1794 unsigned char * data
,
1795 unsigned const char * end
,
1796 dwarf_vma pointer_size
,
1797 dwarf_vma offset_size
,
1799 dwarf_vma
* value_return
)
1801 dwarf_signed_vma svalue
;
1802 dwarf_vma uvalue
= 0;
1808 case DW_FORM_ref_addr
:
1809 if (dwarf_version
== 2)
1810 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1811 else if (dwarf_version
== 3 || dwarf_version
== 4)
1812 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1818 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1822 case DW_FORM_line_strp
:
1823 case DW_FORM_sec_offset
:
1824 case DW_FORM_GNU_ref_alt
:
1825 case DW_FORM_GNU_strp_alt
:
1826 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1829 case DW_FORM_flag_present
:
1836 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1841 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1846 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1850 READ_SLEB (svalue
, data
, end
);
1854 case DW_FORM_ref_udata
:
1856 case DW_FORM_GNU_str_index
:
1857 case DW_FORM_GNU_addr_index
:
1858 READ_ULEB (uvalue
, data
, end
);
1866 case DW_FORM_data16
:
1870 case DW_FORM_string
:
1871 data
+= strnlen ((char *) data
, end
- data
) + 1;
1875 case DW_FORM_exprloc
:
1876 READ_ULEB (uvalue
, data
, end
);
1879 case DW_FORM_block1
:
1880 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1884 case DW_FORM_block2
:
1885 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1889 case DW_FORM_block4
:
1890 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1894 case DW_FORM_ref_sig8
:
1898 case DW_FORM_indirect
:
1899 /* FIXME: Handle this form. */
1904 * value_return
= uvalue
;
1906 data
= (unsigned char *) end
;
1910 /* Return IS_SIGNED set to TRUE if the type at
1911 DATA can be determined to be a signed type. */
1914 get_type_signedness (unsigned char * start
,
1915 unsigned char * data
,
1916 unsigned const char * end
,
1917 dwarf_vma pointer_size
,
1918 dwarf_vma offset_size
,
1920 bfd_boolean
* is_signed
,
1921 bfd_boolean is_nested
)
1923 unsigned long abbrev_number
;
1924 abbrev_entry
* entry
;
1927 * is_signed
= FALSE
;
1929 READ_ULEB (abbrev_number
, data
, end
);
1931 for (entry
= first_abbrev
;
1932 entry
!= NULL
&& entry
->entry
!= abbrev_number
;
1933 entry
= entry
->next
)
1937 /* FIXME: Issue a warning ? */
1940 for (attr
= entry
->first_attr
;
1941 attr
!= NULL
&& attr
->attribute
;
1944 dwarf_vma uvalue
= 0;
1946 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
1947 offset_size
, dwarf_version
, & uvalue
);
1951 switch (attr
->attribute
)
1953 #if 0 /* FIXME: It would be nice to print the name of the type,
1954 but this would mean updating a lot of binutils tests. */
1956 if (attr
->form
== DW_FORM_strp
)
1957 printf ("%s", fetch_indirect_string (uvalue
));
1964 /* FIXME: Warn - or is this expected ?
1965 NB/ We need to avoid infinite recursion. */
1968 if (uvalue
>= (size_t) (end
- start
))
1970 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
1971 offset_size
, dwarf_version
, is_signed
, TRUE
);
1974 case DW_AT_encoding
:
1975 /* Determine signness. */
1978 case DW_ATE_address
:
1979 /* FIXME - some architectures have signed addresses. */
1980 case DW_ATE_boolean
:
1981 case DW_ATE_unsigned
:
1982 case DW_ATE_unsigned_char
:
1983 case DW_ATE_unsigned_fixed
:
1984 * is_signed
= FALSE
;
1988 case DW_ATE_complex_float
:
1991 case DW_ATE_signed_char
:
1992 case DW_ATE_imaginary_float
:
1993 case DW_ATE_decimal_float
:
1994 case DW_ATE_signed_fixed
:
2004 read_and_print_leb128 (unsigned char * data
,
2005 unsigned int * bytes_read
,
2006 unsigned const char * end
,
2007 bfd_boolean is_signed
)
2010 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2012 report_leb_status (status
, __FILE__
, __LINE__
);
2014 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2018 display_discr_list (unsigned long form
,
2020 unsigned char * data
,
2021 unsigned const char * end
,
2026 printf ("[default]");
2033 case DW_FORM_block1
:
2034 case DW_FORM_block2
:
2035 case DW_FORM_block4
:
2036 /* Move data pointer back to the start of the byte array. */
2040 printf ("<corrupt>\n");
2041 warn (_("corrupt discr_list - not using a block form\n"));
2047 printf ("<corrupt>\n");
2048 warn (_("corrupt discr_list - block not long enough\n"));
2052 bfd_boolean is_signed
=
2053 (level
> 0 && level
<= MAX_CU_NESTING
)
2054 ? level_type_signed
[level
- 1] : FALSE
;
2059 unsigned char discriminant
;
2060 unsigned int bytes_read
;
2062 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2066 assert (uvalue
> 0);
2067 switch (discriminant
)
2071 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2072 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2073 uvalue
-= bytes_read
;
2079 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2080 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2081 uvalue
-= bytes_read
;
2085 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2086 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2087 uvalue
-= bytes_read
;
2092 printf ("<corrupt>\n");
2093 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2103 printf (")(signed)");
2105 printf (")(unsigned)");
2108 static unsigned char *
2109 read_and_display_attr_value (unsigned long attribute
,
2111 dwarf_signed_vma implicit_const
,
2112 unsigned char * start
,
2113 unsigned char * data
,
2114 unsigned char * end
,
2115 dwarf_vma cu_offset
,
2116 dwarf_vma pointer_size
,
2117 dwarf_vma offset_size
,
2119 debug_info
* debug_info_p
,
2121 struct dwarf_section
* section
,
2122 struct cu_tu_set
* this_set
,
2126 dwarf_signed_vma svalue
;
2127 dwarf_vma uvalue
= 0;
2128 unsigned char * block_start
= NULL
;
2129 unsigned char * orig_data
= data
;
2131 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2133 warn (_("Corrupt attribute\n"));
2142 case DW_FORM_ref_addr
:
2143 if (dwarf_version
== 2)
2144 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2145 else if (dwarf_version
== 3 || dwarf_version
== 4)
2146 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2148 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
2153 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2157 case DW_FORM_line_strp
:
2158 case DW_FORM_sec_offset
:
2159 case DW_FORM_GNU_ref_alt
:
2160 case DW_FORM_GNU_strp_alt
:
2161 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2164 case DW_FORM_flag_present
:
2171 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2176 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2181 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2185 READ_SLEB (svalue
, data
, end
);
2189 case DW_FORM_GNU_str_index
:
2190 case DW_FORM_ref_udata
:
2192 case DW_FORM_GNU_addr_index
:
2193 READ_ULEB (uvalue
, data
, end
);
2196 case DW_FORM_indirect
:
2197 READ_ULEB (form
, data
, end
);
2199 printf ("%c%s", delimiter
, get_FORM_name (form
));
2200 if (form
== DW_FORM_implicit_const
)
2201 READ_SLEB (implicit_const
, data
, end
);
2202 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2204 cu_offset
, pointer_size
,
2205 offset_size
, dwarf_version
,
2206 debug_info_p
, do_loc
,
2207 section
, this_set
, delimiter
, level
);
2212 case DW_FORM_ref_addr
:
2214 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2217 case DW_FORM_GNU_ref_alt
:
2219 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2220 /* FIXME: Follow the reference... */
2226 case DW_FORM_ref_udata
:
2228 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2233 case DW_FORM_sec_offset
:
2235 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2238 case DW_FORM_flag_present
:
2245 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2248 case DW_FORM_implicit_const
:
2250 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2257 dwarf_vma high_bits
;
2261 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2263 if (form
== DW_FORM_ref8
)
2264 add64 (& high_bits
, & utmp
, cu_offset
);
2265 printf ("%c0x%s", delimiter
,
2266 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2269 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2270 && num_debug_info_entries
== 0)
2272 if (sizeof (uvalue
) == 8)
2273 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2275 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2281 case DW_FORM_data16
:
2284 dwarf_vma left_high_bits
, left_low_bits
;
2285 dwarf_vma right_high_bits
, right_low_bits
;
2287 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2288 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2289 if (byte_get
== byte_get_little_endian
)
2292 left_high_bits
^= right_high_bits
;
2293 right_high_bits
^= left_high_bits
;
2294 left_high_bits
^= right_high_bits
;
2295 left_low_bits
^= right_low_bits
;
2296 right_low_bits
^= left_low_bits
;
2297 left_low_bits
^= right_low_bits
;
2299 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2300 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2301 left_high_bits
, left_low_bits
, right_high_bits
,
2307 case DW_FORM_string
:
2309 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2310 data
+= strnlen ((char *) data
, end
- data
) + 1;
2314 case DW_FORM_exprloc
:
2315 READ_ULEB (uvalue
, data
, end
);
2318 if (block_start
>= end
)
2320 warn (_("Block ends prematurely\n"));
2325 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2328 data
= block_start
+ uvalue
;
2330 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2333 case DW_FORM_block1
:
2334 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2337 case DW_FORM_block2
:
2338 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2341 case DW_FORM_block4
:
2342 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2347 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2348 dwarf_vmatoa ("x", uvalue
),
2349 fetch_indirect_string (uvalue
));
2352 case DW_FORM_line_strp
:
2354 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2355 dwarf_vmatoa ("x", uvalue
),
2356 fetch_indirect_line_string (uvalue
));
2359 case DW_FORM_GNU_str_index
:
2362 const char * suffix
= strrchr (section
->name
, '.');
2363 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2365 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2366 dwarf_vmatoa ("x", uvalue
),
2367 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2371 case DW_FORM_GNU_strp_alt
:
2374 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2375 dwarf_vmatoa ("x", uvalue
),
2376 fetch_alt_indirect_string (uvalue
));
2380 case DW_FORM_indirect
:
2381 /* Handled above. */
2384 case DW_FORM_ref_sig8
:
2387 dwarf_vma high_bits
;
2390 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2391 printf ("%csignature: 0x%s", delimiter
,
2392 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2397 case DW_FORM_GNU_addr_index
:
2399 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2400 dwarf_vmatoa ("x", uvalue
),
2401 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2405 warn (_("Unrecognized form: %lu\n"), form
);
2409 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2410 && num_debug_info_entries
== 0
2411 && debug_info_p
!= NULL
)
2415 case DW_AT_frame_base
:
2416 have_frame_base
= 1;
2418 case DW_AT_location
:
2419 case DW_AT_GNU_locviews
:
2420 case DW_AT_string_length
:
2421 case DW_AT_return_addr
:
2422 case DW_AT_data_member_location
:
2423 case DW_AT_vtable_elem_location
:
2425 case DW_AT_static_link
:
2426 case DW_AT_use_location
:
2427 case DW_AT_call_value
:
2428 case DW_AT_GNU_call_site_value
:
2429 case DW_AT_call_data_value
:
2430 case DW_AT_GNU_call_site_data_value
:
2431 case DW_AT_call_target
:
2432 case DW_AT_GNU_call_site_target
:
2433 case DW_AT_call_target_clobbered
:
2434 case DW_AT_GNU_call_site_target_clobbered
:
2435 if ((dwarf_version
< 4
2436 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2437 || form
== DW_FORM_sec_offset
)
2439 /* Process location list. */
2440 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2441 unsigned int num
= debug_info_p
->num_loc_offsets
;
2443 if (lmax
== 0 || num
>= lmax
)
2446 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2447 xcrealloc (debug_info_p
->loc_offsets
,
2448 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2449 debug_info_p
->loc_views
= (dwarf_vma
*)
2450 xcrealloc (debug_info_p
->loc_views
,
2451 lmax
, sizeof (*debug_info_p
->loc_views
));
2452 debug_info_p
->have_frame_base
= (int *)
2453 xcrealloc (debug_info_p
->have_frame_base
,
2454 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2455 debug_info_p
->max_loc_offsets
= lmax
;
2457 if (this_set
!= NULL
)
2458 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2459 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2460 if (attribute
!= DW_AT_GNU_locviews
)
2462 /* Corrupt DWARF info can produce more offsets than views.
2463 See PR 23062 for an example. */
2464 if (debug_info_p
->num_loc_offsets
2465 > debug_info_p
->num_loc_views
)
2466 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2469 debug_info_p
->loc_offsets
[num
] = uvalue
;
2470 debug_info_p
->num_loc_offsets
++;
2475 assert (debug_info_p
->num_loc_views
<= num
);
2476 num
= debug_info_p
->num_loc_views
;
2477 if (num
> debug_info_p
->num_loc_offsets
)
2478 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2481 debug_info_p
->loc_views
[num
] = uvalue
;
2482 debug_info_p
->num_loc_views
++;
2489 if (need_base_address
)
2490 debug_info_p
->base_address
= uvalue
;
2493 case DW_AT_GNU_addr_base
:
2494 debug_info_p
->addr_base
= uvalue
;
2497 case DW_AT_GNU_ranges_base
:
2498 debug_info_p
->ranges_base
= uvalue
;
2502 if ((dwarf_version
< 4
2503 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2504 || form
== DW_FORM_sec_offset
)
2506 /* Process range list. */
2507 unsigned int lmax
= debug_info_p
->max_range_lists
;
2508 unsigned int num
= debug_info_p
->num_range_lists
;
2510 if (lmax
== 0 || num
>= lmax
)
2513 debug_info_p
->range_lists
= (dwarf_vma
*)
2514 xcrealloc (debug_info_p
->range_lists
,
2515 lmax
, sizeof (*debug_info_p
->range_lists
));
2516 debug_info_p
->max_range_lists
= lmax
;
2518 debug_info_p
->range_lists
[num
] = uvalue
;
2519 debug_info_p
->num_range_lists
++;
2523 case DW_AT_GNU_dwo_name
:
2524 case DW_AT_dwo_name
:
2529 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2531 case DW_FORM_GNU_str_index
:
2532 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2534 case DW_FORM_string
:
2535 add_dwo_name ((const char *) orig_data
);
2538 warn (_("Unsupported form (%s) for attribute %s\n"),
2539 get_FORM_name (form
), get_AT_name (attribute
));
2544 case DW_AT_comp_dir
:
2545 /* FIXME: Also extract a build-id in a CU/TU. */
2550 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2552 case DW_FORM_line_strp
:
2553 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2555 case DW_FORM_GNU_str_index
:
2556 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2558 case DW_FORM_string
:
2559 add_dwo_dir ((const char *) orig_data
);
2562 warn (_("Unsupported form (%s) for attribute %s\n"),
2563 get_FORM_name (form
), get_AT_name (attribute
));
2568 case DW_AT_GNU_dwo_id
:
2573 /* FIXME: Record the length of the ID as well ? */
2574 add_dwo_id ((const char *) (data
- 8));
2577 warn (_("Unsupported form (%s) for attribute %s\n"),
2578 get_FORM_name (form
), get_AT_name (attribute
));
2588 if (do_loc
|| attribute
== 0)
2591 /* For some attributes we can display further information. */
2595 if (level
>= 0 && level
< MAX_CU_NESTING
2596 && uvalue
< (size_t) (end
- start
))
2598 bfd_boolean is_signed
= FALSE
;
2600 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2601 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2602 level_type_signed
[level
] = is_signed
;
2610 case DW_INL_not_inlined
:
2611 printf (_("(not inlined)"));
2613 case DW_INL_inlined
:
2614 printf (_("(inlined)"));
2616 case DW_INL_declared_not_inlined
:
2617 printf (_("(declared as inline but ignored)"));
2619 case DW_INL_declared_inlined
:
2620 printf (_("(declared as inline and inlined)"));
2623 printf (_(" (Unknown inline attribute value: %s)"),
2624 dwarf_vmatoa ("x", uvalue
));
2629 case DW_AT_language
:
2633 /* Ordered by the numeric value of these constants. */
2634 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2635 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2636 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2637 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2638 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2639 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2640 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2641 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2642 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2643 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2644 /* DWARF 2.1 values. */
2645 case DW_LANG_Java
: printf ("(Java)"); break;
2646 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2647 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2648 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2649 /* DWARF 3 values. */
2650 case DW_LANG_PLI
: printf ("(PLI)"); break;
2651 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2652 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2653 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2654 case DW_LANG_D
: printf ("(D)"); break;
2655 /* DWARF 4 values. */
2656 case DW_LANG_Python
: printf ("(Python)"); break;
2657 /* DWARF 5 values. */
2658 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2659 case DW_LANG_Go
: printf ("(Go)"); break;
2660 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2661 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2662 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2663 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2664 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2665 case DW_LANG_Rust
: printf ("(Rust)"); break;
2666 case DW_LANG_C11
: printf ("(C11)"); break;
2667 case DW_LANG_Swift
: printf ("(Swift)"); break;
2668 case DW_LANG_Julia
: printf ("(Julia)"); break;
2669 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2670 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2671 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2672 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2673 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2674 /* MIPS extension. */
2675 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2676 /* UPC extension. */
2677 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2679 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2680 printf (_("(implementation defined: %s)"),
2681 dwarf_vmatoa ("x", uvalue
));
2683 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2688 case DW_AT_encoding
:
2692 case DW_ATE_void
: printf ("(void)"); break;
2693 case DW_ATE_address
: printf ("(machine address)"); break;
2694 case DW_ATE_boolean
: printf ("(boolean)"); break;
2695 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2696 case DW_ATE_float
: printf ("(float)"); break;
2697 case DW_ATE_signed
: printf ("(signed)"); break;
2698 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2699 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2700 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2701 /* DWARF 2.1 values: */
2702 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2703 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2704 /* DWARF 3 values: */
2705 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2706 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2707 case DW_ATE_edited
: printf ("(edited)"); break;
2708 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2709 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2710 /* DWARF 4 values: */
2711 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2712 /* DWARF 5 values: */
2713 case DW_ATE_UCS
: printf ("(UCS)"); break;
2714 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2716 /* HP extensions: */
2717 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2718 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2719 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2720 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2721 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2722 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2723 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2726 if (uvalue
>= DW_ATE_lo_user
2727 && uvalue
<= DW_ATE_hi_user
)
2728 printf (_("(user defined type)"));
2730 printf (_("(unknown type)"));
2735 case DW_AT_accessibility
:
2739 case DW_ACCESS_public
: printf ("(public)"); break;
2740 case DW_ACCESS_protected
: printf ("(protected)"); break;
2741 case DW_ACCESS_private
: printf ("(private)"); break;
2743 printf (_("(unknown accessibility)"));
2748 case DW_AT_visibility
:
2752 case DW_VIS_local
: printf ("(local)"); break;
2753 case DW_VIS_exported
: printf ("(exported)"); break;
2754 case DW_VIS_qualified
: printf ("(qualified)"); break;
2755 default: printf (_("(unknown visibility)")); break;
2759 case DW_AT_endianity
:
2763 case DW_END_default
: printf ("(default)"); break;
2764 case DW_END_big
: printf ("(big)"); break;
2765 case DW_END_little
: printf ("(little)"); break;
2767 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2768 printf (_("(user specified)"));
2770 printf (_("(unknown endianity)"));
2775 case DW_AT_virtuality
:
2779 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2780 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2781 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2782 default: printf (_("(unknown virtuality)")); break;
2786 case DW_AT_identifier_case
:
2790 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2791 case DW_ID_up_case
: printf ("(up_case)"); break;
2792 case DW_ID_down_case
: printf ("(down_case)"); break;
2793 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2794 default: printf (_("(unknown case)")); break;
2798 case DW_AT_calling_convention
:
2802 case DW_CC_normal
: printf ("(normal)"); break;
2803 case DW_CC_program
: printf ("(program)"); break;
2804 case DW_CC_nocall
: printf ("(nocall)"); break;
2805 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2806 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2807 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2808 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2810 if (uvalue
>= DW_CC_lo_user
2811 && uvalue
<= DW_CC_hi_user
)
2812 printf (_("(user defined)"));
2814 printf (_("(unknown convention)"));
2818 case DW_AT_ordering
:
2823 case -1: printf (_("(undefined)")); break;
2824 case 0: printf ("(row major)"); break;
2825 case 1: printf ("(column major)"); break;
2829 case DW_AT_decimal_sign
:
2833 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2834 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2835 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2836 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2837 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2838 default: printf (_("(unrecognised)")); break;
2842 case DW_AT_defaulted
:
2846 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2847 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2848 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2849 default: printf (_("(unrecognised)")); break;
2853 case DW_AT_discr_list
:
2855 display_discr_list (form
, uvalue
, data
, end
, level
);
2858 case DW_AT_frame_base
:
2859 have_frame_base
= 1;
2861 case DW_AT_location
:
2862 case DW_AT_string_length
:
2863 case DW_AT_return_addr
:
2864 case DW_AT_data_member_location
:
2865 case DW_AT_vtable_elem_location
:
2867 case DW_AT_static_link
:
2868 case DW_AT_use_location
:
2869 case DW_AT_call_value
:
2870 case DW_AT_GNU_call_site_value
:
2871 case DW_AT_call_data_value
:
2872 case DW_AT_GNU_call_site_data_value
:
2873 case DW_AT_call_target
:
2874 case DW_AT_GNU_call_site_target
:
2875 case DW_AT_call_target_clobbered
:
2876 case DW_AT_GNU_call_site_target_clobbered
:
2877 if ((dwarf_version
< 4
2878 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2879 || form
== DW_FORM_sec_offset
)
2880 printf (_(" (location list)"));
2882 case DW_AT_allocated
:
2883 case DW_AT_associated
:
2884 case DW_AT_data_location
:
2886 case DW_AT_upper_bound
:
2887 case DW_AT_lower_bound
:
2890 int need_frame_base
;
2893 need_frame_base
= decode_location_expression (block_start
,
2898 cu_offset
, section
);
2900 if (need_frame_base
&& !have_frame_base
)
2901 printf (_(" [without DW_AT_frame_base]"));
2905 case DW_AT_data_bit_offset
:
2906 case DW_AT_byte_size
:
2907 case DW_AT_bit_size
:
2908 case DW_AT_string_length_byte_size
:
2909 case DW_AT_string_length_bit_size
:
2910 case DW_AT_bit_stride
:
2911 if (form
== DW_FORM_exprloc
)
2914 (void) decode_location_expression (block_start
, pointer_size
,
2915 offset_size
, dwarf_version
,
2916 uvalue
, cu_offset
, section
);
2923 if (form
== DW_FORM_ref_sig8
2924 || form
== DW_FORM_GNU_ref_alt
)
2927 if (form
== DW_FORM_ref1
2928 || form
== DW_FORM_ref2
2929 || form
== DW_FORM_ref4
2930 || form
== DW_FORM_ref_udata
)
2931 uvalue
+= cu_offset
;
2933 if (uvalue
>= section
->size
)
2934 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2935 dwarf_vmatoa ("x", uvalue
),
2936 (unsigned long) (orig_data
- section
->start
));
2939 unsigned long abbrev_number
;
2940 abbrev_entry
*entry
;
2941 unsigned char *p
= section
->start
+ uvalue
;
2943 READ_ULEB (abbrev_number
, p
, end
);
2945 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2946 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2947 use different abbrev table, and we don't track .debug_info chunks
2949 if (form
!= DW_FORM_ref_addr
)
2951 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2952 if (entry
->entry
== abbrev_number
)
2955 printf (" (%s)", get_TAG_name (entry
->tag
));
2969 static unsigned char *
2970 read_and_display_attr (unsigned long attribute
,
2972 dwarf_signed_vma implicit_const
,
2973 unsigned char * start
,
2974 unsigned char * data
,
2975 unsigned char * end
,
2976 dwarf_vma cu_offset
,
2977 dwarf_vma pointer_size
,
2978 dwarf_vma offset_size
,
2980 debug_info
* debug_info_p
,
2982 struct dwarf_section
* section
,
2983 struct cu_tu_set
* this_set
,
2987 printf (" %-18s:", get_AT_name (attribute
));
2988 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
2990 cu_offset
, pointer_size
, offset_size
,
2991 dwarf_version
, debug_info_p
,
2992 do_loc
, section
, this_set
, ' ', level
);
2998 /* Like load_debug_section, but if the ordinary call fails, and we are
2999 following debug links, then attempt to load the requested section
3000 from one of the separate debug info files. */
3003 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3006 if (load_debug_section (sec_enum
, handle
))
3008 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3010 /* See if we can associate a filename with this section. */
3013 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3014 if (i
->handle
== handle
)
3016 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3024 if (do_follow_links
)
3028 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3030 if (load_debug_section (sec_enum
, i
->handle
))
3032 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3034 /* FIXME: We should check to see if any of the remaining debug info
3035 files also contain this section, and, umm, do something about it. */
3045 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3049 if (do_follow_links
&& section
->filename
)
3050 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3051 section
->name
, section
->filename
);
3053 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3057 if (do_follow_links
&& section
->filename
)
3058 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3059 section
->name
, section
->filename
);
3061 printf (_("Contents of the %s section:\n\n"), section
->name
);
3065 /* Process the contents of a .debug_info section.
3066 If do_loc is TRUE then we are scanning for location lists and dwo tags
3067 and we do not want to display anything to the user.
3068 If do_types is TRUE, we are processing a .debug_types section instead of
3069 a .debug_info section.
3070 The information displayed is restricted by the values in DWARF_START_DIE
3071 and DWARF_CUTOFF_LEVEL.
3072 Returns TRUE upon success. Otherwise an error or warning message is
3073 printed and FALSE is returned. */
3076 process_debug_info (struct dwarf_section
* section
,
3078 enum dwarf_section_display_enum abbrev_sec
,
3080 bfd_boolean do_types
)
3082 unsigned char *start
= section
->start
;
3083 unsigned char *end
= start
+ section
->size
;
3084 unsigned char *section_begin
;
3086 unsigned int num_units
= 0;
3088 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3089 && num_debug_info_entries
== 0
3094 /* First scan the section to get the number of comp units. */
3095 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3098 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3099 will be the length. For a 64-bit DWARF section, it'll be
3100 the escape code 0xffffffff followed by an 8 byte length. */
3101 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3103 if (length
== 0xffffffff)
3105 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3106 section_begin
+= length
+ 12;
3108 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3110 warn (_("Reserved length value (0x%s) found in section %s\n"),
3111 dwarf_vmatoa ("x", length
), section
->name
);
3115 section_begin
+= length
+ 4;
3117 /* Negative values are illegal, they may even cause infinite
3118 looping. This can happen if we can't accurately apply
3119 relocations to an object file, or if the file is corrupt. */
3120 if ((signed long) length
<= 0 || section_begin
< start
)
3122 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3123 dwarf_vmatoa ("x", length
), section
->name
);
3130 error (_("No comp units in %s section ?\n"), section
->name
);
3134 /* Then allocate an array to hold the information. */
3135 debug_information
= (debug_info
*) cmalloc (num_units
,
3136 sizeof (* debug_information
));
3137 if (debug_information
== NULL
)
3139 error (_("Not enough memory for a debug info array of %u entries\n"),
3141 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3145 /* PR 17531: file: 92ca3797.
3146 We cannot rely upon the debug_information array being initialised
3147 before it is used. A corrupt file could easily contain references
3148 to a unit for which information has not been made available. So
3149 we ensure that the array is zeroed here. */
3150 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3152 alloc_num_debug_info_entries
= num_units
;
3157 load_debug_section_with_follow (str
, file
);
3158 load_debug_section_with_follow (line_str
, file
);
3159 load_debug_section_with_follow (str_dwo
, file
);
3160 load_debug_section_with_follow (str_index
, file
);
3161 load_debug_section_with_follow (str_index_dwo
, file
);
3162 load_debug_section_with_follow (debug_addr
, file
);
3165 load_debug_section_with_follow (abbrev_sec
, file
);
3166 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3168 warn (_("Unable to locate %s section!\n"),
3169 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3173 if (!do_loc
&& dwarf_start_die
== 0)
3174 introduce (section
, FALSE
);
3176 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3178 DWARF2_Internal_CompUnit compunit
;
3179 unsigned char *hdrptr
;
3180 unsigned char *tags
;
3181 int level
, last_level
, saved_level
;
3182 dwarf_vma cu_offset
;
3183 unsigned long sec_off
;
3184 unsigned int offset_size
;
3185 unsigned int initial_length_size
;
3186 dwarf_vma signature_high
= 0;
3187 dwarf_vma signature_low
= 0;
3188 dwarf_vma type_offset
= 0;
3189 struct cu_tu_set
*this_set
;
3190 dwarf_vma abbrev_base
;
3195 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3197 if (compunit
.cu_length
== 0xffffffff)
3199 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3201 initial_length_size
= 12;
3206 initial_length_size
= 4;
3209 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3211 cu_offset
= start
- section_begin
;
3213 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3215 if (compunit
.cu_version
< 5)
3217 compunit
.cu_unit_type
= DW_UT_compile
;
3218 /* Initialize it due to a false compiler warning. */
3219 compunit
.cu_pointer_size
= -1;
3223 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3224 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3226 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3229 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3231 if (this_set
== NULL
)
3234 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3238 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3239 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3242 if (compunit
.cu_version
< 5)
3243 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3245 /* PR 17512: file: 001-108546-0.001:0.1. */
3246 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3248 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3249 compunit
.cu_pointer_size
, offset_size
);
3250 compunit
.cu_pointer_size
= offset_size
;
3255 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3257 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3260 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3261 + initial_length_size
))
3263 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3264 + initial_length_size
;
3268 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3269 && num_debug_info_entries
== 0
3270 && alloc_num_debug_info_entries
> unit
3273 debug_information
[unit
].cu_offset
= cu_offset
;
3274 debug_information
[unit
].pointer_size
3275 = compunit
.cu_pointer_size
;
3276 debug_information
[unit
].offset_size
= offset_size
;
3277 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3278 debug_information
[unit
].base_address
= 0;
3279 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3280 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3281 debug_information
[unit
].loc_offsets
= NULL
;
3282 debug_information
[unit
].have_frame_base
= NULL
;
3283 debug_information
[unit
].max_loc_offsets
= 0;
3284 debug_information
[unit
].num_loc_offsets
= 0;
3285 debug_information
[unit
].range_lists
= NULL
;
3286 debug_information
[unit
].max_range_lists
= 0;
3287 debug_information
[unit
].num_range_lists
= 0;
3290 if (!do_loc
&& dwarf_start_die
== 0)
3292 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3293 dwarf_vmatoa ("x", cu_offset
));
3294 printf (_(" Length: 0x%s (%s)\n"),
3295 dwarf_vmatoa ("x", compunit
.cu_length
),
3296 offset_size
== 8 ? "64-bit" : "32-bit");
3297 printf (_(" Version: %d\n"), compunit
.cu_version
);
3298 printf (_(" Abbrev Offset: 0x%s\n"),
3299 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3300 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3305 printf (_(" Signature: 0x%s\n"),
3306 dwarf_vmatoa64 (signature_high
, signature_low
,
3307 buf
, sizeof (buf
)));
3308 printf (_(" Type Offset: 0x%s\n"),
3309 dwarf_vmatoa ("x", type_offset
));
3311 if (this_set
!= NULL
)
3313 dwarf_vma
*offsets
= this_set
->section_offsets
;
3314 size_t *sizes
= this_set
->section_sizes
;
3316 printf (_(" Section contributions:\n"));
3317 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3318 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3319 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3320 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3321 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3322 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3323 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3324 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3325 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3326 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3327 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3328 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3332 sec_off
= cu_offset
+ initial_length_size
;
3333 if (sec_off
+ compunit
.cu_length
< sec_off
3334 || sec_off
+ compunit
.cu_length
> section
->size
)
3336 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3338 (unsigned long) cu_offset
,
3339 dwarf_vmatoa ("x", compunit
.cu_length
));
3345 start
+= compunit
.cu_length
+ initial_length_size
;
3347 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3349 warn (_("CU at offset %s contains corrupt or "
3350 "unsupported version number: %d.\n"),
3351 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3355 if (compunit
.cu_unit_type
!= DW_UT_compile
3356 && compunit
.cu_unit_type
!= DW_UT_type
)
3358 warn (_("CU at offset %s contains corrupt or "
3359 "unsupported unit type: %d.\n"),
3360 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3366 /* Process the abbrevs used by this compilation unit. */
3367 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3368 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3369 (unsigned long) compunit
.cu_abbrev_offset
,
3370 (unsigned long) abbrev_size
);
3371 /* PR 17531: file:4bcd9ce9. */
3372 else if ((abbrev_base
+ abbrev_size
)
3373 > debug_displays
[abbrev_sec
].section
.size
)
3374 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3375 (unsigned long) abbrev_base
+ abbrev_size
,
3376 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3378 process_abbrev_section
3379 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3380 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3381 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3382 + abbrev_base
+ abbrev_size
));
3387 while (tags
< start
)
3389 unsigned long abbrev_number
;
3390 unsigned long die_offset
;
3391 abbrev_entry
*entry
;
3393 int do_printing
= 1;
3395 die_offset
= tags
- section_begin
;
3397 READ_ULEB (abbrev_number
, tags
, start
);
3399 /* A null DIE marks the end of a list of siblings or it may also be
3400 a section padding. */
3401 if (abbrev_number
== 0)
3403 /* Check if it can be a section padding for the last CU. */
3404 if (level
== 0 && start
== end
)
3408 for (chk
= tags
; chk
< start
; chk
++)
3415 if (!do_loc
&& die_offset
>= dwarf_start_die
3416 && (dwarf_cutoff_level
== -1
3417 || level
< dwarf_cutoff_level
))
3418 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3424 static unsigned num_bogus_warns
= 0;
3426 if (num_bogus_warns
< 3)
3428 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3429 die_offset
, section
->name
);
3431 if (num_bogus_warns
== 3)
3432 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3435 if (dwarf_start_die
!= 0 && level
< saved_level
)
3442 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3446 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3447 saved_level
= level
;
3448 do_printing
= (dwarf_cutoff_level
== -1
3449 || level
< dwarf_cutoff_level
);
3451 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3452 level
, die_offset
, abbrev_number
);
3453 else if (dwarf_cutoff_level
== -1
3454 || last_level
< dwarf_cutoff_level
)
3455 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3460 /* Scan through the abbreviation list until we reach the
3462 for (entry
= first_abbrev
;
3463 entry
&& entry
->entry
!= abbrev_number
;
3464 entry
= entry
->next
)
3469 if (!do_loc
&& do_printing
)
3474 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3475 die_offset
, abbrev_number
);
3479 if (!do_loc
&& do_printing
)
3480 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3485 need_base_address
= 0;
3487 case DW_TAG_compile_unit
:
3488 need_base_address
= 1;
3489 need_dwo_info
= do_loc
;
3491 case DW_TAG_entry_point
:
3492 case DW_TAG_subprogram
:
3493 need_base_address
= 0;
3494 /* Assuming that there is no DW_AT_frame_base. */
3495 have_frame_base
= 0;
3499 debug_info
*debug_info_p
=
3500 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3501 ? debug_information
+ unit
: NULL
;
3503 assert (!debug_info_p
3504 || (debug_info_p
->num_loc_offsets
3505 == debug_info_p
->num_loc_views
));
3507 for (attr
= entry
->first_attr
;
3508 attr
&& attr
->attribute
;
3511 if (! do_loc
&& do_printing
)
3512 /* Show the offset from where the tag was extracted. */
3513 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3514 tags
= read_and_display_attr (attr
->attribute
,
3516 attr
->implicit_const
,
3521 compunit
.cu_pointer_size
,
3523 compunit
.cu_version
,
3525 do_loc
|| ! do_printing
,
3531 /* If a locview attribute appears before a location one,
3532 make sure we don't associate it with an earlier
3535 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3538 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3539 debug_info_p
->num_loc_views
++;
3540 assert (debug_info_p
->num_loc_views
3541 == debug_info_p
->num_loc_offsets
);
3548 warn(_("DIE has locviews without loclist\n"));
3549 debug_info_p
->num_loc_views
--;
3556 if (entry
->children
)
3561 /* Set num_debug_info_entries here so that it can be used to check if
3562 we need to process .debug_loc and .debug_ranges sections. */
3563 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3564 && num_debug_info_entries
== 0
3567 if (num_units
> alloc_num_debug_info_entries
)
3568 num_debug_info_entries
= alloc_num_debug_info_entries
;
3570 num_debug_info_entries
= num_units
;
3579 /* Locate and scan the .debug_info section in the file and record the pointer
3580 sizes and offsets for the compilation units in it. Usually an executable
3581 will have just one pointer size, but this is not guaranteed, and so we try
3582 not to make any assumptions. Returns zero upon failure, or the number of
3583 compilation units upon success. */
3586 load_debug_info (void * file
)
3588 /* If we have already tried and failed to load the .debug_info
3589 section then do not bother to repeat the task. */
3590 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3593 /* If we already have the information there is nothing else to do. */
3594 if (num_debug_info_entries
> 0)
3595 return num_debug_info_entries
;
3597 /* If this is a DWARF package file, load the CU and TU indexes. */
3598 (void) load_cu_tu_indexes (file
);
3600 if (load_debug_section_with_follow (info
, file
)
3601 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3602 return num_debug_info_entries
;
3604 if (load_debug_section_with_follow (info_dwo
, file
)
3605 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3606 abbrev_dwo
, TRUE
, FALSE
))
3607 return num_debug_info_entries
;
3609 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3613 /* Read a DWARF .debug_line section header starting at DATA.
3614 Upon success returns an updated DATA pointer and the LINFO
3615 structure and the END_OF_SEQUENCE pointer will be filled in.
3616 Otherwise returns NULL. */
3618 static unsigned char *
3619 read_debug_line_header (struct dwarf_section
* section
,
3620 unsigned char * data
,
3621 unsigned char * end
,
3622 DWARF2_Internal_LineInfo
* linfo
,
3623 unsigned char ** end_of_sequence
)
3625 unsigned char *hdrptr
;
3626 unsigned int initial_length_size
;
3628 /* Extract information from the Line Number Program Header.
3629 (section 6.2.4 in the Dwarf3 doc). */
3632 /* Get and check the length of the block. */
3633 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3635 if (linfo
->li_length
== 0xffffffff)
3637 /* This section is 64-bit DWARF 3. */
3638 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3639 linfo
->li_offset_size
= 8;
3640 initial_length_size
= 12;
3644 linfo
->li_offset_size
= 4;
3645 initial_length_size
= 4;
3648 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3650 /* If the length field has a relocation against it, then we should
3651 not complain if it is inaccurate (and probably negative). This
3652 happens in object files when the .debug_line section is actually
3653 comprised of several different .debug_line.* sections, (some of
3654 which may be removed by linker garbage collection), and a relocation
3655 is used to compute the correct length once that is done. */
3656 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3658 linfo
->li_length
= (end
- data
) - initial_length_size
;
3662 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3663 (long) linfo
->li_length
);
3668 /* Get and check the version number. */
3669 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3671 if (linfo
->li_version
!= 2
3672 && linfo
->li_version
!= 3
3673 && linfo
->li_version
!= 4
3674 && linfo
->li_version
!= 5)
3676 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3677 "is currently supported.\n"));
3681 if (linfo
->li_version
>= 5)
3683 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
3685 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
3686 if (linfo
->li_segment_size
!= 0)
3688 warn (_("The %s section contains "
3689 "unsupported segment selector size: %d.\n"),
3690 section
->name
, linfo
->li_segment_size
);
3695 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3696 linfo
->li_offset_size
, end
);
3697 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3699 if (linfo
->li_version
>= 4)
3701 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3703 if (linfo
->li_max_ops_per_insn
== 0)
3705 warn (_("Invalid maximum operations per insn.\n"));
3710 linfo
->li_max_ops_per_insn
= 1;
3712 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3713 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3714 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3715 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3717 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3718 /* PR 17512: file:002-117414-0.004. */
3719 if (* end_of_sequence
> end
)
3721 warn (_("Line length %s extends beyond end of section\n"),
3722 dwarf_vmatoa ("u", linfo
->li_length
));
3723 * end_of_sequence
= end
;
3730 static unsigned char *
3731 display_formatted_table (unsigned char * data
,
3732 unsigned char * start
,
3733 unsigned char * end
,
3734 const DWARF2_Internal_LineInfo
* linfo
,
3735 struct dwarf_section
* section
,
3738 unsigned char *format_start
, format_count
, *format
, formati
;
3739 dwarf_vma data_count
, datai
;
3740 unsigned int namepass
, last_entry
= 0;
3741 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
3743 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3744 if (do_checks
&& format_count
> 5)
3745 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
3746 table_name
, format_count
);
3748 format_start
= data
;
3749 for (formati
= 0; formati
< format_count
; formati
++)
3751 SKIP_ULEB (data
, end
);
3752 SKIP_ULEB (data
, end
);
3755 warn (_("%s: Corrupt format description entry\n"), table_name
);
3760 READ_ULEB (data_count
, data
, end
);
3761 if (data_count
== 0)
3763 printf (_("\n The %s is empty.\n"), table_name
);
3766 else if (data
== end
)
3768 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
3769 table_name
, dwarf_vmatoa ("x", data_count
));
3773 else if (format_count
== 0)
3775 warn (_("%s: format count is zero, but the table is not empty\n"),
3780 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
3781 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
3784 printf (_(" Entry"));
3785 /* Delay displaying name as the last entry for better screen layout. */
3786 for (namepass
= 0; namepass
< 2; namepass
++)
3788 format
= format_start
;
3789 for (formati
= 0; formati
< format_count
; formati
++)
3791 dwarf_vma content_type
;
3793 READ_ULEB (content_type
, format
, end
);
3794 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3795 switch (content_type
)
3798 printf (_("\tName"));
3800 case DW_LNCT_directory_index
:
3801 printf (_("\tDir"));
3803 case DW_LNCT_timestamp
:
3804 printf (_("\tTime"));
3807 printf (_("\tSize"));
3810 printf (_("\tMD5\t\t\t"));
3813 printf (_("\t(Unknown format content type %s)"),
3814 dwarf_vmatoa ("u", content_type
));
3816 SKIP_ULEB (format
, end
);
3821 for (datai
= 0; datai
< data_count
; datai
++)
3823 unsigned char *datapass
= data
;
3825 printf (" %d", last_entry
++);
3826 /* Delay displaying name as the last entry for better screen layout. */
3827 for (namepass
= 0; namepass
< 2; namepass
++)
3829 format
= format_start
;
3831 for (formati
= 0; formati
< format_count
; formati
++)
3833 dwarf_vma content_type
, form
;
3835 READ_ULEB (content_type
, format
, end
);
3836 READ_ULEB (form
, format
, end
);
3837 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
3838 0, 0, linfo
->li_offset_size
,
3839 linfo
->li_version
, NULL
,
3840 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3841 section
, NULL
, '\t', -1);
3845 if (data
== end
&& (datai
< data_count
- 1))
3847 warn (_("\n%s: Corrupt entries list\n"), table_name
);
3856 display_debug_lines_raw (struct dwarf_section
* section
,
3857 unsigned char * data
,
3858 unsigned char * end
,
3861 unsigned char *start
= section
->start
;
3862 int verbose_view
= 0;
3864 introduce (section
, TRUE
);
3868 static DWARF2_Internal_LineInfo saved_linfo
;
3869 DWARF2_Internal_LineInfo linfo
;
3870 unsigned char *standard_opcodes
;
3871 unsigned char *end_of_sequence
;
3874 if (const_strneq (section
->name
, ".debug_line.")
3875 /* Note: the following does not apply to .debug_line.dwo sections.
3876 These are full debug_line sections. */
3877 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3879 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3880 section containing just the Line Number Statements. They are
3881 created by the assembler and intended to be used alongside gcc's
3882 -ffunction-sections command line option. When the linker's
3883 garbage collection decides to discard a .text.<foo> section it
3884 can then also discard the line number information in .debug_line.<foo>.
3886 Since the section is a fragment it does not have the details
3887 needed to fill out a LineInfo structure, so instead we use the
3888 details from the last full debug_line section that we processed. */
3889 end_of_sequence
= end
;
3890 standard_opcodes
= NULL
;
3891 linfo
= saved_linfo
;
3892 /* PR 17531: file: 0522b371. */
3893 if (linfo
.li_line_range
== 0)
3895 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3898 reset_state_machine (linfo
.li_default_is_stmt
);
3902 unsigned char * hdrptr
;
3904 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3905 & end_of_sequence
)) == NULL
)
3908 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3909 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3910 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3911 if (linfo
.li_version
>= 5)
3913 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
3914 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
3916 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3917 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3918 if (linfo
.li_version
>= 4)
3919 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3920 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3921 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3922 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3923 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3925 /* PR 17512: file: 1665-6428-0.004. */
3926 if (linfo
.li_line_range
== 0)
3928 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3929 linfo
.li_line_range
= 1;
3932 reset_state_machine (linfo
.li_default_is_stmt
);
3934 /* Display the contents of the Opcodes table. */
3935 standard_opcodes
= hdrptr
;
3937 /* PR 17512: file: 002-417945-0.004. */
3938 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3940 warn (_("Line Base extends beyond end of section\n"));
3944 printf (_("\n Opcodes:\n"));
3946 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3947 printf (ngettext (" Opcode %d has %d arg\n",
3948 " Opcode %d has %d args\n",
3949 standard_opcodes
[i
- 1]),
3950 i
, standard_opcodes
[i
- 1]);
3952 /* Display the contents of the Directory table. */
3953 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3955 if (linfo
.li_version
>= 5)
3957 load_debug_section_with_follow (line_str
, file
);
3959 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3961 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3967 printf (_("\n The Directory Table is empty.\n"));
3970 unsigned int last_dir_entry
= 0;
3972 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3973 (long)(data
- start
));
3975 while (data
< end
&& *data
!= 0)
3977 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3979 data
+= strnlen ((char *) data
, end
- data
) + 1;
3982 /* PR 17512: file: 002-132094-0.004. */
3983 if (data
>= end
- 1)
3987 /* Skip the NUL at the end of the table. */
3990 /* Display the contents of the File Name table. */
3992 printf (_("\n The File Name Table is empty.\n"));
3995 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3996 (long)(data
- start
));
3997 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3999 while (data
< end
&& *data
!= 0)
4001 unsigned char *name
;
4004 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4006 data
+= strnlen ((char *) data
, end
- data
) + 1;
4008 READ_ULEB (val
, data
, end
);
4009 printf ("%s\t", dwarf_vmatoa ("u", val
));
4010 READ_ULEB (val
, data
, end
);
4011 printf ("%s\t", dwarf_vmatoa ("u", val
));
4012 READ_ULEB (val
, data
, end
);
4013 printf ("%s\t", dwarf_vmatoa ("u", val
));
4014 printf ("%.*s\n", (int)(end
- name
), name
);
4018 warn (_("Corrupt file name table entry\n"));
4024 /* Skip the NUL at the end of the table. */
4029 saved_linfo
= linfo
;
4032 /* Now display the statements. */
4033 if (data
>= end_of_sequence
)
4034 printf (_(" No Line Number Statements.\n"));
4037 printf (_(" Line Number Statements:\n"));
4039 while (data
< end_of_sequence
)
4041 unsigned char op_code
;
4042 dwarf_signed_vma adv
;
4045 printf (" [0x%08lx]", (long)(data
- start
));
4049 if (op_code
>= linfo
.li_opcode_base
)
4051 op_code
-= linfo
.li_opcode_base
;
4052 uladv
= (op_code
/ linfo
.li_line_range
);
4053 if (linfo
.li_max_ops_per_insn
== 1)
4055 uladv
*= linfo
.li_min_insn_length
;
4056 state_machine_regs
.address
+= uladv
;
4058 state_machine_regs
.view
= 0;
4059 printf (_(" Special opcode %d: "
4060 "advance Address by %s to 0x%s%s"),
4061 op_code
, dwarf_vmatoa ("u", uladv
),
4062 dwarf_vmatoa ("x", state_machine_regs
.address
),
4063 verbose_view
&& uladv
4064 ? _(" (reset view)") : "");
4069 = ((state_machine_regs
.op_index
+ uladv
)
4070 / linfo
.li_max_ops_per_insn
)
4071 * linfo
.li_min_insn_length
;
4073 state_machine_regs
.address
+= addrdelta
;
4074 state_machine_regs
.op_index
4075 = (state_machine_regs
.op_index
+ uladv
)
4076 % linfo
.li_max_ops_per_insn
;
4078 state_machine_regs
.view
= 0;
4079 printf (_(" Special opcode %d: "
4080 "advance Address by %s to 0x%s[%d]%s"),
4081 op_code
, dwarf_vmatoa ("u", uladv
),
4082 dwarf_vmatoa ("x", state_machine_regs
.address
),
4083 state_machine_regs
.op_index
,
4084 verbose_view
&& addrdelta
4085 ? _(" (reset view)") : "");
4087 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4088 state_machine_regs
.line
+= adv
;
4089 printf (_(" and Line by %s to %d"),
4090 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4091 if (verbose_view
|| state_machine_regs
.view
)
4092 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4095 state_machine_regs
.view
++;
4100 case DW_LNS_extended_op
:
4101 data
+= process_extended_line_op (data
,
4102 linfo
.li_default_is_stmt
,
4107 printf (_(" Copy"));
4108 if (verbose_view
|| state_machine_regs
.view
)
4109 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4112 state_machine_regs
.view
++;
4115 case DW_LNS_advance_pc
:
4116 READ_ULEB (uladv
, data
, end
);
4117 if (linfo
.li_max_ops_per_insn
== 1)
4119 uladv
*= linfo
.li_min_insn_length
;
4120 state_machine_regs
.address
+= uladv
;
4122 state_machine_regs
.view
= 0;
4123 printf (_(" Advance PC by %s to 0x%s%s\n"),
4124 dwarf_vmatoa ("u", uladv
),
4125 dwarf_vmatoa ("x", state_machine_regs
.address
),
4126 verbose_view
&& uladv
4127 ? _(" (reset view)") : "");
4132 = ((state_machine_regs
.op_index
+ uladv
)
4133 / linfo
.li_max_ops_per_insn
)
4134 * linfo
.li_min_insn_length
;
4135 state_machine_regs
.address
4137 state_machine_regs
.op_index
4138 = (state_machine_regs
.op_index
+ uladv
)
4139 % linfo
.li_max_ops_per_insn
;
4141 state_machine_regs
.view
= 0;
4142 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4143 dwarf_vmatoa ("u", uladv
),
4144 dwarf_vmatoa ("x", state_machine_regs
.address
),
4145 state_machine_regs
.op_index
,
4146 verbose_view
&& addrdelta
4147 ? _(" (reset view)") : "");
4151 case DW_LNS_advance_line
:
4152 READ_SLEB (adv
, data
, end
);
4153 state_machine_regs
.line
+= adv
;
4154 printf (_(" Advance Line by %s to %d\n"),
4155 dwarf_vmatoa ("d", adv
),
4156 state_machine_regs
.line
);
4159 case DW_LNS_set_file
:
4160 READ_ULEB (uladv
, data
, end
);
4161 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4162 dwarf_vmatoa ("u", uladv
));
4163 state_machine_regs
.file
= uladv
;
4166 case DW_LNS_set_column
:
4167 READ_ULEB (uladv
, data
, end
);
4168 printf (_(" Set column to %s\n"),
4169 dwarf_vmatoa ("u", uladv
));
4170 state_machine_regs
.column
= uladv
;
4173 case DW_LNS_negate_stmt
:
4174 adv
= state_machine_regs
.is_stmt
;
4176 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4177 state_machine_regs
.is_stmt
= adv
;
4180 case DW_LNS_set_basic_block
:
4181 printf (_(" Set basic block\n"));
4182 state_machine_regs
.basic_block
= 1;
4185 case DW_LNS_const_add_pc
:
4186 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4187 if (linfo
.li_max_ops_per_insn
)
4189 uladv
*= linfo
.li_min_insn_length
;
4190 state_machine_regs
.address
+= uladv
;
4192 state_machine_regs
.view
= 0;
4193 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4194 dwarf_vmatoa ("u", uladv
),
4195 dwarf_vmatoa ("x", state_machine_regs
.address
),
4196 verbose_view
&& uladv
4197 ? _(" (reset view)") : "");
4202 = ((state_machine_regs
.op_index
+ uladv
)
4203 / linfo
.li_max_ops_per_insn
)
4204 * linfo
.li_min_insn_length
;
4205 state_machine_regs
.address
4207 state_machine_regs
.op_index
4208 = (state_machine_regs
.op_index
+ uladv
)
4209 % linfo
.li_max_ops_per_insn
;
4211 state_machine_regs
.view
= 0;
4212 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4213 dwarf_vmatoa ("u", uladv
),
4214 dwarf_vmatoa ("x", state_machine_regs
.address
),
4215 state_machine_regs
.op_index
,
4216 verbose_view
&& addrdelta
4217 ? _(" (reset view)") : "");
4221 case DW_LNS_fixed_advance_pc
:
4222 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4223 state_machine_regs
.address
+= uladv
;
4224 state_machine_regs
.op_index
= 0;
4225 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4226 dwarf_vmatoa ("u", uladv
),
4227 dwarf_vmatoa ("x", state_machine_regs
.address
));
4228 /* Do NOT reset view. */
4231 case DW_LNS_set_prologue_end
:
4232 printf (_(" Set prologue_end to true\n"));
4235 case DW_LNS_set_epilogue_begin
:
4236 printf (_(" Set epilogue_begin to true\n"));
4239 case DW_LNS_set_isa
:
4240 READ_ULEB (uladv
, data
, end
);
4241 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4245 printf (_(" Unknown opcode %d with operands: "), op_code
);
4247 if (standard_opcodes
!= NULL
)
4248 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4250 READ_ULEB (uladv
, data
, end
);
4251 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4252 i
== 1 ? "" : ", ");
4267 unsigned char *name
;
4268 unsigned int directory_index
;
4269 unsigned int modification_date
;
4270 unsigned int length
;
4273 /* Output a decoded representation of the .debug_line section. */
4276 display_debug_lines_decoded (struct dwarf_section
* section
,
4277 unsigned char * start
,
4278 unsigned char * data
,
4279 unsigned char * end
,
4282 static DWARF2_Internal_LineInfo saved_linfo
;
4284 introduce (section
, FALSE
);
4288 /* This loop amounts to one iteration per compilation unit. */
4289 DWARF2_Internal_LineInfo linfo
;
4290 unsigned char *standard_opcodes
;
4291 unsigned char *end_of_sequence
;
4293 File_Entry
*file_table
= NULL
;
4294 unsigned int n_files
= 0;
4295 unsigned char **directory_table
= NULL
;
4296 dwarf_vma n_directories
= 0;
4298 if (const_strneq (section
->name
, ".debug_line.")
4299 /* Note: the following does not apply to .debug_line.dwo sections.
4300 These are full debug_line sections. */
4301 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4303 /* See comment in display_debug_lines_raw(). */
4304 end_of_sequence
= end
;
4305 standard_opcodes
= NULL
;
4306 linfo
= saved_linfo
;
4307 /* PR 17531: file: 0522b371. */
4308 if (linfo
.li_line_range
== 0)
4310 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4313 reset_state_machine (linfo
.li_default_is_stmt
);
4317 unsigned char *hdrptr
;
4319 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4320 & end_of_sequence
)) == NULL
)
4323 /* PR 17531: file: 0522b371. */
4324 if (linfo
.li_line_range
== 0)
4326 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4327 linfo
.li_line_range
= 1;
4329 reset_state_machine (linfo
.li_default_is_stmt
);
4331 /* Save a pointer to the contents of the Opcodes table. */
4332 standard_opcodes
= hdrptr
;
4334 /* Traverse the Directory table just to count entries. */
4335 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4339 warn (_("opcode base of %d extends beyond end of section\n"),
4340 linfo
.li_opcode_base
);
4344 if (linfo
.li_version
>= 5)
4346 unsigned char *format_start
, format_count
, *format
;
4347 dwarf_vma formati
, entryi
;
4349 load_debug_section_with_follow (line_str
, fileptr
);
4351 /* Skip directories format. */
4352 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4353 if (do_checks
&& format_count
> 1)
4354 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4356 format_start
= data
;
4357 for (formati
= 0; formati
< format_count
; formati
++)
4359 SKIP_ULEB (data
, end
);
4360 SKIP_ULEB (data
, end
);
4363 READ_ULEB (n_directories
, data
, end
);
4366 warn (_("Corrupt directories list\n"));
4370 if (n_directories
== 0)
4371 directory_table
= NULL
;
4373 directory_table
= (unsigned char **)
4374 xmalloc (n_directories
* sizeof (unsigned char *));
4376 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4378 unsigned char **pathp
= &directory_table
[entryi
];
4380 format
= format_start
;
4381 for (formati
= 0; formati
< format_count
; formati
++)
4383 dwarf_vma content_type
, form
;
4386 READ_ULEB (content_type
, format
, end
);
4387 READ_ULEB (form
, format
, end
);
4390 warn (_("Corrupt directories list\n"));
4393 switch (content_type
)
4398 case DW_FORM_string
:
4401 case DW_FORM_line_strp
:
4402 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4404 /* Remove const by the cast. */
4405 *pathp
= (unsigned char *)
4406 fetch_indirect_line_string (uvalue
);
4411 data
= read_and_display_attr_value (0, form
, 0, start
,
4413 linfo
.li_offset_size
,
4420 warn (_("Corrupt directories list\n"));
4425 /* Skip files format. */
4426 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4427 if (do_checks
&& format_count
> 5)
4428 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4430 format_start
= data
;
4431 for (formati
= 0; formati
< format_count
; formati
++)
4433 SKIP_ULEB (data
, end
);
4434 SKIP_ULEB (data
, end
);
4437 READ_ULEB (n_files
, data
, end
);
4438 if (data
== end
&& n_files
> 0)
4440 warn (_("Corrupt file name list\n"));
4447 file_table
= (File_Entry
*) xcalloc (1, n_files
4448 * sizeof (File_Entry
));
4450 for (entryi
= 0; entryi
< n_files
; entryi
++)
4452 File_Entry
*file
= &file_table
[entryi
];
4454 format
= format_start
;
4455 for (formati
= 0; formati
< format_count
; formati
++)
4457 dwarf_vma content_type
, form
;
4461 READ_ULEB (content_type
, format
, end
);
4462 READ_ULEB (form
, format
, end
);
4465 warn (_("Corrupt file name list\n"));
4468 switch (content_type
)
4473 case DW_FORM_string
:
4476 case DW_FORM_line_strp
:
4477 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4479 /* Remove const by the cast. */
4480 file
->name
= (unsigned char *)
4481 fetch_indirect_line_string (uvalue
);
4485 case DW_LNCT_directory_index
:
4489 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4493 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4498 READ_ULEB (file
->directory_index
, tmp
, end
);
4503 data
= read_and_display_attr_value (0, form
, 0, start
,
4505 linfo
.li_offset_size
,
4512 warn (_("Corrupt file name list\n"));
4521 unsigned char *ptr_directory_table
= data
;
4523 while (data
< end
&& *data
!= 0)
4525 data
+= strnlen ((char *) data
, end
- data
) + 1;
4532 warn (_("directory table ends unexpectedly\n"));
4537 /* Go through the directory table again to save the directories. */
4538 directory_table
= (unsigned char **)
4539 xmalloc (n_directories
* sizeof (unsigned char *));
4542 while (*ptr_directory_table
!= 0)
4544 directory_table
[i
] = ptr_directory_table
;
4545 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4546 ptr_directory_table
- end
) + 1;
4550 /* Skip the NUL at the end of the table. */
4553 /* Traverse the File Name table just to count the entries. */
4554 if (data
< end
&& *data
!= 0)
4556 unsigned char *ptr_file_name_table
= data
;
4558 while (data
< end
&& *data
!= 0)
4560 /* Skip Name, directory index, last modification
4561 time and length of file. */
4562 data
+= strnlen ((char *) data
, end
- data
) + 1;
4563 SKIP_ULEB (data
, end
);
4564 SKIP_ULEB (data
, end
);
4565 SKIP_ULEB (data
, end
);
4571 warn (_("file table ends unexpectedly\n"));
4576 /* Go through the file table again to save the strings. */
4577 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4580 while (*ptr_file_name_table
!= 0)
4582 file_table
[i
].name
= ptr_file_name_table
;
4583 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4584 end
- ptr_file_name_table
) + 1;
4586 /* We are not interested in directory, time or size. */
4587 READ_ULEB (file_table
[i
].directory_index
,
4588 ptr_file_name_table
, end
);
4589 READ_ULEB (file_table
[i
].modification_date
,
4590 ptr_file_name_table
, end
);
4591 READ_ULEB (file_table
[i
].length
,
4592 ptr_file_name_table
, end
);
4598 /* Skip the NUL at the end of the table. */
4602 /* Print the Compilation Unit's name and a header. */
4603 if (file_table
== NULL
)
4604 printf (_("CU: No directory table\n"));
4605 else if (directory_table
== NULL
)
4606 printf (_("CU: %s:\n"), file_table
[0].name
);
4609 unsigned int ix
= file_table
[0].directory_index
;
4610 const char *directory
;
4615 else if (n_directories
== 0)
4616 directory
= _("<unknown>");
4617 else if (ix
> n_directories
)
4619 warn (_("directory index %u > number of directories %s\n"),
4620 ix
, dwarf_vmatoa ("u", n_directories
));
4621 directory
= _("<corrupt>");
4624 directory
= (char *) directory_table
[ix
- 1];
4626 if (do_wide
|| strlen (directory
) < 76)
4627 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4629 printf ("%s:\n", file_table
[0].name
);
4633 printf (_("File name Line number Starting address View Stmt\n"));
4635 printf (_("CU: Empty file name table\n"));
4636 saved_linfo
= linfo
;
4639 /* This loop iterates through the Dwarf Line Number Program. */
4640 while (data
< end_of_sequence
)
4642 unsigned char op_code
;
4645 unsigned long int uladv
;
4646 int is_special_opcode
= 0;
4651 if (op_code
>= linfo
.li_opcode_base
)
4653 op_code
-= linfo
.li_opcode_base
;
4654 uladv
= (op_code
/ linfo
.li_line_range
);
4655 if (linfo
.li_max_ops_per_insn
== 1)
4657 uladv
*= linfo
.li_min_insn_length
;
4658 state_machine_regs
.address
+= uladv
;
4660 state_machine_regs
.view
= 0;
4665 = ((state_machine_regs
.op_index
+ uladv
)
4666 / linfo
.li_max_ops_per_insn
)
4667 * linfo
.li_min_insn_length
;
4668 state_machine_regs
.address
4670 state_machine_regs
.op_index
4671 = (state_machine_regs
.op_index
+ uladv
)
4672 % linfo
.li_max_ops_per_insn
;
4674 state_machine_regs
.view
= 0;
4677 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4678 state_machine_regs
.line
+= adv
;
4679 is_special_opcode
= 1;
4680 /* Increment view after printing this row. */
4685 case DW_LNS_extended_op
:
4687 unsigned int ext_op_code_len
;
4688 unsigned char ext_op_code
;
4689 unsigned char *op_code_end
;
4690 unsigned char *op_code_data
= data
;
4692 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
4693 op_code_end
= op_code_data
+ ext_op_code_len
;
4694 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
4696 warn (_("Badly formed extended line op encountered!\n"));
4699 ext_op_code
= *op_code_data
++;
4703 switch (ext_op_code
)
4705 case DW_LNE_end_sequence
:
4706 /* Reset stuff after printing this row. */
4708 case DW_LNE_set_address
:
4709 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4711 op_code_end
- op_code_data
,
4713 state_machine_regs
.op_index
= 0;
4714 state_machine_regs
.view
= 0;
4716 case DW_LNE_define_file
:
4717 file_table
= (File_Entry
*) xrealloc
4718 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4720 ++state_machine_regs
.last_file_entry
;
4721 /* Source file name. */
4722 file_table
[n_files
].name
= op_code_data
;
4723 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4724 /* Directory index. */
4725 READ_ULEB (file_table
[n_files
].directory_index
,
4726 op_code_data
, op_code_end
);
4727 /* Last modification time. */
4728 READ_ULEB (file_table
[n_files
].modification_date
,
4729 op_code_data
, op_code_end
);
4731 READ_ULEB (file_table
[n_files
].length
,
4732 op_code_data
, op_code_end
);
4736 case DW_LNE_set_discriminator
:
4737 case DW_LNE_HP_set_sequence
:
4738 /* Simply ignored. */
4742 printf (_("UNKNOWN (%u): length %ld\n"),
4743 ext_op_code
, (long int) (op_code_data
- data
));
4750 /* Increment view after printing this row. */
4753 case DW_LNS_advance_pc
:
4754 READ_ULEB (uladv
, data
, end
);
4755 if (linfo
.li_max_ops_per_insn
== 1)
4757 uladv
*= linfo
.li_min_insn_length
;
4758 state_machine_regs
.address
+= uladv
;
4760 state_machine_regs
.view
= 0;
4765 = ((state_machine_regs
.op_index
+ uladv
)
4766 / linfo
.li_max_ops_per_insn
)
4767 * linfo
.li_min_insn_length
;
4768 state_machine_regs
.address
4770 state_machine_regs
.op_index
4771 = (state_machine_regs
.op_index
+ uladv
)
4772 % linfo
.li_max_ops_per_insn
;
4774 state_machine_regs
.view
= 0;
4778 case DW_LNS_advance_line
:
4779 READ_SLEB (adv
, data
, end
);
4780 state_machine_regs
.line
+= adv
;
4783 case DW_LNS_set_file
:
4784 READ_ULEB (uladv
, data
, end
);
4785 state_machine_regs
.file
= uladv
;
4788 unsigned file
= state_machine_regs
.file
- 1;
4791 if (file_table
== NULL
|| n_files
== 0)
4792 printf (_("\n [Use file table entry %d]\n"), file
);
4794 else if (file
>= n_files
)
4796 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4797 printf (_("\n <over large file table index %u>"), file
);
4799 else if ((dir
= file_table
[file
].directory_index
) == 0)
4800 /* If directory index is 0, that means current directory. */
4801 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4802 else if (directory_table
== NULL
|| n_directories
== 0)
4803 printf (_("\n [Use file %s in directory table entry %d]\n"),
4804 file_table
[file
].name
, dir
);
4806 else if (dir
> n_directories
)
4808 warn (_("directory index %u > number of directories %s\n"),
4809 dir
, dwarf_vmatoa ("u", n_directories
));
4810 printf (_("\n <over large directory table entry %u>\n"), dir
);
4813 printf ("\n%s/%s:\n",
4814 /* The directory index starts counting at 1. */
4815 directory_table
[dir
- 1], file_table
[file
].name
);
4819 case DW_LNS_set_column
:
4820 READ_ULEB (uladv
, data
, end
);
4821 state_machine_regs
.column
= uladv
;
4824 case DW_LNS_negate_stmt
:
4825 adv
= state_machine_regs
.is_stmt
;
4827 state_machine_regs
.is_stmt
= adv
;
4830 case DW_LNS_set_basic_block
:
4831 state_machine_regs
.basic_block
= 1;
4834 case DW_LNS_const_add_pc
:
4835 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4836 if (linfo
.li_max_ops_per_insn
== 1)
4838 uladv
*= linfo
.li_min_insn_length
;
4839 state_machine_regs
.address
+= uladv
;
4841 state_machine_regs
.view
= 0;
4846 = ((state_machine_regs
.op_index
+ uladv
)
4847 / linfo
.li_max_ops_per_insn
)
4848 * linfo
.li_min_insn_length
;
4849 state_machine_regs
.address
4851 state_machine_regs
.op_index
4852 = (state_machine_regs
.op_index
+ uladv
)
4853 % linfo
.li_max_ops_per_insn
;
4855 state_machine_regs
.view
= 0;
4859 case DW_LNS_fixed_advance_pc
:
4860 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4861 state_machine_regs
.address
+= uladv
;
4862 state_machine_regs
.op_index
= 0;
4863 /* Do NOT reset view. */
4866 case DW_LNS_set_prologue_end
:
4869 case DW_LNS_set_epilogue_begin
:
4872 case DW_LNS_set_isa
:
4873 READ_ULEB (uladv
, data
, end
);
4874 printf (_(" Set ISA to %lu\n"), uladv
);
4878 printf (_(" Unknown opcode %d with operands: "), op_code
);
4880 if (standard_opcodes
!= NULL
)
4881 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4885 READ_ULEB (val
, data
, end
);
4886 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
4887 i
== 1 ? "" : ", ");
4893 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4894 to the DWARF address/line matrix. */
4895 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4896 || (xop
== DW_LNS_copy
))
4898 const unsigned int MAX_FILENAME_LENGTH
= 35;
4900 char *newFileName
= NULL
;
4901 size_t fileNameLength
;
4905 unsigned indx
= state_machine_regs
.file
- 1;
4907 if (indx
>= n_files
)
4909 warn (_("corrupt file index %u encountered\n"), indx
);
4910 fileName
= _("<corrupt>");
4913 fileName
= (char *) file_table
[indx
].name
;
4916 fileName
= _("<unknown>");
4918 fileNameLength
= strlen (fileName
);
4920 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4922 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4923 /* Truncate file name */
4924 strncpy (newFileName
,
4925 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4926 MAX_FILENAME_LENGTH
+ 1);
4927 /* FIXME: This is to pacify gcc-10 which can warn that the
4928 strncpy above might leave a non-NUL terminated string
4929 in newFileName. It won't, but gcc's analysis doesn't
4930 quite go far enough to discover this. */
4931 newFileName
[MAX_FILENAME_LENGTH
] = 0;
4935 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4936 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4939 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4941 if (linfo
.li_max_ops_per_insn
== 1)
4942 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4943 newFileName
, state_machine_regs
.line
,
4944 state_machine_regs
.address
);
4946 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4947 newFileName
, state_machine_regs
.line
,
4948 state_machine_regs
.address
,
4949 state_machine_regs
.op_index
);
4953 if (linfo
.li_max_ops_per_insn
== 1)
4954 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4955 newFileName
, state_machine_regs
.line
,
4956 state_machine_regs
.address
);
4958 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4959 newFileName
, state_machine_regs
.line
,
4960 state_machine_regs
.address
,
4961 state_machine_regs
.op_index
);
4964 if (state_machine_regs
.view
)
4965 printf (" %6u", state_machine_regs
.view
);
4969 if (state_machine_regs
.is_stmt
)
4973 state_machine_regs
.view
++;
4975 if (xop
== -DW_LNE_end_sequence
)
4977 reset_state_machine (linfo
.li_default_is_stmt
);
4992 if (directory_table
)
4994 free (directory_table
);
4995 directory_table
= NULL
;
5006 display_debug_lines (struct dwarf_section
*section
, void *file
)
5008 unsigned char *data
= section
->start
;
5009 unsigned char *end
= data
+ section
->size
;
5011 int retValDecoded
= 1;
5013 if (do_debug_lines
== 0)
5014 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5016 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5017 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5019 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5020 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5022 if (!retValRaw
|| !retValDecoded
)
5029 find_debug_info_for_offset (unsigned long offset
)
5033 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5036 for (i
= 0; i
< num_debug_info_entries
; i
++)
5037 if (debug_information
[i
].cu_offset
== offset
)
5038 return debug_information
+ i
;
5044 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5046 /* See gdb/gdb-index.h. */
5047 static const char * const kinds
[] =
5059 return _ (kinds
[kind
]);
5063 display_debug_pubnames_worker (struct dwarf_section
*section
,
5064 void *file ATTRIBUTE_UNUSED
,
5067 DWARF2_Internal_PubNames names
;
5068 unsigned char *start
= section
->start
;
5069 unsigned char *end
= start
+ section
->size
;
5071 /* It does not matter if this load fails,
5072 we test for that later on. */
5073 load_debug_info (file
);
5075 introduce (section
, FALSE
);
5079 unsigned char *data
;
5080 unsigned long sec_off
;
5081 unsigned int offset_size
, initial_length_size
;
5083 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5084 if (names
.pn_length
== 0xffffffff)
5086 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5088 initial_length_size
= 12;
5093 initial_length_size
= 4;
5096 sec_off
= start
- section
->start
;
5097 if (sec_off
+ names
.pn_length
< sec_off
5098 || sec_off
+ names
.pn_length
> section
->size
)
5100 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5102 sec_off
- initial_length_size
,
5103 dwarf_vmatoa ("x", names
.pn_length
));
5108 start
+= names
.pn_length
;
5110 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5111 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5113 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5114 && num_debug_info_entries
> 0
5115 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5116 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5117 (unsigned long) names
.pn_offset
, section
->name
);
5119 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5121 printf (_(" Length: %ld\n"),
5122 (long) names
.pn_length
);
5123 printf (_(" Version: %d\n"),
5125 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5126 (unsigned long) names
.pn_offset
);
5127 printf (_(" Size of area in .debug_info section: %ld\n"),
5128 (long) names
.pn_size
);
5130 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5132 static int warned
= 0;
5136 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5144 printf (_("\n Offset Kind Name\n"));
5146 printf (_("\n Offset\tName\n"));
5150 bfd_size_type maxprint
;
5153 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5158 data
+= offset_size
;
5161 maxprint
= (end
- data
) - 1;
5165 unsigned int kind_data
;
5166 gdb_index_symbol_kind kind
;
5167 const char *kind_name
;
5170 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5173 /* GCC computes the kind as the upper byte in the CU index
5174 word, and then right shifts it by the CU index size.
5175 Left shift KIND to where the gdb-index.h accessor macros
5177 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5178 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5179 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5180 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5181 printf (" %-6lx %s,%-10s %.*s\n",
5182 (unsigned long) offset
, is_static
? _("s") : _("g"),
5183 kind_name
, (int) maxprint
, data
);
5186 printf (" %-6lx\t%.*s\n",
5187 (unsigned long) offset
, (int) maxprint
, data
);
5189 data
+= strnlen ((char *) data
, maxprint
) + 1;
5200 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5202 return display_debug_pubnames_worker (section
, file
, 0);
5206 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5208 return display_debug_pubnames_worker (section
, file
, 1);
5212 display_debug_macinfo (struct dwarf_section
*section
,
5213 void *file ATTRIBUTE_UNUSED
)
5215 unsigned char *start
= section
->start
;
5216 unsigned char *end
= start
+ section
->size
;
5217 unsigned char *curr
= start
;
5218 enum dwarf_macinfo_record_type op
;
5220 introduce (section
, FALSE
);
5224 unsigned int lineno
;
5225 const unsigned char *string
;
5227 op
= (enum dwarf_macinfo_record_type
) *curr
;
5232 case DW_MACINFO_start_file
:
5234 unsigned int filenum
;
5236 READ_ULEB (lineno
, curr
, end
);
5237 READ_ULEB (filenum
, curr
, end
);
5238 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5243 case DW_MACINFO_end_file
:
5244 printf (_(" DW_MACINFO_end_file\n"));
5247 case DW_MACINFO_define
:
5248 READ_ULEB (lineno
, curr
, end
);
5250 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5251 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5255 case DW_MACINFO_undef
:
5256 READ_ULEB (lineno
, curr
, end
);
5258 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5259 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5263 case DW_MACINFO_vendor_ext
:
5265 unsigned int constant
;
5267 READ_ULEB (constant
, curr
, end
);
5269 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5270 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5280 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5281 filename and dirname corresponding to file name table entry with index
5282 FILEIDX. Return NULL on failure. */
5284 static unsigned char *
5285 get_line_filename_and_dirname (dwarf_vma line_offset
,
5287 unsigned char **dir_name
)
5289 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5290 unsigned char *hdrptr
, *dirtable
, *file_name
;
5291 unsigned int offset_size
, initial_length_size
;
5292 unsigned int version
, opcode_base
;
5293 dwarf_vma length
, diridx
;
5294 const unsigned char * end
;
5297 if (section
->start
== NULL
5298 || line_offset
>= section
->size
5302 hdrptr
= section
->start
+ line_offset
;
5303 end
= section
->start
+ section
->size
;
5305 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5306 if (length
== 0xffffffff)
5308 /* This section is 64-bit DWARF 3. */
5309 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5311 initial_length_size
= 12;
5316 initial_length_size
= 4;
5318 if (length
+ initial_length_size
< length
5319 || length
+ initial_length_size
> section
->size
)
5322 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5323 if (version
!= 2 && version
!= 3 && version
!= 4)
5325 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5327 hdrptr
++; /* Skip max_ops_per_insn. */
5328 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5330 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5331 if (opcode_base
== 0)
5334 hdrptr
+= opcode_base
- 1;
5339 /* Skip over dirname table. */
5340 while (*hdrptr
!= '\0')
5342 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5346 hdrptr
++; /* Skip the NUL at the end of the table. */
5348 /* Now skip over preceding filename table entries. */
5349 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5351 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5352 SKIP_ULEB (hdrptr
, end
);
5353 SKIP_ULEB (hdrptr
, end
);
5354 SKIP_ULEB (hdrptr
, end
);
5356 if (hdrptr
>= end
|| *hdrptr
== '\0')
5360 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5363 READ_ULEB (diridx
, hdrptr
, end
);
5366 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5367 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5368 if (dirtable
>= end
|| *dirtable
== '\0')
5370 *dir_name
= dirtable
;
5375 display_debug_macro (struct dwarf_section
*section
,
5378 unsigned char *start
= section
->start
;
5379 unsigned char *end
= start
+ section
->size
;
5380 unsigned char *curr
= start
;
5381 unsigned char *extended_op_buf
[256];
5383 load_debug_section_with_follow (str
, file
);
5384 load_debug_section_with_follow (line
, file
);
5386 introduce (section
, FALSE
);
5390 unsigned int lineno
, version
, flags
;
5391 unsigned int offset_size
= 4;
5392 const unsigned char *string
;
5393 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5394 unsigned char **extended_ops
= NULL
;
5396 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5397 if (version
!= 4 && version
!= 5)
5399 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5404 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5407 printf (_(" Offset: 0x%lx\n"),
5408 (unsigned long) sec_offset
);
5409 printf (_(" Version: %d\n"), version
);
5410 printf (_(" Offset size: %d\n"), offset_size
);
5413 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5414 printf (_(" Offset into .debug_line: 0x%lx\n"),
5415 (unsigned long) line_offset
);
5419 unsigned int i
, count
, op
;
5422 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5424 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5425 extended_ops
= extended_op_buf
;
5428 printf (_(" Extension opcode arguments:\n"));
5429 for (i
= 0; i
< count
; i
++)
5431 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5432 extended_ops
[op
] = curr
;
5433 READ_ULEB (nargs
, curr
, end
);
5435 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5438 printf (_(" DW_MACRO_%02x arguments: "), op
);
5439 for (n
= 0; n
< nargs
; n
++)
5443 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5444 printf ("%s%s", get_FORM_name (form
),
5445 n
== nargs
- 1 ? "\n" : ", ");
5455 case DW_FORM_block1
:
5456 case DW_FORM_block2
:
5457 case DW_FORM_block4
:
5459 case DW_FORM_string
:
5461 case DW_FORM_sec_offset
:
5464 error (_("Invalid extension opcode form %s\n"),
5465 get_FORM_name (form
));
5481 error (_(".debug_macro section not zero terminated\n"));
5485 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5491 case DW_MACRO_start_file
:
5493 unsigned int filenum
;
5494 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5496 READ_ULEB (lineno
, curr
, end
);
5497 READ_ULEB (filenum
, curr
, end
);
5499 if ((flags
& 2) == 0)
5500 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5503 = get_line_filename_and_dirname (line_offset
, filenum
,
5505 if (file_name
== NULL
)
5506 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5509 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5511 dir_name
!= NULL
? (const char *) dir_name
: "",
5512 dir_name
!= NULL
? "/" : "", file_name
);
5516 case DW_MACRO_end_file
:
5517 printf (_(" DW_MACRO_end_file\n"));
5520 case DW_MACRO_define
:
5521 READ_ULEB (lineno
, curr
, end
);
5523 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5524 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5528 case DW_MACRO_undef
:
5529 READ_ULEB (lineno
, curr
, end
);
5531 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5532 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5536 case DW_MACRO_define_strp
:
5537 READ_ULEB (lineno
, curr
, end
);
5538 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5539 string
= fetch_indirect_string (offset
);
5540 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5544 case DW_MACRO_undef_strp
:
5545 READ_ULEB (lineno
, curr
, end
);
5546 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5547 string
= fetch_indirect_string (offset
);
5548 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5552 case DW_MACRO_import
:
5553 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5554 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5555 (unsigned long) offset
);
5558 case DW_MACRO_define_sup
:
5559 READ_ULEB (lineno
, curr
, end
);
5560 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5561 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5562 lineno
, (unsigned long) offset
);
5565 case DW_MACRO_undef_sup
:
5566 READ_ULEB (lineno
, curr
, end
);
5567 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5568 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5569 lineno
, (unsigned long) offset
);
5572 case DW_MACRO_import_sup
:
5573 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5574 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5575 (unsigned long) offset
);
5579 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5581 error (_(" Unknown macro opcode %02x seen\n"), op
);
5586 /* Skip over unhandled opcodes. */
5588 unsigned char *desc
= extended_ops
[op
];
5589 READ_ULEB (nargs
, desc
, end
);
5592 printf (_(" DW_MACRO_%02x\n"), op
);
5595 printf (_(" DW_MACRO_%02x -"), op
);
5596 for (n
= 0; n
< nargs
; n
++)
5600 /* DW_FORM_implicit_const is not expected here. */
5601 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5603 = read_and_display_attr_value (0, val
, 0,
5604 start
, curr
, end
, 0, 0, offset_size
,
5605 version
, NULL
, 0, NULL
,
5623 display_debug_abbrev (struct dwarf_section
*section
,
5624 void *file ATTRIBUTE_UNUSED
)
5626 abbrev_entry
*entry
;
5627 unsigned char *start
= section
->start
;
5628 unsigned char *end
= start
+ section
->size
;
5630 introduce (section
, FALSE
);
5634 unsigned char *last
;
5639 start
= process_abbrev_section (start
, end
);
5641 if (first_abbrev
== NULL
)
5644 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5646 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5650 printf (" %ld %s [%s]\n",
5652 get_TAG_name (entry
->tag
),
5653 entry
->children
? _("has children") : _("no children"));
5655 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5657 printf (" %-18s %s",
5658 get_AT_name (attr
->attribute
),
5659 get_FORM_name (attr
->form
));
5660 if (attr
->form
== DW_FORM_implicit_const
)
5661 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5673 /* Return true when ADDR is the maximum address, when addresses are
5674 POINTER_SIZE bytes long. */
5677 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5679 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5680 return ((addr
& mask
) == mask
);
5683 /* Display a view pair list starting at *VSTART_PTR and ending at
5684 VLISTEND within SECTION. */
5687 display_view_pair_list (struct dwarf_section
*section
,
5688 unsigned char **vstart_ptr
,
5689 unsigned int debug_info_entry
,
5690 unsigned char *vlistend
)
5692 unsigned char *vstart
= *vstart_ptr
;
5693 unsigned char *section_end
= section
->start
+ section
->size
;
5694 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5696 if (vlistend
< section_end
)
5697 section_end
= vlistend
;
5701 while (vstart
< section_end
)
5703 dwarf_vma off
= vstart
- section
->start
;
5704 dwarf_vma vbegin
, vend
;
5706 READ_ULEB (vbegin
, vstart
, section_end
);
5707 if (vstart
== section_end
)
5710 READ_ULEB (vend
, vstart
, section_end
);
5711 printf (" %8.8lx ", (unsigned long) off
);
5713 print_dwarf_view (vbegin
, pointer_size
, 1);
5714 print_dwarf_view (vend
, pointer_size
, 1);
5715 printf (_("location view pair\n"));
5719 *vstart_ptr
= vstart
;
5722 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5725 display_loc_list (struct dwarf_section
*section
,
5726 unsigned char **start_ptr
,
5727 unsigned int debug_info_entry
,
5729 dwarf_vma base_address
,
5730 unsigned char **vstart_ptr
,
5733 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5734 unsigned char *section_end
= section
->start
+ section
->size
;
5735 unsigned long cu_offset
;
5736 unsigned int pointer_size
;
5737 unsigned int offset_size
;
5742 unsigned short length
;
5743 int need_frame_base
;
5745 if (debug_info_entry
>= num_debug_info_entries
)
5747 warn (_("No debug information available for loc lists of entry: %u\n"),
5752 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5753 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5754 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5755 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5757 if (pointer_size
< 2 || pointer_size
> 8)
5759 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5760 pointer_size
, debug_info_entry
);
5766 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5767 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5769 if (start
+ 2 * pointer_size
> section_end
)
5771 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5772 (unsigned long) offset
);
5776 printf (" %8.8lx ", (unsigned long) off
);
5778 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5779 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5781 if (begin
== 0 && end
== 0)
5783 /* PR 18374: In a object file we can have a location list that
5784 starts with a begin and end of 0 because there are relocations
5785 that need to be applied to the addresses. Actually applying
5786 the relocations now does not help as they will probably resolve
5787 to 0, since the object file has not been fully linked. Real
5788 end of list markers will not have any relocations against them. */
5789 if (! reloc_at (section
, off
)
5790 && ! reloc_at (section
, off
+ pointer_size
))
5792 printf (_("<End of list>\n"));
5797 /* Check base address specifiers. */
5798 if (is_max_address (begin
, pointer_size
)
5799 && !is_max_address (end
, pointer_size
))
5802 print_dwarf_vma (begin
, pointer_size
);
5803 print_dwarf_vma (end
, pointer_size
);
5804 printf (_("(base address)\n"));
5810 off
= offset
+ (vstart
- *start_ptr
);
5812 READ_ULEB (vbegin
, vstart
, section_end
);
5813 print_dwarf_view (vbegin
, pointer_size
, 1);
5815 READ_ULEB (vend
, vstart
, section_end
);
5816 print_dwarf_view (vend
, pointer_size
, 1);
5818 printf (_("views at %8.8lx for:\n %*s "),
5819 (unsigned long) off
, 8, "");
5822 if (start
+ 2 > section_end
)
5824 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5825 (unsigned long) offset
);
5829 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5831 if (start
+ length
> section_end
)
5833 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5834 (unsigned long) offset
);
5838 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5839 print_dwarf_vma (end
+ base_address
, pointer_size
);
5842 need_frame_base
= decode_location_expression (start
,
5847 cu_offset
, section
);
5850 if (need_frame_base
&& !has_frame_base
)
5851 printf (_(" [without DW_AT_frame_base]"));
5853 if (begin
== end
&& vbegin
== vend
)
5854 fputs (_(" (start == end)"), stdout
);
5855 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5856 fputs (_(" (start > end)"), stdout
);
5864 *vstart_ptr
= vstart
;
5867 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5870 display_loclists_list (struct dwarf_section
*section
,
5871 unsigned char **start_ptr
,
5872 unsigned int debug_info_entry
,
5874 dwarf_vma base_address
,
5875 unsigned char **vstart_ptr
,
5878 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5879 unsigned char *section_end
= section
->start
+ section
->size
;
5880 unsigned long cu_offset
;
5881 unsigned int pointer_size
;
5882 unsigned int offset_size
;
5885 /* Initialize it due to a false compiler warning. */
5886 dwarf_vma begin
= -1, vbegin
= -1;
5887 dwarf_vma end
= -1, vend
= -1;
5889 int need_frame_base
;
5891 if (debug_info_entry
>= num_debug_info_entries
)
5893 warn (_("No debug information available for "
5894 "loclists lists of entry: %u\n"),
5899 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5900 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5901 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5902 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5904 if (pointer_size
< 2 || pointer_size
> 8)
5906 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5907 pointer_size
, debug_info_entry
);
5913 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5914 enum dwarf_location_list_entry_type llet
;
5916 if (start
+ 1 > section_end
)
5918 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5919 (unsigned long) offset
);
5923 printf (" %8.8lx ", (unsigned long) off
);
5925 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5927 if (vstart
&& llet
== DW_LLE_offset_pair
)
5929 off
= offset
+ (vstart
- *start_ptr
);
5931 READ_ULEB (vbegin
, vstart
, section_end
);
5932 print_dwarf_view (vbegin
, pointer_size
, 1);
5934 READ_ULEB (vend
, vstart
, section_end
);
5935 print_dwarf_view (vend
, pointer_size
, 1);
5937 printf (_("views at %8.8lx for:\n %*s "),
5938 (unsigned long) off
, 8, "");
5943 case DW_LLE_end_of_list
:
5944 printf (_("<End of list>\n"));
5946 case DW_LLE_offset_pair
:
5947 READ_ULEB (begin
, start
, section_end
);
5948 READ_ULEB (end
, start
, section_end
);
5950 case DW_LLE_base_address
:
5951 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5953 print_dwarf_vma (base_address
, pointer_size
);
5954 printf (_("(base address)\n"));
5956 #ifdef DW_LLE_view_pair
5957 case DW_LLE_view_pair
:
5959 printf (_("View pair entry in loclist with locviews attribute\n"));
5960 READ_ULEB (vbegin
, start
, section_end
);
5961 print_dwarf_view (vbegin
, pointer_size
, 1);
5963 READ_ULEB (vend
, start
, section_end
);
5964 print_dwarf_view (vend
, pointer_size
, 1);
5966 printf (_("views for:\n"));
5970 error (_("Invalid location list entry type %d\n"), llet
);
5973 if (llet
== DW_LLE_end_of_list
)
5975 if (llet
!= DW_LLE_offset_pair
)
5978 if (start
+ 2 > section_end
)
5980 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5981 (unsigned long) offset
);
5985 READ_ULEB (length
, start
, section_end
);
5987 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5988 print_dwarf_vma (end
+ base_address
, pointer_size
);
5991 need_frame_base
= decode_location_expression (start
,
5996 cu_offset
, section
);
5999 if (need_frame_base
&& !has_frame_base
)
6000 printf (_(" [without DW_AT_frame_base]"));
6002 if (begin
== end
&& vbegin
== vend
)
6003 fputs (_(" (start == end)"), stdout
);
6004 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6005 fputs (_(" (start > end)"), stdout
);
6013 if (vbegin
!= vm1
|| vend
!= vm1
)
6014 printf (_("Trailing view pair not used in a range"));
6017 *vstart_ptr
= vstart
;
6020 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6021 right-adjusted in a field of length LEN, and followed by a space. */
6024 print_addr_index (unsigned int idx
, unsigned int len
)
6026 static char buf
[15];
6027 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6028 printf ("%*s ", len
, buf
);
6031 /* Display a location list from a .dwo section. It uses address indexes rather
6032 than embedded addresses. This code closely follows display_loc_list, but the
6033 two are sufficiently different that combining things is very ugly. */
6036 display_loc_list_dwo (struct dwarf_section
*section
,
6037 unsigned char **start_ptr
,
6038 unsigned int debug_info_entry
,
6040 unsigned char **vstart_ptr
,
6043 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6044 unsigned char *section_end
= section
->start
+ section
->size
;
6045 unsigned long cu_offset
;
6046 unsigned int pointer_size
;
6047 unsigned int offset_size
;
6050 unsigned short length
;
6051 int need_frame_base
;
6054 if (debug_info_entry
>= num_debug_info_entries
)
6056 warn (_("No debug information for loc lists of entry: %u\n"),
6061 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6062 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6063 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6064 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6066 if (pointer_size
< 2 || pointer_size
> 8)
6068 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6069 pointer_size
, debug_info_entry
);
6075 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6077 if (start
>= section_end
)
6079 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6080 (unsigned long) offset
);
6084 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6097 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6099 READ_ULEB (view
, vstart
, section_end
);
6100 print_dwarf_view (view
, 8, 1);
6102 READ_ULEB (view
, vstart
, section_end
);
6103 print_dwarf_view (view
, 8, 1);
6105 printf (_("views at %8.8lx for:\n %*s "),
6106 (unsigned long) off
, 8, "");
6114 case 0: /* A terminating entry. */
6116 *vstart_ptr
= vstart
;
6117 printf (_("<End of list>\n"));
6119 case 1: /* A base-address entry. */
6120 READ_ULEB (idx
, start
, section_end
);
6121 print_addr_index (idx
, 8);
6122 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6123 printf (_("(base address selection entry)\n"));
6125 case 2: /* A start/end entry. */
6126 READ_ULEB (idx
, start
, section_end
);
6127 print_addr_index (idx
, 8);
6128 READ_ULEB (idx
, start
, section_end
);
6129 print_addr_index (idx
, 8);
6131 case 3: /* A start/length entry. */
6132 READ_ULEB (idx
, start
, section_end
);
6133 print_addr_index (idx
, 8);
6134 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6135 printf ("%08x ", idx
);
6137 case 4: /* An offset pair entry. */
6138 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6139 printf ("%08x ", idx
);
6140 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6141 printf ("%08x ", idx
);
6144 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6146 *vstart_ptr
= vstart
;
6150 if (start
+ 2 > section_end
)
6152 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6153 (unsigned long) offset
);
6157 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6158 if (start
+ length
> section_end
)
6160 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6161 (unsigned long) offset
);
6166 need_frame_base
= decode_location_expression (start
,
6171 cu_offset
, section
);
6174 if (need_frame_base
&& !has_frame_base
)
6175 printf (_(" [without DW_AT_frame_base]"));
6183 *vstart_ptr
= vstart
;
6186 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6189 static dwarf_vma
*loc_offsets
, *loc_views
;
6192 loc_offsets_compar (const void *ap
, const void *bp
)
6194 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6195 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6197 int ret
= (a
> b
) - (b
> a
);
6201 a
= loc_views
[*(const unsigned int *) ap
];
6202 b
= loc_views
[*(const unsigned int *) bp
];
6204 ret
= (a
> b
) - (b
> a
);
6210 display_debug_loc (struct dwarf_section
*section
, void *file
)
6212 unsigned char *start
= section
->start
, *vstart
= NULL
;
6213 unsigned long bytes
;
6214 unsigned char *section_begin
= start
;
6215 unsigned int num_loc_list
= 0;
6216 unsigned long last_offset
= 0;
6217 unsigned long last_view
= 0;
6218 unsigned int first
= 0;
6221 int seen_first_offset
= 0;
6222 int locs_sorted
= 1;
6223 unsigned char *next
= start
, *vnext
= vstart
;
6224 unsigned int *array
= NULL
;
6225 const char *suffix
= strrchr (section
->name
, '.');
6226 bfd_boolean is_dwo
= FALSE
;
6227 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6228 dwarf_vma expected_start
= 0;
6230 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6233 bytes
= section
->size
;
6237 printf (_("\nThe %s section is empty.\n"), section
->name
);
6243 unsigned char *hdrptr
= section_begin
;
6244 dwarf_vma ll_length
;
6245 unsigned short ll_version
;
6246 unsigned char *end
= section_begin
+ section
->size
;
6247 unsigned char address_size
, segment_selector_size
;
6248 uint32_t offset_entry_count
;
6250 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6251 if (ll_length
== 0xffffffff)
6252 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6254 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6255 if (ll_version
!= 5)
6257 warn (_("The %s section contains corrupt or "
6258 "unsupported version number: %d.\n"),
6259 section
->name
, ll_version
);
6263 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6265 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6266 if (segment_selector_size
!= 0)
6268 warn (_("The %s section contains "
6269 "unsupported segment selector size: %d.\n"),
6270 section
->name
, segment_selector_size
);
6274 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6275 if (offset_entry_count
!= 0)
6277 warn (_("The %s section contains "
6278 "unsupported offset entry count: %d.\n"),
6279 section
->name
, offset_entry_count
);
6283 expected_start
= hdrptr
- section_begin
;
6286 if (load_debug_info (file
) == 0)
6288 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6293 /* Check the order of location list in .debug_info section. If
6294 offsets of location lists are in the ascending order, we can
6295 use `debug_information' directly. */
6296 for (i
= 0; i
< num_debug_info_entries
; i
++)
6300 num
= debug_information
[i
].num_loc_offsets
;
6301 if (num
> num_loc_list
)
6304 /* Check if we can use `debug_information' directly. */
6305 if (locs_sorted
&& num
!= 0)
6307 if (!seen_first_offset
)
6309 /* This is the first location list. */
6310 last_offset
= debug_information
[i
].loc_offsets
[0];
6311 last_view
= debug_information
[i
].loc_views
[0];
6313 seen_first_offset
= 1;
6319 for (; j
< num
; j
++)
6322 debug_information
[i
].loc_offsets
[j
]
6323 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6324 && last_view
> debug_information
[i
].loc_views
[j
]))
6329 last_offset
= debug_information
[i
].loc_offsets
[j
];
6330 last_view
= debug_information
[i
].loc_views
[j
];
6335 if (!seen_first_offset
)
6336 error (_("No location lists in .debug_info section!\n"));
6338 if (debug_information
[first
].num_loc_offsets
> 0
6339 && debug_information
[first
].loc_offsets
[0] != expected_start
6340 && debug_information
[first
].loc_views
[0] != expected_start
)
6341 warn (_("Location lists in %s section start at 0x%s\n"),
6343 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6346 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6348 introduce (section
, FALSE
);
6350 if (reloc_at (section
, 0))
6351 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6353 printf (_(" Offset Begin End Expression\n"));
6355 seen_first_offset
= 0;
6356 for (i
= first
; i
< num_debug_info_entries
; i
++)
6358 dwarf_vma offset
, voffset
;
6359 dwarf_vma base_address
;
6365 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6367 loc_offsets
= debug_information
[i
].loc_offsets
;
6368 loc_views
= debug_information
[i
].loc_views
;
6369 qsort (array
, debug_information
[i
].num_loc_offsets
,
6370 sizeof (*array
), loc_offsets_compar
);
6373 int adjacent_view_loclists
= 1;
6374 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6376 j
= locs_sorted
? k
: array
[k
];
6378 && (debug_information
[i
].loc_offsets
[locs_sorted
6379 ? k
- 1 : array
[k
- 1]]
6380 == debug_information
[i
].loc_offsets
[j
])
6381 && (debug_information
[i
].loc_views
[locs_sorted
6382 ? k
- 1 : array
[k
- 1]]
6383 == debug_information
[i
].loc_views
[j
]))
6385 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6386 offset
= debug_information
[i
].loc_offsets
[j
];
6387 next
= section_begin
+ offset
;
6388 voffset
= debug_information
[i
].loc_views
[j
];
6390 vnext
= section_begin
+ voffset
;
6393 base_address
= debug_information
[i
].base_address
;
6395 if (vnext
&& vnext
< next
)
6398 display_view_pair_list (section
, &vstart
, i
, next
);
6403 if (!seen_first_offset
|| !adjacent_view_loclists
)
6404 seen_first_offset
= 1;
6408 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6409 (unsigned long) (start
- section_begin
),
6410 (unsigned long) offset
);
6411 else if (start
> next
)
6412 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6413 (unsigned long) (start
- section_begin
),
6414 (unsigned long) offset
);
6419 if (offset
>= bytes
)
6421 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6422 (unsigned long) offset
);
6426 if (vnext
&& voffset
>= bytes
)
6428 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6429 (unsigned long) voffset
);
6436 display_loc_list_dwo (section
, &start
, i
, offset
,
6437 &vstart
, has_frame_base
);
6439 display_loc_list (section
, &start
, i
, offset
, base_address
,
6440 &vstart
, has_frame_base
);
6445 warn (_("DWO is not yet supported.\n"));
6447 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6448 &vstart
, has_frame_base
);
6451 /* FIXME: this arrangement is quite simplistic. Nothing
6452 requires locview lists to be adjacent to corresponding
6453 loclists, and a single loclist could be augmented by
6454 different locview lists, and vice-versa, unlikely as it
6455 is that it would make sense to do so. Hopefully we'll
6456 have view pair support built into loclists before we ever
6457 need to address all these possibilities. */
6458 if (adjacent_view_loclists
&& vnext
6459 && vnext
!= start
&& vstart
!= next
)
6461 adjacent_view_loclists
= 0;
6462 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6465 if (vnext
&& vnext
== start
)
6466 display_view_pair_list (section
, &start
, i
, vstart
);
6470 if (start
< section
->start
+ section
->size
)
6471 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6472 "There are %ld unused bytes at the end of section %s\n",
6473 (long) (section
->start
+ section
->size
- start
)),
6474 (long) (section
->start
+ section
->size
- start
), section
->name
);
6481 display_debug_str (struct dwarf_section
*section
,
6482 void *file ATTRIBUTE_UNUSED
)
6484 unsigned char *start
= section
->start
;
6485 unsigned long bytes
= section
->size
;
6486 dwarf_vma addr
= section
->address
;
6490 printf (_("\nThe %s section is empty.\n"), section
->name
);
6494 introduce (section
, FALSE
);
6502 lbytes
= (bytes
> 16 ? 16 : bytes
);
6504 printf (" 0x%8.8lx ", (unsigned long) addr
);
6506 for (j
= 0; j
< 16; j
++)
6509 printf ("%2.2x", start
[j
]);
6517 for (j
= 0; j
< lbytes
; j
++)
6520 if (k
>= ' ' && k
< 0x80)
6539 display_debug_info (struct dwarf_section
*section
, void *file
)
6541 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6545 display_debug_types (struct dwarf_section
*section
, void *file
)
6547 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6551 display_trace_info (struct dwarf_section
*section
, void *file
)
6553 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6557 display_debug_aranges (struct dwarf_section
*section
,
6558 void *file ATTRIBUTE_UNUSED
)
6560 unsigned char *start
= section
->start
;
6561 unsigned char *end
= start
+ section
->size
;
6563 introduce (section
, FALSE
);
6565 /* It does not matter if this load fails,
6566 we test for that later on. */
6567 load_debug_info (file
);
6571 unsigned char *hdrptr
;
6572 DWARF2_Internal_ARange arange
;
6573 unsigned char *addr_ranges
;
6576 unsigned long sec_off
;
6577 unsigned char address_size
;
6579 unsigned int offset_size
;
6580 unsigned int initial_length_size
;
6584 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6585 if (arange
.ar_length
== 0xffffffff)
6587 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6589 initial_length_size
= 12;
6594 initial_length_size
= 4;
6597 sec_off
= hdrptr
- section
->start
;
6598 if (sec_off
+ arange
.ar_length
< sec_off
6599 || sec_off
+ arange
.ar_length
> section
->size
)
6601 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6603 sec_off
- initial_length_size
,
6604 dwarf_vmatoa ("x", arange
.ar_length
));
6608 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6609 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6611 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6612 && num_debug_info_entries
> 0
6613 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6614 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6615 (unsigned long) arange
.ar_info_offset
, section
->name
);
6617 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6618 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6620 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6622 /* PR 19872: A version number of 0 probably means that there is
6623 padding at the end of the .debug_aranges section. Gold puts
6624 it there when performing an incremental link, for example.
6625 So do not generate a warning in this case. */
6626 if (arange
.ar_version
)
6627 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6631 printf (_(" Length: %ld\n"),
6632 (long) arange
.ar_length
);
6633 printf (_(" Version: %d\n"), arange
.ar_version
);
6634 printf (_(" Offset into .debug_info: 0x%lx\n"),
6635 (unsigned long) arange
.ar_info_offset
);
6636 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6637 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6639 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6641 /* PR 17512: file: 001-108546-0.001:0.1. */
6642 if (address_size
== 0 || address_size
> 8)
6644 error (_("Invalid address size in %s section!\n"),
6649 /* The DWARF spec does not require that the address size be a power
6650 of two, but we do. This will have to change if we ever encounter
6651 an uneven architecture. */
6652 if ((address_size
& (address_size
- 1)) != 0)
6654 warn (_("Pointer size + Segment size is not a power of two.\n"));
6658 if (address_size
> 4)
6659 printf (_("\n Address Length\n"));
6661 printf (_("\n Address Length\n"));
6663 addr_ranges
= hdrptr
;
6665 /* Must pad to an alignment boundary that is twice the address size. */
6666 excess
= (hdrptr
- start
) % (2 * address_size
);
6668 addr_ranges
+= (2 * address_size
) - excess
;
6670 start
+= arange
.ar_length
+ initial_length_size
;
6672 while (addr_ranges
+ 2 * address_size
<= start
)
6674 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6675 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6678 print_dwarf_vma (address
, address_size
);
6679 print_dwarf_vma (length
, address_size
);
6689 /* Comparison function for qsort. */
6691 comp_addr_base (const void * v0
, const void * v1
)
6693 debug_info
*info0
= *(debug_info
**) v0
;
6694 debug_info
*info1
= *(debug_info
**) v1
;
6695 return info0
->addr_base
- info1
->addr_base
;
6698 /* Display the debug_addr section. */
6700 display_debug_addr (struct dwarf_section
*section
,
6703 debug_info
**debug_addr_info
;
6704 unsigned char *entry
;
6709 if (section
->size
== 0)
6711 printf (_("\nThe %s section is empty.\n"), section
->name
);
6715 if (load_debug_info (file
) == 0)
6717 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6722 introduce (section
, FALSE
);
6724 /* PR 17531: file: cf38d01b.
6725 We use xcalloc because a corrupt file may not have initialised all of the
6726 fields in the debug_info structure, which means that the sort below might
6727 try to move uninitialised data. */
6728 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6729 sizeof (debug_info
*));
6732 for (i
= 0; i
< num_debug_info_entries
; i
++)
6733 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6735 /* PR 17531: file: cf38d01b. */
6736 if (debug_information
[i
].addr_base
>= section
->size
)
6737 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6738 (unsigned long) debug_information
[i
].addr_base
, i
);
6740 debug_addr_info
[count
++] = debug_information
+ i
;
6743 /* Add a sentinel to make iteration convenient. */
6744 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6745 debug_addr_info
[count
]->addr_base
= section
->size
;
6746 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6748 for (i
= 0; i
< count
; i
++)
6751 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6753 printf (_(" For compilation unit at offset 0x%s:\n"),
6754 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6756 printf (_("\tIndex\tAddress\n"));
6757 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6758 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6762 dwarf_vma base
= byte_get (entry
, address_size
);
6763 printf (_("\t%d:\t"), idx
);
6764 print_dwarf_vma (base
, address_size
);
6766 entry
+= address_size
;
6772 free (debug_addr_info
);
6776 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6779 display_debug_str_offsets (struct dwarf_section
*section
,
6780 void *file ATTRIBUTE_UNUSED
)
6782 if (section
->size
== 0)
6784 printf (_("\nThe %s section is empty.\n"), section
->name
);
6787 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6788 what the offset size is for this section. */
6792 /* Each debug_information[x].range_lists[y] gets this representation for
6793 sorting purposes. */
6797 /* The debug_information[x].range_lists[y] value. */
6798 dwarf_vma ranges_offset
;
6800 /* Original debug_information to find parameters of the data. */
6801 debug_info
*debug_info_p
;
6804 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6807 range_entry_compar (const void *ap
, const void *bp
)
6809 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6810 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6811 const dwarf_vma a
= a_re
->ranges_offset
;
6812 const dwarf_vma b
= b_re
->ranges_offset
;
6814 return (a
> b
) - (b
> a
);
6818 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6819 unsigned int pointer_size
, unsigned long offset
,
6820 unsigned long base_address
)
6822 while (start
< finish
)
6827 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6828 if (start
>= finish
)
6830 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6833 printf (" %8.8lx ", offset
);
6835 if (begin
== 0 && end
== 0)
6837 printf (_("<End of list>\n"));
6841 /* Check base address specifiers. */
6842 if (is_max_address (begin
, pointer_size
)
6843 && !is_max_address (end
, pointer_size
))
6846 print_dwarf_vma (begin
, pointer_size
);
6847 print_dwarf_vma (end
, pointer_size
);
6848 printf ("(base address)\n");
6852 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6853 print_dwarf_vma (end
+ base_address
, pointer_size
);
6856 fputs (_("(start == end)"), stdout
);
6857 else if (begin
> end
)
6858 fputs (_("(start > end)"), stdout
);
6865 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6866 unsigned int pointer_size
, unsigned long offset
,
6867 unsigned long base_address
)
6869 unsigned char *next
= start
;
6873 unsigned long off
= offset
+ (start
- next
);
6874 enum dwarf_range_list_entry rlet
;
6875 /* Initialize it due to a false compiler warning. */
6876 dwarf_vma begin
= -1, length
, end
= -1;
6878 if (start
+ 1 > finish
)
6880 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6885 printf (" %8.8lx ", off
);
6887 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6891 case DW_RLE_end_of_list
:
6892 printf (_("<End of list>\n"));
6894 case DW_RLE_base_address
:
6895 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6896 print_dwarf_vma (base_address
, pointer_size
);
6897 printf (_("(base address)\n"));
6899 case DW_RLE_start_length
:
6900 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6901 READ_ULEB (length
, start
, finish
);
6902 end
= begin
+ length
;
6904 case DW_RLE_offset_pair
:
6905 READ_ULEB (begin
, start
, finish
);
6906 READ_ULEB (end
, start
, finish
);
6908 case DW_RLE_start_end
:
6909 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6910 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6913 error (_("Invalid range list entry type %d\n"), rlet
);
6914 rlet
= DW_RLE_end_of_list
;
6917 if (rlet
== DW_RLE_end_of_list
)
6919 if (rlet
== DW_RLE_base_address
)
6922 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6923 print_dwarf_vma (end
+ base_address
, pointer_size
);
6926 fputs (_("(start == end)"), stdout
);
6927 else if (begin
> end
)
6928 fputs (_("(start > end)"), stdout
);
6935 display_debug_ranges (struct dwarf_section
*section
,
6936 void *file ATTRIBUTE_UNUSED
)
6938 unsigned char *start
= section
->start
;
6939 unsigned char *last_start
= start
;
6940 unsigned long bytes
= section
->size
;
6941 unsigned char *section_begin
= start
;
6942 unsigned char *finish
= start
+ bytes
;
6943 unsigned int num_range_list
, i
;
6944 struct range_entry
*range_entries
, *range_entry_fill
;
6945 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6946 /* Initialize it due to a false compiler warning. */
6947 unsigned char address_size
= 0;
6948 dwarf_vma last_offset
= 0;
6952 printf (_("\nThe %s section is empty.\n"), section
->name
);
6958 dwarf_vma initial_length
;
6959 unsigned int initial_length_size
;
6960 unsigned char segment_selector_size
;
6961 unsigned int offset_size
, offset_entry_count
;
6962 unsigned short version
;
6964 /* Get and check the length of the block. */
6965 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6967 if (initial_length
== 0xffffffff)
6969 /* This section is 64-bit DWARF 3. */
6970 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6972 initial_length_size
= 12;
6977 initial_length_size
= 4;
6980 if (initial_length
+ initial_length_size
> section
->size
)
6982 /* If the length field has a relocation against it, then we should
6983 not complain if it is inaccurate (and probably negative).
6984 It is copied from .debug_line handling code. */
6985 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6987 initial_length
= (finish
- start
) - initial_length_size
;
6991 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6992 (long) initial_length
);
6997 /* Get and check the version number. */
6998 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7002 warn (_("Only DWARF version 5 debug_rnglists info "
7003 "is currently supported.\n"));
7007 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7009 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7010 if (segment_selector_size
!= 0)
7012 warn (_("The %s section contains "
7013 "unsupported segment selector size: %d.\n"),
7014 section
->name
, segment_selector_size
);
7018 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7019 if (offset_entry_count
!= 0)
7021 warn (_("The %s section contains "
7022 "unsupported offset entry count: %u.\n"),
7023 section
->name
, offset_entry_count
);
7028 if (load_debug_info (file
) == 0)
7030 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7036 for (i
= 0; i
< num_debug_info_entries
; i
++)
7037 num_range_list
+= debug_information
[i
].num_range_lists
;
7039 if (num_range_list
== 0)
7041 /* This can happen when the file was compiled with -gsplit-debug
7042 which removes references to range lists from the primary .o file. */
7043 printf (_("No range lists in .debug_info section.\n"));
7047 range_entries
= (struct range_entry
*)
7048 xmalloc (sizeof (*range_entries
) * num_range_list
);
7049 range_entry_fill
= range_entries
;
7051 for (i
= 0; i
< num_debug_info_entries
; i
++)
7053 debug_info
*debug_info_p
= &debug_information
[i
];
7056 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7058 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7059 range_entry_fill
->debug_info_p
= debug_info_p
;
7064 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7065 range_entry_compar
);
7067 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7068 warn (_("Range lists in %s section start at 0x%lx\n"),
7069 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7071 introduce (section
, FALSE
);
7073 printf (_(" Offset Begin End\n"));
7075 for (i
= 0; i
< num_range_list
; i
++)
7077 struct range_entry
*range_entry
= &range_entries
[i
];
7078 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7079 unsigned int pointer_size
;
7081 unsigned char *next
;
7082 dwarf_vma base_address
;
7084 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7085 offset
= range_entry
->ranges_offset
;
7086 next
= section_begin
+ offset
;
7087 base_address
= debug_info_p
->base_address
;
7089 /* PR 17512: file: 001-101485-0.001:0.1. */
7090 if (pointer_size
< 2 || pointer_size
> 8)
7092 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7093 pointer_size
, (unsigned long) offset
);
7097 if (next
< section_begin
|| next
>= finish
)
7099 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7100 (unsigned long) offset
, i
);
7104 /* If multiple DWARF entities reference the same range then we will
7105 have multiple entries in the `range_entries' list for the same
7106 offset. Thanks to the sort above these will all be consecutive in
7107 the `range_entries' list, so we can easily ignore duplicates
7109 if (i
> 0 && last_offset
== offset
)
7111 last_offset
= offset
;
7113 if (dwarf_check
!= 0 && i
> 0)
7116 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7117 (unsigned long) (start
- section_begin
),
7118 (unsigned long) (next
- section_begin
), section
->name
);
7119 else if (start
> next
)
7121 if (next
== last_start
)
7123 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7124 (unsigned long) (start
- section_begin
),
7125 (unsigned long) (next
- section_begin
), section
->name
);
7132 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7133 (start
, finish
, pointer_size
, offset
, base_address
);
7137 free (range_entries
);
7142 typedef struct Frame_Chunk
7144 struct Frame_Chunk
*next
;
7145 unsigned char *chunk_start
;
7147 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7148 short int *col_type
;
7151 unsigned int code_factor
;
7155 unsigned int cfa_reg
;
7156 dwarf_vma cfa_offset
;
7158 unsigned char fde_encoding
;
7159 unsigned char cfa_exp
;
7160 unsigned char ptr_size
;
7161 unsigned char segment_size
;
7165 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7166 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7167 static const char *const *dwarf_regnames
;
7168 static unsigned int dwarf_regnames_count
;
7171 /* A marker for a col_type that means this column was never referenced
7172 in the frame info. */
7173 #define DW_CFA_unreferenced (-1)
7175 /* Return 0 if no more space is needed, 1 if more space is needed,
7176 -1 for invalid reg. */
7179 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7181 unsigned int prev
= fc
->ncols
;
7183 if (reg
< (unsigned int) fc
->ncols
)
7186 if (dwarf_regnames_count
> 0
7187 && reg
> dwarf_regnames_count
)
7190 fc
->ncols
= reg
+ 1;
7191 /* PR 17512: file: 10450-2643-0.004.
7192 If reg == -1 then this can happen... */
7196 /* PR 17512: file: 2844a11d. */
7197 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7199 error (_("Unfeasibly large register number: %u\n"), reg
);
7201 /* FIXME: 1024 is an arbitrary limit. Increase it if
7202 we ever encounter a valid binary that exceeds it. */
7206 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7207 sizeof (short int));
7208 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7209 /* PR 17512: file:002-10025-0.005. */
7210 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7212 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7218 while (prev
< fc
->ncols
)
7220 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7221 fc
->col_offset
[prev
] = 0;
7227 static const char *const dwarf_regnames_i386
[] =
7229 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7230 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7231 "eip", "eflags", NULL
, /* 8 - 10 */
7232 "st0", "st1", "st2", "st3", /* 11 - 14 */
7233 "st4", "st5", "st6", "st7", /* 15 - 18 */
7234 NULL
, NULL
, /* 19 - 20 */
7235 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7236 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7237 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7238 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7239 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7240 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7241 "tr", "ldtr", /* 48 - 49 */
7242 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7243 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7244 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7245 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7246 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7247 NULL
, NULL
, NULL
, /* 90 - 92 */
7248 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7251 static const char *const dwarf_regnames_iamcu
[] =
7253 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7254 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7255 "eip", "eflags", NULL
, /* 8 - 10 */
7256 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7257 NULL
, NULL
, /* 19 - 20 */
7258 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7259 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7260 NULL
, NULL
, NULL
, /* 37 - 39 */
7261 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7262 "tr", "ldtr", /* 48 - 49 */
7263 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7264 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7265 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7266 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7267 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7268 NULL
, NULL
, NULL
, /* 90 - 92 */
7269 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7273 init_dwarf_regnames_i386 (void)
7275 dwarf_regnames
= dwarf_regnames_i386
;
7276 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7277 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7281 init_dwarf_regnames_iamcu (void)
7283 dwarf_regnames
= dwarf_regnames_iamcu
;
7284 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7285 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7288 static const char *const dwarf_regnames_x86_64
[] =
7290 "rax", "rdx", "rcx", "rbx",
7291 "rsi", "rdi", "rbp", "rsp",
7292 "r8", "r9", "r10", "r11",
7293 "r12", "r13", "r14", "r15",
7295 "xmm0", "xmm1", "xmm2", "xmm3",
7296 "xmm4", "xmm5", "xmm6", "xmm7",
7297 "xmm8", "xmm9", "xmm10", "xmm11",
7298 "xmm12", "xmm13", "xmm14", "xmm15",
7299 "st0", "st1", "st2", "st3",
7300 "st4", "st5", "st6", "st7",
7301 "mm0", "mm1", "mm2", "mm3",
7302 "mm4", "mm5", "mm6", "mm7",
7304 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7305 "fs.base", "gs.base", NULL
, NULL
,
7307 "mxcsr", "fcw", "fsw",
7308 "xmm16", "xmm17", "xmm18", "xmm19",
7309 "xmm20", "xmm21", "xmm22", "xmm23",
7310 "xmm24", "xmm25", "xmm26", "xmm27",
7311 "xmm28", "xmm29", "xmm30", "xmm31",
7312 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7313 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7314 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7315 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7316 NULL
, NULL
, NULL
, /* 115 - 117 */
7317 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7321 init_dwarf_regnames_x86_64 (void)
7323 dwarf_regnames
= dwarf_regnames_x86_64
;
7324 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7325 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7328 static const char *const dwarf_regnames_aarch64
[] =
7330 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7331 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7332 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7333 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7334 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7335 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7336 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7337 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7338 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7339 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7340 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7341 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7342 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7343 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7344 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7345 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7349 init_dwarf_regnames_aarch64 (void)
7351 dwarf_regnames
= dwarf_regnames_aarch64
;
7352 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7353 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7356 static const char *const dwarf_regnames_s390
[] =
7358 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7359 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7360 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7361 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7362 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7363 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7364 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7365 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7366 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7369 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7370 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7374 init_dwarf_regnames_s390 (void)
7376 dwarf_regnames
= dwarf_regnames_s390
;
7377 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7378 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7381 static const char *const dwarf_regnames_riscv
[] =
7383 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7384 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7385 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7386 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7387 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7388 "fs0", "fs1", /* 40 - 41 */
7389 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7390 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7391 "fs10", "fs11", /* 58 - 59 */
7392 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7395 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7396 the large number of CSRs. */
7399 regname_internal_riscv (unsigned int regno
)
7401 const char *name
= NULL
;
7403 /* Lookup in the table first, this covers GPR and FPR. */
7404 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7405 name
= dwarf_regnames_riscv
[regno
];
7406 else if (regno
>= 4096 && regno
<= 8191)
7408 /* This might be a CSR, these live in a sparse number space from 4096
7409 to 8191 These numbers are defined in the RISC-V ELF ABI
7413 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
7414 case VALUE + 4096: name = #NAME; break;
7415 #include "opcode/riscv-opc.h"
7420 static char csr_name
[10];
7421 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7432 init_dwarf_regnames_riscv (void)
7434 dwarf_regnames
= NULL
;
7435 dwarf_regnames_count
= 8192;
7436 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7440 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7442 dwarf_regnames_lookup_func
= NULL
;
7447 init_dwarf_regnames_i386 ();
7451 init_dwarf_regnames_iamcu ();
7457 init_dwarf_regnames_x86_64 ();
7461 init_dwarf_regnames_aarch64 ();
7465 init_dwarf_regnames_s390 ();
7469 init_dwarf_regnames_riscv ();
7477 /* Initialize the DWARF register name lookup state based on the
7478 architecture and specific machine type of a BFD. */
7481 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7484 dwarf_regnames_lookup_func
= NULL
;
7491 case bfd_mach_x86_64
:
7492 case bfd_mach_x86_64_intel_syntax
:
7493 case bfd_mach_x86_64_nacl
:
7494 case bfd_mach_x64_32
:
7495 case bfd_mach_x64_32_intel_syntax
:
7496 case bfd_mach_x64_32_nacl
:
7497 init_dwarf_regnames_x86_64 ();
7501 init_dwarf_regnames_i386 ();
7506 case bfd_arch_iamcu
:
7507 init_dwarf_regnames_iamcu ();
7510 case bfd_arch_aarch64
:
7511 init_dwarf_regnames_aarch64();
7515 init_dwarf_regnames_s390 ();
7518 case bfd_arch_riscv
:
7519 init_dwarf_regnames_riscv ();
7528 regname_internal_by_table_only (unsigned int regno
)
7530 if (dwarf_regnames
!= NULL
7531 && regno
< dwarf_regnames_count
7532 && dwarf_regnames
[regno
] != NULL
)
7533 return dwarf_regnames
[regno
];
7539 regname (unsigned int regno
, int name_only_p
)
7541 static char reg
[64];
7543 const char *name
= NULL
;
7545 if (dwarf_regnames_lookup_func
!= NULL
)
7546 name
= dwarf_regnames_lookup_func (regno
);
7552 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7555 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7560 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7565 if (*max_regs
!= fc
->ncols
)
7566 *max_regs
= fc
->ncols
;
7568 if (*need_col_headers
)
7570 static const char *sloc
= " LOC";
7572 *need_col_headers
= 0;
7574 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7576 for (r
= 0; r
< *max_regs
; r
++)
7577 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7582 printf ("%-5s ", regname (r
, 1));
7588 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7590 strcpy (tmp
, "exp");
7592 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7593 printf ("%-8s ", tmp
);
7595 for (r
= 0; r
< fc
->ncols
; r
++)
7597 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7599 switch (fc
->col_type
[r
])
7601 case DW_CFA_undefined
:
7604 case DW_CFA_same_value
:
7608 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7610 case DW_CFA_val_offset
:
7611 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7613 case DW_CFA_register
:
7614 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7616 case DW_CFA_expression
:
7617 strcpy (tmp
, "exp");
7619 case DW_CFA_val_expression
:
7620 strcpy (tmp
, "vexp");
7623 strcpy (tmp
, "n/a");
7626 printf ("%-5s ", tmp
);
7632 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7634 static unsigned char *
7635 read_cie (unsigned char *start
, unsigned char *end
,
7636 Frame_Chunk
**p_cie
, int *p_version
,
7637 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7641 unsigned char *augmentation_data
= NULL
;
7642 bfd_size_type augmentation_data_len
= 0;
7645 /* PR 17512: file: 001-228113-0.004. */
7649 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7650 memset (fc
, 0, sizeof (Frame_Chunk
));
7652 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7653 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7657 fc
->augmentation
= (char *) start
;
7658 /* PR 17512: file: 001-228113-0.004.
7659 Skip past augmentation name, but avoid running off the end of the data. */
7661 if (* start
++ == '\0')
7665 warn (_("No terminator for augmentation name\n"));
7669 if (strcmp (fc
->augmentation
, "eh") == 0)
7670 start
+= eh_addr_size
;
7674 GET (fc
->ptr_size
, 1);
7675 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7677 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7681 GET (fc
->segment_size
, 1);
7682 /* PR 17512: file: e99d2804. */
7683 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7685 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7689 eh_addr_size
= fc
->ptr_size
;
7693 fc
->ptr_size
= eh_addr_size
;
7694 fc
->segment_size
= 0;
7697 READ_ULEB (fc
->code_factor
, start
, end
);
7698 READ_SLEB (fc
->data_factor
, start
, end
);
7706 READ_ULEB (fc
->ra
, start
, end
);
7709 if (fc
->augmentation
[0] == 'z')
7711 READ_ULEB (augmentation_data_len
, start
, end
);
7712 augmentation_data
= start
;
7713 /* PR 17512: file: 11042-2589-0.004. */
7714 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7716 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7717 dwarf_vmatoa ("x", augmentation_data_len
),
7718 (unsigned long) (end
- start
));
7721 start
+= augmentation_data_len
;
7724 if (augmentation_data_len
)
7728 unsigned char *qend
;
7730 p
= (unsigned char *) fc
->augmentation
+ 1;
7731 q
= augmentation_data
;
7732 qend
= q
+ augmentation_data_len
;
7734 while (p
< end
&& q
< qend
)
7739 q
+= 1 + size_of_encoded_value (*q
);
7741 fc
->fde_encoding
= *q
++;
7750 /* Note - it is OK if this loop terminates with q < qend.
7751 Padding may have been inserted to align the end of the CIE. */
7756 *p_version
= version
;
7759 *p_aug_len
= augmentation_data_len
;
7760 *p_aug
= augmentation_data
;
7765 free (fc
->col_offset
);
7766 free (fc
->col_type
);
7771 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7772 If do_wide is not enabled, then formats the output to fit into 80 columns.
7773 PRINTED contains the number of characters already written to the current
7777 display_data (bfd_size_type printed
,
7778 const unsigned char * data
,
7779 const bfd_size_type len
)
7781 if (do_wide
|| len
< ((80 - printed
) / 3))
7782 for (printed
= 0; printed
< len
; ++printed
)
7783 printf (" %02x", data
[printed
]);
7786 for (printed
= 0; printed
< len
; ++printed
)
7788 if (printed
% (80 / 3) == 0)
7790 printf (" %02x", data
[printed
]);
7795 /* Prints out the contents on the augmentation data array.
7796 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7799 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7803 i
= printf (_(" Augmentation data: "));
7804 display_data (i
, data
, len
);
7808 display_debug_frames (struct dwarf_section
*section
,
7809 void *file ATTRIBUTE_UNUSED
)
7811 unsigned char *start
= section
->start
;
7812 unsigned char *end
= start
+ section
->size
;
7813 unsigned char *section_start
= start
;
7814 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7815 Frame_Chunk
*remembered_state
= NULL
;
7817 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7818 unsigned int max_regs
= 0;
7819 const char *bad_reg
= _("bad register: ");
7820 unsigned int saved_eh_addr_size
= eh_addr_size
;
7822 introduce (section
, FALSE
);
7826 unsigned char *saved_start
;
7827 unsigned char *block_end
;
7832 int need_col_headers
= 1;
7833 unsigned char *augmentation_data
= NULL
;
7834 bfd_size_type augmentation_data_len
= 0;
7835 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7836 unsigned int offset_size
;
7837 unsigned int initial_length_size
;
7838 bfd_boolean all_nops
;
7839 static Frame_Chunk fde_fc
;
7841 saved_start
= start
;
7843 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7847 printf ("\n%08lx ZERO terminator\n\n",
7848 (unsigned long)(saved_start
- section_start
));
7849 /* Skip any zero terminators that directly follow.
7850 A corrupt section size could have loaded a whole
7851 slew of zero filled memory bytes. eg
7852 PR 17512: file: 070-19381-0.004. */
7853 while (start
< end
&& * start
== 0)
7858 if (length
== 0xffffffff)
7860 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7862 initial_length_size
= 12;
7867 initial_length_size
= 4;
7870 block_end
= saved_start
+ length
+ initial_length_size
;
7871 if (block_end
> end
|| block_end
< start
)
7873 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7874 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7875 (unsigned long) (saved_start
- section_start
));
7879 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7881 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7882 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7887 start
= read_cie (start
, end
, &cie
, &version
,
7888 &augmentation_data_len
, &augmentation_data
);
7889 /* PR 17512: file: 027-135133-0.005. */
7896 fc
->chunk_start
= saved_start
;
7897 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7900 if (frame_need_space (fc
, mreg
) < 0)
7902 if (fc
->fde_encoding
)
7903 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7905 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7906 print_dwarf_vma (length
, fc
->ptr_size
);
7907 print_dwarf_vma (cie_id
, offset_size
);
7909 if (do_debug_frames_interp
)
7911 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7912 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7917 printf (" Version: %d\n", version
);
7918 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7921 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7922 printf (" Segment Size: %u\n", fc
->segment_size
);
7924 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7925 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7926 printf (" Return address column: %d\n", fc
->ra
);
7928 if (augmentation_data_len
)
7929 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7936 unsigned char *look_for
;
7937 unsigned long segment_selector
;
7941 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7942 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7945 look_for
= section_start
+ cie_id
;
7947 if (look_for
<= saved_start
)
7949 for (cie
= chunks
; cie
; cie
= cie
->next
)
7950 if (cie
->chunk_start
== look_for
)
7955 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7956 if (cie
->chunk_start
== look_for
)
7960 unsigned int off_size
;
7961 unsigned char *cie_scan
;
7963 cie_scan
= look_for
;
7965 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7966 if (length
== 0xffffffff)
7968 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7975 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7978 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7979 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7984 read_cie (cie_scan
, end
, &cie
, &version
,
7985 &augmentation_data_len
, &augmentation_data
);
7986 /* PR 17512: file: 3450-2098-0.004. */
7989 warn (_("Failed to read CIE information\n"));
7992 cie
->next
= forward_refs
;
7994 cie
->chunk_start
= look_for
;
7995 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7998 if (frame_need_space (cie
, mreg
) < 0)
8000 warn (_("Invalid max register\n"));
8003 if (cie
->fde_encoding
)
8005 = size_of_encoded_value (cie
->fde_encoding
);
8012 memset (fc
, 0, sizeof (Frame_Chunk
));
8016 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8017 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8018 (unsigned long) (saved_start
- section_start
));
8020 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8021 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8022 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8024 warn (_("Invalid max register\n"));
8028 fc
->augmentation
= "";
8029 fc
->fde_encoding
= 0;
8030 fc
->ptr_size
= eh_addr_size
;
8031 fc
->segment_size
= 0;
8035 fc
->ncols
= cie
->ncols
;
8036 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8037 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8038 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8039 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8040 fc
->augmentation
= cie
->augmentation
;
8041 fc
->ptr_size
= cie
->ptr_size
;
8042 eh_addr_size
= cie
->ptr_size
;
8043 fc
->segment_size
= cie
->segment_size
;
8044 fc
->code_factor
= cie
->code_factor
;
8045 fc
->data_factor
= cie
->data_factor
;
8046 fc
->cfa_reg
= cie
->cfa_reg
;
8047 fc
->cfa_offset
= cie
->cfa_offset
;
8049 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8051 warn (_("Invalid max register\n"));
8054 fc
->fde_encoding
= cie
->fde_encoding
;
8057 if (fc
->fde_encoding
)
8058 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8060 segment_selector
= 0;
8061 if (fc
->segment_size
)
8063 if (fc
->segment_size
> sizeof (segment_selector
))
8065 /* PR 17512: file: 9e196b3e. */
8066 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8067 fc
->segment_size
= 4;
8069 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8072 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8074 /* FIXME: It appears that sometimes the final pc_range value is
8075 encoded in less than encoded_ptr_size bytes. See the x86_64
8076 run of the "objcopy on compressed debug sections" test for an
8078 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8080 if (cie
->augmentation
[0] == 'z')
8082 READ_ULEB (augmentation_data_len
, start
, end
);
8083 augmentation_data
= start
;
8084 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8085 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8087 warn (_("Augmentation data too long: 0x%s, "
8088 "expected at most %#lx\n"),
8089 dwarf_vmatoa ("x", augmentation_data_len
),
8090 (unsigned long) (end
- start
));
8092 augmentation_data
= NULL
;
8093 augmentation_data_len
= 0;
8095 start
+= augmentation_data_len
;
8098 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8099 (unsigned long)(saved_start
- section_start
),
8100 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8101 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8102 (unsigned long)(cie
->chunk_start
- section_start
));
8104 if (fc
->segment_size
)
8105 printf ("%04lx:", segment_selector
);
8108 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8109 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8111 if (! do_debug_frames_interp
&& augmentation_data_len
)
8113 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8118 /* At this point, fc is the current chunk, cie (if any) is set, and
8119 we're about to interpret instructions for the chunk. */
8120 /* ??? At present we need to do this always, since this sizes the
8121 fc->col_type and fc->col_offset arrays, which we write into always.
8122 We should probably split the interpreted and non-interpreted bits
8123 into two different routines, since there's so much that doesn't
8124 really overlap between them. */
8125 if (1 || do_debug_frames_interp
)
8127 /* Start by making a pass over the chunk, allocating storage
8128 and taking note of what registers are used. */
8129 unsigned char *tmp
= start
;
8131 while (start
< block_end
)
8133 unsigned int reg
, op
, opa
;
8135 unsigned char * new_start
;
8142 /* Warning: if you add any more cases to this switch, be
8143 sure to add them to the corresponding switch below. */
8146 case DW_CFA_advance_loc
:
8149 SKIP_ULEB (start
, end
);
8150 if (frame_need_space (fc
, opa
) >= 0)
8151 fc
->col_type
[opa
] = DW_CFA_undefined
;
8153 case DW_CFA_restore
:
8154 if (frame_need_space (fc
, opa
) >= 0)
8155 fc
->col_type
[opa
] = DW_CFA_undefined
;
8157 case DW_CFA_set_loc
:
8158 start
+= encoded_ptr_size
;
8160 case DW_CFA_advance_loc1
:
8163 case DW_CFA_advance_loc2
:
8166 case DW_CFA_advance_loc4
:
8169 case DW_CFA_offset_extended
:
8170 case DW_CFA_val_offset
:
8171 READ_ULEB (reg
, start
, end
);
8172 SKIP_ULEB (start
, end
);
8173 if (frame_need_space (fc
, reg
) >= 0)
8174 fc
->col_type
[reg
] = DW_CFA_undefined
;
8176 case DW_CFA_restore_extended
:
8177 READ_ULEB (reg
, start
, end
);
8178 if (frame_need_space (fc
, reg
) >= 0)
8179 fc
->col_type
[reg
] = DW_CFA_undefined
;
8181 case DW_CFA_undefined
:
8182 READ_ULEB (reg
, start
, end
);
8183 if (frame_need_space (fc
, reg
) >= 0)
8184 fc
->col_type
[reg
] = DW_CFA_undefined
;
8186 case DW_CFA_same_value
:
8187 READ_ULEB (reg
, start
, end
);
8188 if (frame_need_space (fc
, reg
) >= 0)
8189 fc
->col_type
[reg
] = DW_CFA_undefined
;
8191 case DW_CFA_register
:
8192 READ_ULEB (reg
, start
, end
);
8193 SKIP_ULEB (start
, end
);
8194 if (frame_need_space (fc
, reg
) >= 0)
8195 fc
->col_type
[reg
] = DW_CFA_undefined
;
8197 case DW_CFA_def_cfa
:
8198 SKIP_ULEB (start
, end
);
8199 SKIP_ULEB (start
, end
);
8201 case DW_CFA_def_cfa_register
:
8202 SKIP_ULEB (start
, end
);
8204 case DW_CFA_def_cfa_offset
:
8205 SKIP_ULEB (start
, end
);
8207 case DW_CFA_def_cfa_expression
:
8208 READ_ULEB (temp
, start
, end
);
8209 new_start
= start
+ temp
;
8210 if (new_start
< start
)
8212 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8218 case DW_CFA_expression
:
8219 case DW_CFA_val_expression
:
8220 READ_ULEB (reg
, start
, end
);
8221 READ_ULEB (temp
, start
, end
);
8222 new_start
= start
+ temp
;
8223 if (new_start
< start
)
8225 /* PR 17512: file:306-192417-0.005. */
8226 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8231 if (frame_need_space (fc
, reg
) >= 0)
8232 fc
->col_type
[reg
] = DW_CFA_undefined
;
8234 case DW_CFA_offset_extended_sf
:
8235 case DW_CFA_val_offset_sf
:
8236 READ_ULEB (reg
, start
, end
);
8237 SKIP_SLEB (start
, end
);
8238 if (frame_need_space (fc
, reg
) >= 0)
8239 fc
->col_type
[reg
] = DW_CFA_undefined
;
8241 case DW_CFA_def_cfa_sf
:
8242 SKIP_ULEB (start
, end
);
8243 SKIP_SLEB (start
, end
);
8245 case DW_CFA_def_cfa_offset_sf
:
8246 SKIP_SLEB (start
, end
);
8248 case DW_CFA_MIPS_advance_loc8
:
8251 case DW_CFA_GNU_args_size
:
8252 SKIP_ULEB (start
, end
);
8254 case DW_CFA_GNU_negative_offset_extended
:
8255 READ_ULEB (reg
, start
, end
);
8256 SKIP_ULEB (start
, end
);
8257 if (frame_need_space (fc
, reg
) >= 0)
8258 fc
->col_type
[reg
] = DW_CFA_undefined
;
8269 /* Now we know what registers are used, make a second pass over
8270 the chunk, this time actually printing out the info. */
8272 while (start
< block_end
)
8274 unsigned char * tmp
;
8276 unsigned long ul
, roffs
;
8277 /* Note: It is tempting to use an unsigned long for 'reg' but there
8278 are various functions, notably frame_space_needed() that assume that
8279 reg is an unsigned int. */
8284 const char *reg_prefix
= "";
8291 /* Make a note if something other than DW_CFA_nop happens. */
8292 if (op
!= DW_CFA_nop
)
8295 /* Warning: if you add any more cases to this switch, be
8296 sure to add them to the corresponding switch above. */
8299 case DW_CFA_advance_loc
:
8300 if (do_debug_frames_interp
)
8301 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8303 printf (" DW_CFA_advance_loc: %d to %s\n",
8304 opa
* fc
->code_factor
,
8305 dwarf_vmatoa_1 (NULL
,
8306 fc
->pc_begin
+ opa
* fc
->code_factor
,
8308 fc
->pc_begin
+= opa
* fc
->code_factor
;
8312 READ_ULEB (roffs
, start
, end
);
8313 if (opa
>= (unsigned int) fc
->ncols
)
8314 reg_prefix
= bad_reg
;
8315 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8316 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8317 reg_prefix
, regname (opa
, 0),
8318 roffs
* fc
->data_factor
);
8319 if (*reg_prefix
== '\0')
8321 fc
->col_type
[opa
] = DW_CFA_offset
;
8322 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8326 case DW_CFA_restore
:
8327 if (opa
>= (unsigned int) fc
->ncols
)
8328 reg_prefix
= bad_reg
;
8329 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8330 printf (" DW_CFA_restore: %s%s\n",
8331 reg_prefix
, regname (opa
, 0));
8332 if (*reg_prefix
!= '\0')
8335 if (opa
>= (unsigned int) cie
->ncols
8336 || (do_debug_frames_interp
8337 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8339 fc
->col_type
[opa
] = DW_CFA_undefined
;
8340 fc
->col_offset
[opa
] = 0;
8344 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8345 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8349 case DW_CFA_set_loc
:
8350 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8351 if (do_debug_frames_interp
)
8352 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8354 printf (" DW_CFA_set_loc: %s\n",
8355 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8359 case DW_CFA_advance_loc1
:
8360 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8361 if (do_debug_frames_interp
)
8362 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8364 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8365 (unsigned long) (ofs
* fc
->code_factor
),
8366 dwarf_vmatoa_1 (NULL
,
8367 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8369 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8372 case DW_CFA_advance_loc2
:
8373 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8374 if (do_debug_frames_interp
)
8375 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8377 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8378 (unsigned long) (ofs
* fc
->code_factor
),
8379 dwarf_vmatoa_1 (NULL
,
8380 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8382 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8385 case DW_CFA_advance_loc4
:
8386 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8387 if (do_debug_frames_interp
)
8388 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8390 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8391 (unsigned long) (ofs
* fc
->code_factor
),
8392 dwarf_vmatoa_1 (NULL
,
8393 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8395 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8398 case DW_CFA_offset_extended
:
8399 READ_ULEB (reg
, start
, end
);
8400 READ_ULEB (roffs
, start
, end
);
8401 if (reg
>= (unsigned int) fc
->ncols
)
8402 reg_prefix
= bad_reg
;
8403 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8404 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8405 reg_prefix
, regname (reg
, 0),
8406 roffs
* fc
->data_factor
);
8407 if (*reg_prefix
== '\0')
8409 fc
->col_type
[reg
] = DW_CFA_offset
;
8410 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8414 case DW_CFA_val_offset
:
8415 READ_ULEB (reg
, start
, end
);
8416 READ_ULEB (roffs
, start
, end
);
8417 if (reg
>= (unsigned int) fc
->ncols
)
8418 reg_prefix
= bad_reg
;
8419 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8420 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8421 reg_prefix
, regname (reg
, 0),
8422 roffs
* fc
->data_factor
);
8423 if (*reg_prefix
== '\0')
8425 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8426 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8430 case DW_CFA_restore_extended
:
8431 READ_ULEB (reg
, start
, end
);
8432 if (reg
>= (unsigned int) fc
->ncols
)
8433 reg_prefix
= bad_reg
;
8434 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8435 printf (" DW_CFA_restore_extended: %s%s\n",
8436 reg_prefix
, regname (reg
, 0));
8437 if (*reg_prefix
!= '\0')
8440 if (reg
>= (unsigned int) cie
->ncols
)
8442 fc
->col_type
[reg
] = DW_CFA_undefined
;
8443 fc
->col_offset
[reg
] = 0;
8447 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8448 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8452 case DW_CFA_undefined
:
8453 READ_ULEB (reg
, start
, end
);
8454 if (reg
>= (unsigned int) fc
->ncols
)
8455 reg_prefix
= bad_reg
;
8456 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8457 printf (" DW_CFA_undefined: %s%s\n",
8458 reg_prefix
, regname (reg
, 0));
8459 if (*reg_prefix
== '\0')
8461 fc
->col_type
[reg
] = DW_CFA_undefined
;
8462 fc
->col_offset
[reg
] = 0;
8466 case DW_CFA_same_value
:
8467 READ_ULEB (reg
, start
, end
);
8468 if (reg
>= (unsigned int) fc
->ncols
)
8469 reg_prefix
= bad_reg
;
8470 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8471 printf (" DW_CFA_same_value: %s%s\n",
8472 reg_prefix
, regname (reg
, 0));
8473 if (*reg_prefix
== '\0')
8475 fc
->col_type
[reg
] = DW_CFA_same_value
;
8476 fc
->col_offset
[reg
] = 0;
8480 case DW_CFA_register
:
8481 READ_ULEB (reg
, start
, end
);
8482 READ_ULEB (roffs
, start
, end
);
8483 if (reg
>= (unsigned int) fc
->ncols
)
8484 reg_prefix
= bad_reg
;
8485 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8487 printf (" DW_CFA_register: %s%s in ",
8488 reg_prefix
, regname (reg
, 0));
8489 puts (regname (roffs
, 0));
8491 if (*reg_prefix
== '\0')
8493 fc
->col_type
[reg
] = DW_CFA_register
;
8494 fc
->col_offset
[reg
] = roffs
;
8498 case DW_CFA_remember_state
:
8499 if (! do_debug_frames_interp
)
8500 printf (" DW_CFA_remember_state\n");
8501 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8502 rs
->cfa_offset
= fc
->cfa_offset
;
8503 rs
->cfa_reg
= fc
->cfa_reg
;
8505 rs
->cfa_exp
= fc
->cfa_exp
;
8506 rs
->ncols
= fc
->ncols
;
8507 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8508 sizeof (* rs
->col_type
));
8509 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8510 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8511 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8512 rs
->next
= remembered_state
;
8513 remembered_state
= rs
;
8516 case DW_CFA_restore_state
:
8517 if (! do_debug_frames_interp
)
8518 printf (" DW_CFA_restore_state\n");
8519 rs
= remembered_state
;
8522 remembered_state
= rs
->next
;
8523 fc
->cfa_offset
= rs
->cfa_offset
;
8524 fc
->cfa_reg
= rs
->cfa_reg
;
8526 fc
->cfa_exp
= rs
->cfa_exp
;
8527 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8529 warn (_("Invalid column number in saved frame state\n"));
8533 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8534 memcpy (fc
->col_offset
, rs
->col_offset
,
8535 rs
->ncols
* sizeof (* rs
->col_offset
));
8536 free (rs
->col_type
);
8537 free (rs
->col_offset
);
8540 else if (do_debug_frames_interp
)
8541 printf ("Mismatched DW_CFA_restore_state\n");
8544 case DW_CFA_def_cfa
:
8545 READ_ULEB (fc
->cfa_reg
, start
, end
);
8546 READ_ULEB (fc
->cfa_offset
, start
, end
);
8548 if (! do_debug_frames_interp
)
8549 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8550 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8553 case DW_CFA_def_cfa_register
:
8554 READ_ULEB (fc
->cfa_reg
, start
, end
);
8556 if (! do_debug_frames_interp
)
8557 printf (" DW_CFA_def_cfa_register: %s\n",
8558 regname (fc
->cfa_reg
, 0));
8561 case DW_CFA_def_cfa_offset
:
8562 READ_ULEB (fc
->cfa_offset
, start
, end
);
8563 if (! do_debug_frames_interp
)
8564 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8568 if (! do_debug_frames_interp
)
8569 printf (" DW_CFA_nop\n");
8572 case DW_CFA_def_cfa_expression
:
8573 READ_ULEB (ul
, start
, end
);
8574 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8576 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8579 if (! do_debug_frames_interp
)
8581 printf (" DW_CFA_def_cfa_expression (");
8582 decode_location_expression (start
, eh_addr_size
, 0, -1,
8590 case DW_CFA_expression
:
8591 READ_ULEB (reg
, start
, end
);
8592 READ_ULEB (ul
, start
, end
);
8593 if (reg
>= (unsigned int) fc
->ncols
)
8594 reg_prefix
= bad_reg
;
8595 /* PR 17512: file: 069-133014-0.006. */
8596 /* PR 17512: file: 98c02eb4. */
8598 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8600 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8603 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8605 printf (" DW_CFA_expression: %s%s (",
8606 reg_prefix
, regname (reg
, 0));
8607 decode_location_expression (start
, eh_addr_size
, 0, -1,
8611 if (*reg_prefix
== '\0')
8612 fc
->col_type
[reg
] = DW_CFA_expression
;
8616 case DW_CFA_val_expression
:
8617 READ_ULEB (reg
, start
, end
);
8618 READ_ULEB (ul
, start
, end
);
8619 if (reg
>= (unsigned int) fc
->ncols
)
8620 reg_prefix
= bad_reg
;
8622 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8624 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8627 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8629 printf (" DW_CFA_val_expression: %s%s (",
8630 reg_prefix
, regname (reg
, 0));
8631 decode_location_expression (start
, eh_addr_size
, 0, -1,
8635 if (*reg_prefix
== '\0')
8636 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8640 case DW_CFA_offset_extended_sf
:
8641 READ_ULEB (reg
, start
, end
);
8642 READ_SLEB (l
, start
, end
);
8643 if (frame_need_space (fc
, reg
) < 0)
8644 reg_prefix
= bad_reg
;
8645 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8646 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8647 reg_prefix
, regname (reg
, 0),
8648 (long)(l
* fc
->data_factor
));
8649 if (*reg_prefix
== '\0')
8651 fc
->col_type
[reg
] = DW_CFA_offset
;
8652 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8656 case DW_CFA_val_offset_sf
:
8657 READ_ULEB (reg
, start
, end
);
8658 READ_SLEB (l
, start
, end
);
8659 if (frame_need_space (fc
, reg
) < 0)
8660 reg_prefix
= bad_reg
;
8661 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8662 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8663 reg_prefix
, regname (reg
, 0),
8664 (long)(l
* fc
->data_factor
));
8665 if (*reg_prefix
== '\0')
8667 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8668 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8672 case DW_CFA_def_cfa_sf
:
8673 READ_ULEB (fc
->cfa_reg
, start
, end
);
8674 READ_ULEB (fc
->cfa_offset
, start
, end
);
8675 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8677 if (! do_debug_frames_interp
)
8678 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8679 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8682 case DW_CFA_def_cfa_offset_sf
:
8683 READ_ULEB (fc
->cfa_offset
, start
, end
);
8684 fc
->cfa_offset
*= fc
->data_factor
;
8685 if (! do_debug_frames_interp
)
8686 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8689 case DW_CFA_MIPS_advance_loc8
:
8690 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8691 if (do_debug_frames_interp
)
8692 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8694 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8695 (unsigned long) (ofs
* fc
->code_factor
),
8696 dwarf_vmatoa_1 (NULL
,
8697 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8699 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8702 case DW_CFA_GNU_window_save
:
8703 if (! do_debug_frames_interp
)
8704 printf (" DW_CFA_GNU_window_save\n");
8707 case DW_CFA_GNU_args_size
:
8708 READ_ULEB (ul
, start
, end
);
8709 if (! do_debug_frames_interp
)
8710 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8713 case DW_CFA_GNU_negative_offset_extended
:
8714 READ_ULEB (reg
, start
, end
);
8715 READ_SLEB (l
, start
, end
);
8717 if (frame_need_space (fc
, reg
) < 0)
8718 reg_prefix
= bad_reg
;
8719 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8720 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8721 reg_prefix
, regname (reg
, 0),
8722 (long)(l
* fc
->data_factor
));
8723 if (*reg_prefix
== '\0')
8725 fc
->col_type
[reg
] = DW_CFA_offset
;
8726 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8731 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8732 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8734 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8739 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8740 if (do_debug_frames_interp
&& ! all_nops
)
8741 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8743 if (fde_fc
.col_type
!= NULL
)
8745 free (fde_fc
.col_type
);
8746 fde_fc
.col_type
= NULL
;
8748 if (fde_fc
.col_offset
!= NULL
)
8750 free (fde_fc
.col_offset
);
8751 fde_fc
.col_offset
= NULL
;
8755 eh_addr_size
= saved_eh_addr_size
;
8760 while (remembered_state
!= NULL
)
8762 rs
= remembered_state
;
8763 remembered_state
= rs
->next
;
8764 free (rs
->col_type
);
8765 free (rs
->col_offset
);
8766 rs
->next
= NULL
; /* Paranoia. */
8770 while (chunks
!= NULL
)
8774 free (rs
->col_type
);
8775 free (rs
->col_offset
);
8776 rs
->next
= NULL
; /* Paranoia. */
8780 while (forward_refs
!= NULL
)
8783 forward_refs
= rs
->next
;
8784 free (rs
->col_type
);
8785 free (rs
->col_offset
);
8786 rs
->next
= NULL
; /* Paranoia. */
8796 display_debug_names (struct dwarf_section
*section
, void *file
)
8798 unsigned char *hdrptr
= section
->start
;
8799 dwarf_vma unit_length
;
8800 unsigned char *unit_start
;
8801 const unsigned char *const section_end
= section
->start
+ section
->size
;
8802 unsigned char *unit_end
;
8804 introduce (section
, FALSE
);
8806 load_debug_section_with_follow (str
, file
);
8808 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8810 unsigned int offset_size
;
8811 uint16_t dwarf_version
, padding
;
8812 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8813 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8814 uint32_t augmentation_string_size
;
8816 unsigned long sec_off
;
8817 bfd_boolean augmentation_printable
;
8818 const char *augmentation_string
;
8820 unit_start
= hdrptr
;
8822 /* Get and check the length of the block. */
8823 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8825 if (unit_length
== 0xffffffff)
8827 /* This section is 64-bit DWARF. */
8828 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8833 unit_end
= hdrptr
+ unit_length
;
8835 sec_off
= hdrptr
- section
->start
;
8836 if (sec_off
+ unit_length
< sec_off
8837 || sec_off
+ unit_length
> section
->size
)
8839 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8841 (unsigned long) (unit_start
- section
->start
),
8842 dwarf_vmatoa ("x", unit_length
));
8846 /* Get and check the version number. */
8847 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8848 printf (_("Version %ld\n"), (long) dwarf_version
);
8850 /* Prior versions did not exist, and future versions may not be
8851 backwards compatible. */
8852 if (dwarf_version
!= 5)
8854 warn (_("Only DWARF version 5 .debug_names "
8855 "is currently supported.\n"));
8859 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8861 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8864 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8865 if (comp_unit_count
== 0)
8866 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8868 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8869 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8870 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8871 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8872 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8874 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8875 if (augmentation_string_size
% 4 != 0)
8877 warn (_("Augmentation string length %u must be rounded up "
8878 "to a multiple of 4 in .debug_names.\n"),
8879 augmentation_string_size
);
8880 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8883 printf (_("Augmentation string:"));
8885 augmentation_printable
= TRUE
;
8886 augmentation_string
= (const char *) hdrptr
;
8888 for (i
= 0; i
< augmentation_string_size
; i
++)
8892 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8893 printf (" %02x", uc
);
8895 if (uc
!= 0 && !ISPRINT (uc
))
8896 augmentation_printable
= FALSE
;
8899 if (augmentation_printable
)
8903 i
< augmentation_string_size
&& augmentation_string
[i
];
8905 putchar (augmentation_string
[i
]);
8910 printf (_("CU table:\n"));
8911 for (i
= 0; i
< comp_unit_count
; i
++)
8915 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8916 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8920 printf (_("TU table:\n"));
8921 for (i
= 0; i
< local_type_unit_count
; i
++)
8925 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8926 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8930 printf (_("Foreign TU table:\n"));
8931 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8935 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8936 printf (_("[%3u] "), i
);
8937 print_dwarf_vma (signature
, 8);
8942 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8943 hdrptr
+= bucket_count
* sizeof (uint32_t);
8944 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8945 hdrptr
+= name_count
* sizeof (uint32_t);
8946 unsigned char *const name_table_string_offsets
= hdrptr
;
8947 hdrptr
+= name_count
* offset_size
;
8948 unsigned char *const name_table_entry_offsets
= hdrptr
;
8949 hdrptr
+= name_count
* offset_size
;
8950 unsigned char *const abbrev_table
= hdrptr
;
8951 hdrptr
+= abbrev_table_size
;
8952 const unsigned char *const abbrev_table_end
= hdrptr
;
8953 unsigned char *const entry_pool
= hdrptr
;
8954 if (hdrptr
> unit_end
)
8956 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8957 "for unit 0x%lx in the debug_names\n"),
8958 (long) (hdrptr
- section
->start
),
8959 (long) (unit_end
- section
->start
),
8960 (long) (unit_start
- section
->start
));
8964 size_t buckets_filled
= 0;
8966 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8968 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8973 printf (ngettext ("Used %zu of %lu bucket.\n",
8974 "Used %zu of %lu buckets.\n",
8976 buckets_filled
, (unsigned long) bucket_count
);
8978 uint32_t hash_prev
= 0;
8979 size_t hash_clash_count
= 0;
8980 size_t longest_clash
= 0;
8981 size_t this_length
= 0;
8983 for (hashi
= 0; hashi
< name_count
; hashi
++)
8985 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8989 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8993 longest_clash
= MAX (longest_clash
, this_length
);
8998 hash_prev
= hash_this
;
9000 printf (_("Out of %lu items there are %zu bucket clashes"
9001 " (longest of %zu entries).\n"),
9002 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9003 assert (name_count
== buckets_filled
+ hash_clash_count
);
9005 struct abbrev_lookup_entry
9007 dwarf_vma abbrev_tag
;
9008 unsigned char *abbrev_lookup_ptr
;
9010 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9011 size_t abbrev_lookup_used
= 0;
9012 size_t abbrev_lookup_allocated
= 0;
9014 unsigned char *abbrevptr
= abbrev_table
;
9017 dwarf_vma abbrev_tag
;
9019 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9020 if (abbrev_tag
== 0)
9022 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9024 abbrev_lookup_allocated
= MAX (0x100,
9025 abbrev_lookup_allocated
* 2);
9026 abbrev_lookup
= xrealloc (abbrev_lookup
,
9027 (abbrev_lookup_allocated
9028 * sizeof (*abbrev_lookup
)));
9030 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9031 struct abbrev_lookup_entry
*entry
;
9032 for (entry
= abbrev_lookup
;
9033 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9035 if (entry
->abbrev_tag
== abbrev_tag
)
9037 warn (_("Duplicate abbreviation tag %lu "
9038 "in unit 0x%lx in the debug_names\n"),
9039 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9042 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9043 entry
->abbrev_tag
= abbrev_tag
;
9044 entry
->abbrev_lookup_ptr
= abbrevptr
;
9046 /* Skip DWARF tag. */
9047 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9050 dwarf_vma xindex
, form
;
9052 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9053 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9054 if (xindex
== 0 && form
== 0)
9059 printf (_("\nSymbol table:\n"));
9061 for (namei
= 0; namei
< name_count
; ++namei
)
9063 uint64_t string_offset
, entry_offset
;
9065 SAFE_BYTE_GET (string_offset
,
9066 name_table_string_offsets
+ namei
* offset_size
,
9067 offset_size
, unit_end
);
9068 SAFE_BYTE_GET (entry_offset
,
9069 name_table_entry_offsets
+ namei
* offset_size
,
9070 offset_size
, unit_end
);
9072 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9073 fetch_indirect_string (string_offset
));
9075 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9077 // We need to scan first whether there is a single or multiple
9078 // entries. TAGNO is -2 for the first entry, it is -1 for the
9079 // initial tag read of the second entry, then it becomes 0 for the
9080 // first entry for real printing etc.
9082 /* Initialize it due to a false compiler warning. */
9083 dwarf_vma second_abbrev_tag
= -1;
9086 dwarf_vma abbrev_tag
;
9087 dwarf_vma dwarf_tag
;
9088 const struct abbrev_lookup_entry
*entry
;
9090 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9093 second_abbrev_tag
= abbrev_tag
;
9095 entryptr
= entry_pool
+ entry_offset
;
9098 if (abbrev_tag
== 0)
9102 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9103 (unsigned long) abbrev_tag
);
9105 for (entry
= abbrev_lookup
;
9106 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9108 if (entry
->abbrev_tag
== abbrev_tag
)
9110 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9112 warn (_("Undefined abbreviation tag %lu "
9113 "in unit 0x%lx in the debug_names\n"),
9115 (long) (unit_start
- section
->start
));
9118 abbrevptr
= entry
->abbrev_lookup_ptr
;
9119 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9121 printf (" %s", get_TAG_name (dwarf_tag
));
9124 dwarf_vma xindex
, form
;
9126 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9127 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9128 if (xindex
== 0 && form
== 0)
9132 printf (" %s", get_IDX_name (xindex
));
9133 entryptr
= read_and_display_attr_value (0, form
, 0,
9134 unit_start
, entryptr
, unit_end
,
9136 dwarf_version
, NULL
,
9143 printf (_(" <no entries>"));
9147 free (abbrev_lookup
);
9154 display_debug_links (struct dwarf_section
* section
,
9155 void * file ATTRIBUTE_UNUSED
)
9157 const unsigned char * filename
;
9158 unsigned int filelen
;
9160 introduce (section
, FALSE
);
9162 /* The .gnu_debuglink section is formatted as:
9163 (c-string) Filename.
9164 (padding) If needed to reach a 4 byte boundary.
9165 (uint32_t) CRC32 value.
9167 The .gun_debugaltlink section is formatted as:
9168 (c-string) Filename.
9169 (binary) Build-ID. */
9171 filename
= section
->start
;
9172 filelen
= strnlen ((const char *) filename
, section
->size
);
9173 if (filelen
== section
->size
)
9175 warn (_("The debuglink filename is corrupt/missing\n"));
9179 printf (_(" Separate debug info file: %s\n"), filename
);
9181 if (const_strneq (section
->name
, ".gnu_debuglink"))
9184 unsigned int crc_offset
;
9186 crc_offset
= filelen
+ 1;
9187 crc_offset
= (crc_offset
+ 3) & ~3;
9188 if (crc_offset
+ 4 > section
->size
)
9190 warn (_("CRC offset missing/truncated\n"));
9194 crc32
= byte_get (filename
+ crc_offset
, 4);
9196 printf (_(" CRC value: %#x\n"), crc32
);
9198 if (crc_offset
+ 4 < section
->size
)
9200 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9201 (long)(section
->size
- (crc_offset
+ 4)));
9205 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9207 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9208 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9209 bfd_size_type printed
;
9211 /* FIXME: Should we support smaller build-id notes ? */
9212 if (build_id_len
< 0x14)
9214 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9218 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9219 display_data (printed
, build_id
, build_id_len
);
9228 display_gdb_index (struct dwarf_section
*section
,
9229 void *file ATTRIBUTE_UNUSED
)
9231 unsigned char *start
= section
->start
;
9233 uint32_t cu_list_offset
, tu_list_offset
;
9234 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9235 unsigned int cu_list_elements
, tu_list_elements
;
9236 unsigned int address_table_size
, symbol_table_slots
;
9237 unsigned char *cu_list
, *tu_list
;
9238 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9241 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9243 introduce (section
, FALSE
);
9245 if (section
->size
< 6 * sizeof (uint32_t))
9247 warn (_("Truncated header in the %s section.\n"), section
->name
);
9251 version
= byte_get_little_endian (start
, 4);
9252 printf (_("Version %ld\n"), (long) version
);
9254 /* Prior versions are obsolete, and future versions may not be
9255 backwards compatible. */
9256 if (version
< 3 || version
> 8)
9258 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9262 warn (_("The address table data in version 3 may be wrong.\n"));
9264 warn (_("Version 4 does not support case insensitive lookups.\n"));
9266 warn (_("Version 5 does not include inlined functions.\n"));
9268 warn (_("Version 6 does not include symbol attributes.\n"));
9269 /* Version 7 indices generated by Gold have bad type unit references,
9270 PR binutils/15021. But we don't know if the index was generated by
9271 Gold or not, so to avoid worrying users with gdb-generated indices
9272 we say nothing for version 7 here. */
9274 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9275 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9276 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9277 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9278 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9280 if (cu_list_offset
> section
->size
9281 || tu_list_offset
> section
->size
9282 || address_table_offset
> section
->size
9283 || symbol_table_offset
> section
->size
9284 || constant_pool_offset
> section
->size
)
9286 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9290 /* PR 17531: file: 418d0a8a. */
9291 if (tu_list_offset
< cu_list_offset
)
9293 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9294 tu_list_offset
, cu_list_offset
);
9298 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9300 if (address_table_offset
< tu_list_offset
)
9302 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9303 address_table_offset
, tu_list_offset
);
9307 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9309 /* PR 17531: file: 18a47d3d. */
9310 if (symbol_table_offset
< address_table_offset
)
9312 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9313 symbol_table_offset
, address_table_offset
);
9317 address_table_size
= symbol_table_offset
- address_table_offset
;
9319 if (constant_pool_offset
< symbol_table_offset
)
9321 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9322 constant_pool_offset
, symbol_table_offset
);
9326 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9328 cu_list
= start
+ cu_list_offset
;
9329 tu_list
= start
+ tu_list_offset
;
9330 address_table
= start
+ address_table_offset
;
9331 symbol_table
= start
+ symbol_table_offset
;
9332 constant_pool
= start
+ constant_pool_offset
;
9334 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9336 warn (_("Address table extends beyond end of section.\n"));
9340 printf (_("\nCU table:\n"));
9341 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9343 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9344 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9346 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9347 (unsigned long) cu_offset
,
9348 (unsigned long) (cu_offset
+ cu_length
- 1));
9351 printf (_("\nTU table:\n"));
9352 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9354 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9355 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9356 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9358 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9359 (unsigned long) tu_offset
,
9360 (unsigned long) type_offset
);
9361 print_dwarf_vma (signature
, 8);
9365 printf (_("\nAddress table:\n"));
9366 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9369 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9370 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9371 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9373 print_dwarf_vma (low
, 8);
9374 print_dwarf_vma (high
, 8);
9375 printf (_("%lu\n"), (unsigned long) cu_index
);
9378 printf (_("\nSymbol table:\n"));
9379 for (i
= 0; i
< symbol_table_slots
; ++i
)
9381 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9382 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9383 uint32_t num_cus
, cu
;
9385 if (name_offset
!= 0
9386 || cu_vector_offset
!= 0)
9389 unsigned char * adr
;
9391 adr
= constant_pool
+ name_offset
;
9392 /* PR 17531: file: 5b7b07ad. */
9393 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9395 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9396 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9400 printf ("[%3u] %.*s:", i
,
9401 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9402 constant_pool
+ name_offset
);
9404 adr
= constant_pool
+ cu_vector_offset
;
9405 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9407 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9408 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9409 cu_vector_offset
, i
);
9413 num_cus
= byte_get_little_endian (adr
, 4);
9415 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9416 if (num_cus
* 4 < num_cus
9417 || adr
>= section
->start
+ section
->size
9418 || adr
< constant_pool
)
9420 printf ("<invalid number of CUs: %d>\n", num_cus
);
9421 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9429 for (j
= 0; j
< num_cus
; ++j
)
9432 gdb_index_symbol_kind kind
;
9434 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9435 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9436 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9437 cu
= GDB_INDEX_CU_VALUE (cu
);
9438 /* Convert to TU number if it's for a type unit. */
9439 if (cu
>= cu_list_elements
/ 2)
9440 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9441 (unsigned long) (cu
- cu_list_elements
/ 2));
9443 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9445 printf (" [%s, %s]",
9446 is_static
? _("static") : _("global"),
9447 get_gdb_index_symbol_kind_name (kind
));
9459 /* Pre-allocate enough space for the CU/TU sets needed. */
9462 prealloc_cu_tu_list (unsigned int nshndx
)
9464 if (shndx_pool
== NULL
)
9466 shndx_pool_size
= nshndx
;
9467 shndx_pool_used
= 0;
9468 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9469 sizeof (unsigned int));
9473 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9474 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9475 sizeof (unsigned int));
9480 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9482 if (shndx_pool_used
>= shndx_pool_size
)
9484 error (_("Internal error: out of space in the shndx pool.\n"));
9487 shndx_pool
[shndx_pool_used
++] = shndx
;
9491 end_cu_tu_entry (void)
9493 if (shndx_pool_used
>= shndx_pool_size
)
9495 error (_("Internal error: out of space in the shndx pool.\n"));
9498 shndx_pool
[shndx_pool_used
++] = 0;
9501 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9504 get_DW_SECT_short_name (unsigned int dw_sect
)
9506 static char buf
[16];
9514 case DW_SECT_ABBREV
:
9520 case DW_SECT_STR_OFFSETS
:
9522 case DW_SECT_MACINFO
:
9530 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9534 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9535 These sections are extensions for Fission.
9536 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9539 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9541 unsigned char *phdr
= section
->start
;
9542 unsigned char *limit
= phdr
+ section
->size
;
9543 unsigned char *phash
;
9544 unsigned char *pindex
;
9545 unsigned char *ppool
;
9546 unsigned int version
;
9547 unsigned int ncols
= 0;
9549 unsigned int nslots
;
9552 dwarf_vma signature_high
;
9553 dwarf_vma signature_low
;
9556 /* PR 17512: file: 002-168123-0.004. */
9559 warn (_("Section %s is empty\n"), section
->name
);
9562 /* PR 17512: file: 002-376-0.004. */
9563 if (section
->size
< 24)
9565 warn (_("Section %s is too small to contain a CU/TU header\n"),
9570 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9572 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9573 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9574 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9577 pindex
= phash
+ (size_t) nslots
* 8;
9578 ppool
= pindex
+ (size_t) nslots
* 4;
9582 introduce (section
, FALSE
);
9584 printf (_(" Version: %u\n"), version
);
9586 printf (_(" Number of columns: %u\n"), ncols
);
9587 printf (_(" Number of used entries: %u\n"), nused
);
9588 printf (_(" Number of slots: %u\n\n"), nslots
);
9591 /* PR 17531: file: 45d69832. */
9592 if ((size_t) nslots
* 8 / 8 != nslots
9593 || phash
< phdr
|| phash
> limit
9594 || pindex
< phash
|| pindex
> limit
9595 || ppool
< pindex
|| ppool
> limit
)
9597 warn (ngettext ("Section %s is too small for %u slot\n",
9598 "Section %s is too small for %u slots\n",
9600 section
->name
, nslots
);
9607 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9608 for (i
= 0; i
< nslots
; i
++)
9610 unsigned char *shndx_list
;
9613 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9614 if (signature_high
!= 0 || signature_low
!= 0)
9616 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9617 shndx_list
= ppool
+ j
* 4;
9618 /* PR 17531: file: 705e010d. */
9619 if (shndx_list
< ppool
)
9621 warn (_("Section index pool located before start of section\n"));
9626 printf (_(" [%3d] Signature: 0x%s Sections: "),
9627 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9628 buf
, sizeof (buf
)));
9631 if (shndx_list
>= limit
)
9633 warn (_("Section %s too small for shndx pool\n"),
9637 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9641 printf (" %d", shndx
);
9643 add_shndx_to_cu_tu_entry (shndx
);
9655 else if (version
== 2)
9658 unsigned int dw_sect
;
9659 unsigned char *ph
= phash
;
9660 unsigned char *pi
= pindex
;
9661 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9662 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9663 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9664 bfd_boolean is_tu_index
;
9665 struct cu_tu_set
*this_set
= NULL
;
9667 unsigned char *prow
;
9669 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9671 /* PR 17531: file: 0dd159bf.
9672 Check for integer overflow (can occur when size_t is 32-bit)
9673 with overlarge ncols or nused values. */
9675 && ((size_t) ncols
* 4 / 4 != ncols
9676 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9677 || poffsets
< ppool
|| poffsets
> limit
9678 || psizes
< poffsets
|| psizes
> limit
9679 || pend
< psizes
|| pend
> limit
))
9681 warn (_("Section %s too small for offset and size tables\n"),
9688 printf (_(" Offset table\n"));
9689 printf (" slot %-16s ",
9690 is_tu_index
? _("signature") : _("dwo_id"));
9697 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9703 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9710 for (j
= 0; j
< ncols
; j
++)
9712 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9713 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9718 for (i
= 0; i
< nslots
; i
++)
9720 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9722 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9725 /* PR 17531: file: a05f6ab3. */
9728 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9735 size_t num_copy
= sizeof (uint64_t);
9737 /* PR 23064: Beware of buffer overflow. */
9738 if (ph
+ num_copy
< limit
)
9739 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9742 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9747 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9748 /* PR 17531: file: b8ce60a8. */
9749 if (prow
< poffsets
|| prow
> limit
)
9751 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9757 printf (_(" [%3d] 0x%s"),
9758 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9759 buf
, sizeof (buf
)));
9760 for (j
= 0; j
< ncols
; j
++)
9762 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9764 printf (" %8d", val
);
9767 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9769 /* PR 17531: file: 10796eb3. */
9770 if (dw_sect
>= DW_SECT_MAX
)
9771 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9773 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9789 printf (_(" Size table\n"));
9790 printf (" slot %-16s ",
9791 is_tu_index
? _("signature") : _("dwo_id"));
9794 for (j
= 0; j
< ncols
; j
++)
9796 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9798 printf (" %8s", get_DW_SECT_short_name (val
));
9804 for (i
= 0; i
< nslots
; i
++)
9806 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9808 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9811 prow
= psizes
+ (row
- 1) * ncols
* 4;
9814 printf (_(" [%3d] 0x%s"),
9815 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9816 buf
, sizeof (buf
)));
9818 for (j
= 0; j
< ncols
; j
++)
9820 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9822 printf (" %8d", val
);
9825 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9826 if (dw_sect
>= DW_SECT_MAX
)
9827 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9829 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9841 else if (do_display
)
9842 printf (_(" Unsupported version (%d)\n"), version
);
9850 /* Load the CU and TU indexes if present. This will build a list of
9851 section sets that we can use to associate a .debug_info.dwo section
9852 with its associated .debug_abbrev.dwo section in a .dwp file. */
9855 load_cu_tu_indexes (void *file
)
9857 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9859 /* If we have already loaded (or tried to load) the CU and TU indexes
9860 then do not bother to repeat the task. */
9861 if (cu_tu_indexes_read
== -1)
9863 cu_tu_indexes_read
= TRUE
;
9865 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9866 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9867 cu_tu_indexes_read
= FALSE
;
9869 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9870 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9871 cu_tu_indexes_read
= FALSE
;
9874 return (bfd_boolean
) cu_tu_indexes_read
;
9877 /* Find the set of sections that includes section SHNDX. */
9880 find_cu_tu_set (void *file
, unsigned int shndx
)
9884 if (! load_cu_tu_indexes (file
))
9887 /* Find SHNDX in the shndx pool. */
9888 for (i
= 0; i
< shndx_pool_used
; i
++)
9889 if (shndx_pool
[i
] == shndx
)
9892 if (i
>= shndx_pool_used
)
9895 /* Now backup to find the first entry in the set. */
9896 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9899 return shndx_pool
+ i
;
9902 /* Display a .debug_cu_index or .debug_tu_index section. */
9905 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9907 return process_cu_tu_index (section
, 1);
9911 display_debug_not_supported (struct dwarf_section
*section
,
9912 void *file ATTRIBUTE_UNUSED
)
9914 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9920 /* Like malloc, but takes two parameters like calloc.
9921 Verifies that the first parameter is not too large.
9922 Note: does *not* initialise the allocated memory to zero. */
9925 cmalloc (size_t nmemb
, size_t size
)
9927 /* Check for overflow. */
9928 if (nmemb
>= ~(size_t) 0 / size
)
9931 return xmalloc (nmemb
* size
);
9934 /* Like xmalloc, but takes two parameters like calloc.
9935 Verifies that the first parameter is not too large.
9936 Note: does *not* initialise the allocated memory to zero. */
9939 xcmalloc (size_t nmemb
, size_t size
)
9941 /* Check for overflow. */
9942 if (nmemb
>= ~(size_t) 0 / size
)
9945 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9950 return xmalloc (nmemb
* size
);
9953 /* Like xrealloc, but takes three parameters.
9954 Verifies that the second parameter is not too large.
9955 Note: does *not* initialise any new memory to zero. */
9958 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9960 /* Check for overflow. */
9961 if (nmemb
>= ~(size_t) 0 / size
)
9963 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9968 return xrealloc (ptr
, nmemb
* size
);
9971 /* Like xcalloc, but verifies that the first parameter is not too large. */
9974 xcalloc2 (size_t nmemb
, size_t size
)
9976 /* Check for overflow. */
9977 if (nmemb
>= ~(size_t) 0 / size
)
9979 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9984 return xcalloc (nmemb
, size
);
9987 static unsigned long
9988 calc_gnu_debuglink_crc32 (unsigned long crc
,
9989 const unsigned char * buf
,
9992 static const unsigned long crc32_table
[256] =
9994 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9995 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9996 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9997 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9998 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9999 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10000 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10001 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10002 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10003 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10004 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10005 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10006 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10007 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10008 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10009 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10010 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10011 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10012 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10013 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10014 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10015 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10016 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10017 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10018 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10019 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10020 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10021 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10022 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10023 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10024 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10025 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10026 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10027 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10028 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10029 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10030 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10031 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10032 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10033 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10034 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10035 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10036 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10037 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10038 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10039 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10040 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10041 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10042 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10043 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10044 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10047 const unsigned char *end
;
10049 crc
= ~crc
& 0xffffffff;
10050 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10051 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10052 return ~crc
& 0xffffffff;
10055 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10056 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10059 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10061 static unsigned char buffer
[8 * 1024];
10063 bfd_size_type count
;
10064 unsigned long crc
= 0;
10067 sep_data
= open_debug_file (pathname
);
10068 if (sep_data
== NULL
)
10071 /* Yes - we are opening the file twice... */
10072 f
= fopen (pathname
, "rb");
10075 /* Paranoia: This should never happen. */
10076 close_debug_file (sep_data
);
10077 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10081 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10082 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10086 if (crc
!= * (unsigned long *) crc_pointer
)
10088 close_debug_file (sep_data
);
10089 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10097 static const char *
10098 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10101 unsigned int crc_offset
;
10102 unsigned long * crc32
= (unsigned long *) data
;
10104 /* The name is first.
10105 The CRC value is stored after the filename, aligned up to 4 bytes. */
10106 name
= (const char *) section
->start
;
10109 crc_offset
= strnlen (name
, section
->size
) + 1;
10110 crc_offset
= (crc_offset
+ 3) & ~3;
10111 if (crc_offset
+ 4 > section
->size
)
10114 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10119 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10121 void * sep_data
= open_debug_file (filename
);
10123 if (sep_data
== NULL
)
10126 /* FIXME: We should now extract the build-id in the separate file
10132 typedef struct build_id_data
10135 const unsigned char * data
;
10138 static const char *
10139 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10142 bfd_size_type namelen
;
10143 bfd_size_type id_len
;
10144 Build_id_data
* build_id_data
;
10146 /* The name is first.
10147 The build-id follows immediately, with no padding, up to the section's end. */
10149 name
= (const char *) section
->start
;
10150 namelen
= strnlen (name
, section
->size
) + 1;
10151 if (namelen
>= section
->size
)
10154 id_len
= section
->size
- namelen
;
10158 build_id_data
= calloc (1, sizeof * build_id_data
);
10159 if (build_id_data
== NULL
)
10162 build_id_data
->len
= id_len
;
10163 build_id_data
->data
= section
->start
+ namelen
;
10165 * (Build_id_data
**) data
= build_id_data
;
10171 add_separate_debug_file (const char * filename
, void * handle
)
10173 separate_info
* i
= xmalloc (sizeof * i
);
10175 i
->filename
= filename
;
10176 i
->handle
= handle
;
10177 i
->next
= first_separate_info
;
10178 first_separate_info
= i
;
10181 #if HAVE_LIBDEBUGINFOD
10182 /* Query debuginfod servers for the target debuglink or debugaltlink
10183 file. If successful, store the path of the file in filename and
10184 return TRUE, otherwise return FALSE. */
10187 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10191 size_t build_id_len
;
10192 unsigned char * build_id
;
10194 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10196 /* Get the build-id of file. */
10197 build_id
= get_build_id (file
);
10200 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10202 /* Get the build-id of the debugaltlink file. */
10203 unsigned int filelen
;
10205 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10206 if (filelen
== section
->size
)
10207 /* Corrupt debugaltlink. */
10210 build_id
= section
->start
+ filelen
+ 1;
10211 build_id_len
= section
->size
- (filelen
+ 1);
10213 if (build_id_len
== 0)
10222 debuginfod_client
* client
;
10224 client
= debuginfod_begin ();
10225 if (client
== NULL
)
10228 /* Query debuginfod servers for the target file. If found its path
10229 will be stored in filename. */
10230 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10231 debuginfod_end (client
);
10233 /* Only free build_id if we allocated space for a hex string
10234 in get_build_id (). */
10235 if (build_id_len
== 0)
10240 /* File successfully retrieved. Close fd since we want to
10241 use open_debug_file () on filename instead. */
10252 load_separate_debug_info (const char * main_filename
,
10253 struct dwarf_section
* xlink
,
10254 parse_func_type parse_func
,
10255 check_func_type check_func
,
10257 void * file ATTRIBUTE_UNUSED
)
10259 const char * separate_filename
;
10260 char * debug_filename
;
10262 size_t canon_dirlen
;
10265 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10267 warn (_("Corrupt debuglink section: %s\n"),
10268 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10272 /* Attempt to locate the separate file.
10273 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10275 canon_dir
= lrealpath (main_filename
);
10277 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10278 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10280 canon_dir
[canon_dirlen
] = '\0';
10283 #define DEBUGDIR "/lib/debug"
10285 #ifndef EXTRA_DEBUG_ROOT1
10286 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10288 #ifndef EXTRA_DEBUG_ROOT2
10289 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10292 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10294 + strlen (".debug/")
10295 #ifdef EXTRA_DEBUG_ROOT1
10296 + strlen (EXTRA_DEBUG_ROOT1
)
10298 #ifdef EXTRA_DEBUG_ROOT2
10299 + strlen (EXTRA_DEBUG_ROOT2
)
10301 + strlen (separate_filename
)
10303 if (debug_filename
== NULL
)
10305 warn (_("Out of memory"));
10310 /* First try in the current directory. */
10311 sprintf (debug_filename
, "%s", separate_filename
);
10312 if (check_func (debug_filename
, func_data
))
10315 /* Then try in a subdirectory called .debug. */
10316 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10317 if (check_func (debug_filename
, func_data
))
10320 /* Then try in the same directory as the original file. */
10321 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10322 if (check_func (debug_filename
, func_data
))
10325 /* And the .debug subdirectory of that directory. */
10326 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10327 if (check_func (debug_filename
, func_data
))
10330 #ifdef EXTRA_DEBUG_ROOT1
10331 /* Try the first extra debug file root. */
10332 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10333 if (check_func (debug_filename
, func_data
))
10336 /* Try the first extra debug file root. */
10337 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10338 if (check_func (debug_filename
, func_data
))
10342 #ifdef EXTRA_DEBUG_ROOT2
10343 /* Try the second extra debug file root. */
10344 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10345 if (check_func (debug_filename
, func_data
))
10349 /* Then try in the global debug_filename directory. */
10350 strcpy (debug_filename
, DEBUGDIR
);
10351 dirlen
= strlen (DEBUGDIR
) - 1;
10352 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10353 strcat (debug_filename
, "/");
10354 strcat (debug_filename
, (const char *) separate_filename
);
10356 if (check_func (debug_filename
, func_data
))
10359 #if HAVE_LIBDEBUGINFOD
10361 char * tmp_filename
;
10363 if (debuginfod_fetch_separate_debug_info (xlink
,
10367 /* File successfully downloaded from server, replace
10368 debug_filename with the file's path. */
10369 free (debug_filename
);
10370 debug_filename
= tmp_filename
;
10376 /* Failed to find the file. */
10377 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10378 warn (_("tried: %s\n"), debug_filename
);
10380 #ifdef EXTRA_DEBUG_ROOT2
10381 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10382 warn (_("tried: %s\n"), debug_filename
);
10385 #ifdef EXTRA_DEBUG_ROOT1
10386 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10387 warn (_("tried: %s\n"), debug_filename
);
10389 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10390 warn (_("tried: %s\n"), debug_filename
);
10393 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10394 warn (_("tried: %s\n"), debug_filename
);
10396 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10397 warn (_("tried: %s\n"), debug_filename
);
10399 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10400 warn (_("tried: %s\n"), debug_filename
);
10402 sprintf (debug_filename
, "%s", separate_filename
);
10403 warn (_("tried: %s\n"), debug_filename
);
10405 #if HAVE_LIBDEBUGINFOD
10407 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10411 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10416 free (debug_filename
);
10422 void * debug_handle
;
10424 /* Now open the file.... */
10425 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10427 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10428 free (debug_filename
);
10432 /* FIXME: We do not check to see if there are any other separate debug info
10433 files that would also match. */
10435 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10436 add_separate_debug_file (debug_filename
, debug_handle
);
10438 /* Do not free debug_filename - it might be referenced inside
10439 the structure returned by open_debug_file(). */
10440 return debug_handle
;
10443 /* Attempt to load a separate dwarf object file. */
10446 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10448 char * separate_filename
;
10449 void * separate_handle
;
10451 /* FIXME: Skip adding / if dwo_dir ends in /. */
10452 separate_filename
= concat (dir
, "/", name
, NULL
);
10453 if (separate_filename
== NULL
)
10455 warn (_("Out of memory allocating dwo filename\n"));
10459 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10461 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10462 free (separate_filename
);
10466 /* FIXME: We should check the dwo_id. */
10468 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10469 add_separate_debug_file (separate_filename
, separate_handle
);
10470 /* Note - separate_filename will be freed in free_debug_memory(). */
10471 return separate_handle
;
10474 /* Load the separate debug info file(s) attached to FILE, if any exist.
10475 Returns TRUE if any were found, FALSE otherwise.
10476 If TRUE is returned then the linked list starting at first_separate_info
10477 will be populated with open file handles. */
10480 load_separate_debug_files (void * file
, const char * filename
)
10482 /* Skip this operation if we are not interested in debug links. */
10483 if (! do_follow_links
&& ! do_debug_links
)
10486 /* See if there are any dwo links. */
10487 if (load_debug_section (str
, file
)
10488 && load_debug_section (abbrev
, file
)
10489 && load_debug_section (info
, file
))
10493 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10495 bfd_boolean introduced
= FALSE
;
10497 const char * dir
= NULL
;
10498 const char * id
= NULL
;
10500 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10502 switch (dwinfo
->type
)
10505 if (do_debug_links
)
10509 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10510 debug_displays
[info
].section
.uncompressed_name
);
10514 printf (_(" Name: %s\n"), dwinfo
->value
);
10515 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10517 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10519 printf (_(" ID: <unknown>\n"));
10523 if (do_follow_links
)
10524 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10528 dir
= dwinfo
->value
;
10532 id
= dwinfo
->value
;
10536 error (_("Unexpected DWO INFO type"));
10543 if (! do_follow_links
)
10544 /* The other debug links will be displayed by display_debug_links()
10545 so we do not need to do any further processing here. */
10548 /* FIXME: We do not check for the presence of both link sections in the same file. */
10549 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10550 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10551 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10553 if (load_debug_section (gnu_debugaltlink
, file
))
10555 Build_id_data
* build_id_data
;
10557 load_separate_debug_info (filename
,
10558 & debug_displays
[gnu_debugaltlink
].section
,
10559 parse_gnu_debugaltlink
,
10560 check_gnu_debugaltlink
,
10565 if (load_debug_section (gnu_debuglink
, file
))
10567 unsigned long crc32
;
10569 load_separate_debug_info (filename
,
10570 & debug_displays
[gnu_debuglink
].section
,
10571 parse_gnu_debuglink
,
10572 check_gnu_debuglink
,
10577 if (first_separate_info
!= NULL
)
10580 do_follow_links
= 0;
10585 free_debug_memory (void)
10591 for (i
= 0; i
< max
; i
++)
10592 free_debug_section ((enum dwarf_section_display_enum
) i
);
10594 if (debug_information
!= NULL
)
10596 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10598 for (i
= 0; i
< num_debug_info_entries
; i
++)
10600 if (!debug_information
[i
].max_loc_offsets
)
10602 free (debug_information
[i
].loc_offsets
);
10603 free (debug_information
[i
].have_frame_base
);
10605 if (!debug_information
[i
].max_range_lists
)
10606 free (debug_information
[i
].range_lists
);
10609 free (debug_information
);
10610 debug_information
= NULL
;
10611 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10615 separate_info
* next
;
10617 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10619 close_debug_file (d
->handle
);
10620 free ((void *) d
->filename
);
10624 first_separate_info
= NULL
;
10630 dwarf_select_sections_by_names (const char *names
)
10634 const char * option
;
10638 debug_dump_long_opts
;
10640 static const debug_dump_long_opts opts_table
[] =
10642 /* Please keep this table alpha- sorted. */
10643 { "Ranges", & do_debug_ranges
, 1 },
10644 { "abbrev", & do_debug_abbrevs
, 1 },
10645 { "addr", & do_debug_addr
, 1 },
10646 { "aranges", & do_debug_aranges
, 1 },
10647 { "cu_index", & do_debug_cu_index
, 1 },
10648 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10649 { "follow-links", & do_follow_links
, 1 },
10650 { "frames", & do_debug_frames
, 1 },
10651 { "frames-interp", & do_debug_frames_interp
, 1 },
10652 /* The special .gdb_index section. */
10653 { "gdb_index", & do_gdb_index
, 1 },
10654 { "info", & do_debug_info
, 1 },
10655 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10656 { "links", & do_debug_links
, 1 },
10657 { "loc", & do_debug_loc
, 1 },
10658 { "macro", & do_debug_macinfo
, 1 },
10659 { "pubnames", & do_debug_pubnames
, 1 },
10660 { "pubtypes", & do_debug_pubtypes
, 1 },
10661 /* This entry is for compatibility
10662 with earlier versions of readelf. */
10663 { "ranges", & do_debug_aranges
, 1 },
10664 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10665 { "str", & do_debug_str
, 1 },
10666 /* These trace_* sections are used by Itanium VMS. */
10667 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10668 { "trace_aranges", & do_trace_aranges
, 1 },
10669 { "trace_info", & do_trace_info
, 1 },
10678 const debug_dump_long_opts
* entry
;
10680 for (entry
= opts_table
; entry
->option
; entry
++)
10682 size_t len
= strlen (entry
->option
);
10684 if (strncmp (p
, entry
->option
, len
) == 0
10685 && (p
[len
] == ',' || p
[len
] == '\0'))
10687 * entry
->variable
|= entry
->val
;
10689 /* The --debug-dump=frames-interp option also
10690 enables the --debug-dump=frames option. */
10691 if (do_debug_frames_interp
)
10692 do_debug_frames
= 1;
10699 if (entry
->option
== NULL
)
10701 warn (_("Unrecognized debug option '%s'\n"), p
);
10702 p
= strchr (p
, ',');
10713 dwarf_select_sections_by_letters (const char *letters
)
10715 unsigned int lindex
= 0;
10717 while (letters
[lindex
])
10718 switch (letters
[lindex
++])
10720 case 'A': do_debug_addr
= 1; break;
10721 case 'a': do_debug_abbrevs
= 1; break;
10722 case 'c': do_debug_cu_index
= 1; break;
10723 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10724 case 'f': do_debug_frames
= 1; break;
10725 case 'g': do_gdb_index
= 1; break;
10726 case 'i': do_debug_info
= 1; break;
10727 case 'K': do_follow_links
= 1; break;
10728 case 'k': do_debug_links
= 1; break;
10729 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10730 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10731 case 'm': do_debug_macinfo
= 1; break;
10732 case 'o': do_debug_loc
= 1; break;
10733 case 'p': do_debug_pubnames
= 1; break;
10734 case 'R': do_debug_ranges
= 1; break;
10735 case 'r': do_debug_aranges
= 1; break;
10736 case 's': do_debug_str
= 1; break;
10737 case 'T': do_trace_aranges
= 1; break;
10738 case 't': do_debug_pubtypes
= 1; break;
10739 case 'U': do_trace_info
= 1; break;
10740 case 'u': do_trace_abbrevs
= 1; break;
10743 warn (_("Unrecognized debug option '%s'\n"), letters
);
10749 dwarf_select_sections_all (void)
10752 do_debug_abbrevs
= 1;
10753 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10754 do_debug_pubnames
= 1;
10755 do_debug_pubtypes
= 1;
10756 do_debug_aranges
= 1;
10757 do_debug_ranges
= 1;
10758 do_debug_frames
= 1;
10759 do_debug_macinfo
= 1;
10764 do_trace_abbrevs
= 1;
10765 do_trace_aranges
= 1;
10767 do_debug_cu_index
= 1;
10768 do_follow_links
= 1;
10769 do_debug_links
= 1;
10772 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10773 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10775 /* N.B. The order here must match the order in section_display_enum. */
10777 struct dwarf_section_display debug_displays
[] =
10779 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10780 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10781 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10782 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10783 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10784 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10785 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10786 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10787 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10788 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10789 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10790 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10791 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10792 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10793 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10794 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10795 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10796 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10797 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10798 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10799 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10800 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10801 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10802 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10803 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10804 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10805 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10806 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10807 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10808 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10809 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10810 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10811 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10812 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10813 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10814 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10815 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10816 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10817 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10818 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10819 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10820 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10821 /* Separate debug info files can containt their own .debug_str section,
10822 and this might be in *addition* to a .debug_str section already present
10823 in the main file. Hence we need to have two entries for .debug_str. */
10824 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10827 /* A static assertion. */
10828 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];