1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2022 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"
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>
44 #ifndef ENABLE_CHECKING
45 #define ENABLE_CHECKING 0
50 #define MAX(a, b) ((a) > (b) ? (a) : (b))
51 #define MIN(a, b) ((a) < (b) ? (a) : (b))
53 static const char *regname (unsigned int regno
, int row
);
54 static const char *regname_internal_by_table_only (unsigned int regno
);
56 static int have_frame_base
;
57 static int need_base_address
;
59 static unsigned int num_debug_info_entries
= 0;
60 static unsigned int alloc_num_debug_info_entries
= 0;
61 static debug_info
*debug_information
= NULL
;
62 /* Special value for num_debug_info_entries to indicate
63 that the .debug_info section could not be loaded/parsed. */
64 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
66 /* A .debug_info section can contain multiple links to separate
67 DWO object files. We use these structures to record these links. */
75 typedef struct dwo_info
80 struct dwo_info
* next
;
83 static dwo_info
*first_dwo_info
= NULL
;
84 static bool need_dwo_info
;
86 separate_info
* first_separate_info
= NULL
;
88 unsigned int eh_addr_size
;
93 int do_debug_pubnames
;
94 int do_debug_pubtypes
;
98 int do_debug_frames_interp
;
101 int do_debug_str_offsets
;
105 int do_trace_abbrevs
;
106 int do_trace_aranges
;
108 int do_debug_cu_index
;
111 int do_follow_links
= DEFAULT_FOR_FOLLOW_LINKS
;
112 #ifdef HAVE_LIBDEBUGINFOD
113 int use_debuginfod
= 1;
117 int dwarf_cutoff_level
= -1;
118 unsigned long dwarf_start_die
;
122 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
123 sections. For version 1 package files, each set is stored in SHNDX_POOL
124 as a zero-terminated list of section indexes comprising one set of debug
125 sections from a .dwo file. */
127 static unsigned int *shndx_pool
= NULL
;
128 static unsigned int shndx_pool_size
= 0;
129 static unsigned int shndx_pool_used
= 0;
131 /* For version 2 package files, each set contains an array of section offsets
132 and an array of section sizes, giving the offset and size of the
133 contribution from a CU or TU within one of the debug sections.
134 When displaying debug info from a package file, we need to use these
135 tables to locate the corresponding contributions to each section. */
140 uint64_t section_offsets
[DW_SECT_MAX
];
141 size_t section_sizes
[DW_SECT_MAX
];
144 static int cu_count
= 0;
145 static int tu_count
= 0;
146 static struct cu_tu_set
*cu_sets
= NULL
;
147 static struct cu_tu_set
*tu_sets
= NULL
;
149 static bool load_cu_tu_indexes (void *);
151 /* An array that indicates for a given level of CU nesting whether
152 the latest DW_AT_type seen for that level was a signed type or
154 #define MAX_CU_NESTING (1 << 8)
155 static bool level_type_signed
[MAX_CU_NESTING
];
157 /* Values for do_debug_lines. */
158 #define FLAG_DEBUG_LINES_RAW 1
159 #define FLAG_DEBUG_LINES_DECODED 2
162 size_of_encoded_value (int encoding
)
164 switch (encoding
& 0x7)
167 case 0: return eh_addr_size
;
175 get_encoded_value (unsigned char **pdata
,
177 struct dwarf_section
*section
,
180 unsigned char * data
= * pdata
;
181 unsigned int size
= size_of_encoded_value (encoding
);
184 if (data
>= end
|| size
> (size_t) (end
- data
))
186 warn (_("Encoded value extends past end of section\n"));
191 /* PR 17512: file: 002-829853-0.004. */
194 warn (_("Encoded size of %d is too large to read\n"), size
);
199 /* PR 17512: file: 1085-5603-0.004. */
202 warn (_("Encoded size of 0 is too small to read\n"));
207 if (encoding
& DW_EH_PE_signed
)
208 val
= byte_get_signed (data
, size
);
210 val
= byte_get (data
, size
);
212 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
213 val
+= section
->address
+ (data
- section
->start
);
215 * pdata
= data
+ size
;
219 /* Print a uint64_t value (typically an address, offset or length) in
220 hexadecimal format, followed by a space. The precision displayed is
221 determined by the NUM_BYTES parameter. */
224 print_hex (uint64_t value
, unsigned num_bytes
)
229 printf ("%0*" PRIx64
" ", num_bytes
* 2,
230 value
& ~(~(uint64_t) 0 << num_bytes
* 4 << num_bytes
* 4));
233 /* Like print_hex, but no trailing space. */
236 print_hex_ns (uint64_t value
, unsigned num_bytes
)
241 printf ("%0*" PRIx64
, num_bytes
* 2,
242 value
& ~(~(uint64_t) 0 << num_bytes
* 4 << num_bytes
* 4));
245 /* Print a view number in hexadecimal value, with the same width as
246 print_hex would have printed it. */
249 print_view (uint64_t value
, unsigned num_bytes
)
254 printf ("v%0*" PRIx64
" ", num_bytes
* 2 - 1,
255 value
& ~(~(uint64_t) 0 << num_bytes
* 4 << num_bytes
* 4));
258 /* Read in a LEB128 encoded value starting at address DATA.
259 If SIGN is true, return a signed LEB128 value.
260 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
261 If STATUS_RETURN is not NULL, return with bit 0 (LSB) set if the
262 terminating byte was not found and with bit 1 set if the value
263 overflows a uint64_t.
264 No bytes will be read at address END or beyond. */
267 read_leb128 (unsigned char *data
,
268 const unsigned char *const end
,
270 unsigned int *length_return
,
274 unsigned int num_read
= 0;
275 unsigned int shift
= 0;
280 unsigned char byte
= *data
++;
281 unsigned char lost
, mask
;
285 if (shift
< CHAR_BIT
* sizeof (result
))
287 result
|= ((uint64_t) (byte
& 0x7f)) << shift
;
288 /* These bits overflowed. */
289 lost
= byte
^ (result
>> shift
);
290 /* And this is the mask of possible overflow bits. */
291 mask
= 0x7f ^ ((uint64_t) 0x7f << shift
>> shift
);
299 if ((lost
& mask
) != (sign
&& (int64_t) result
< 0 ? mask
: 0))
302 if ((byte
& 0x80) == 0)
305 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
306 result
|= -((uint64_t) 1 << shift
);
311 if (length_return
!= NULL
)
312 *length_return
= num_read
;
313 if (status_return
!= NULL
)
314 *status_return
= status
;
319 /* Read AMOUNT bytes from PTR and store them in VAL.
320 Checks to make sure that the read will not reach or pass END.
321 FUNC chooses whether the value read is unsigned or signed, and may
322 be either byte_get or byte_get_signed. If INC is true, PTR is
323 incremented after reading the value.
324 This macro cannot protect against PTR values derived from user input.
325 The C standard sections 6.5.6 and 6.5.8 say attempts to do so using
326 pointers is undefined behaviour. */
327 #define SAFE_BYTE_GET_INTERNAL(VAL, PTR, AMOUNT, END, FUNC, INC) \
330 size_t amount = (AMOUNT); \
331 if (sizeof (VAL) < amount) \
333 error (ngettext ("internal error: attempt to read %d byte " \
334 "of data in to %d sized variable", \
335 "internal error: attempt to read %d bytes " \
336 "of data in to %d sized variable", \
338 (int) amount, (int) sizeof (VAL)); \
339 amount = sizeof (VAL); \
341 if (ENABLE_CHECKING) \
342 assert ((PTR) <= (END)); \
343 size_t avail = (END) - (PTR); \
346 if (amount > avail) \
351 (VAL) = (FUNC) ((PTR), amount); \
357 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
358 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, false)
360 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
361 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, true)
363 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
364 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, false)
366 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
367 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, true)
369 typedef struct State_Machine_Registers
378 unsigned char op_index
;
379 unsigned char end_sequence
;
380 /* This variable hold the number of the last entry seen
381 in the File Table. */
382 unsigned int last_file_entry
;
385 static SMR state_machine_regs
;
388 reset_state_machine (int is_stmt
)
390 state_machine_regs
.address
= 0;
391 state_machine_regs
.view
= 0;
392 state_machine_regs
.op_index
= 0;
393 state_machine_regs
.file
= 1;
394 state_machine_regs
.line
= 1;
395 state_machine_regs
.column
= 0;
396 state_machine_regs
.is_stmt
= is_stmt
;
397 state_machine_regs
.basic_block
= 0;
398 state_machine_regs
.end_sequence
= 0;
399 state_machine_regs
.last_file_entry
= 0;
402 /* Handled an extend line op.
403 Returns the number of bytes read. */
406 process_extended_line_op (unsigned char * data
,
410 unsigned char op_code
;
411 size_t len
, header_len
;
413 unsigned char *orig_data
= data
;
416 READ_ULEB (len
, data
, end
);
417 header_len
= data
- orig_data
;
419 if (len
== 0 || data
>= end
|| len
> (size_t) (end
- data
))
421 warn (_("Badly formed extended line op encountered!\n"));
427 printf (_(" Extended opcode %d: "), op_code
);
431 case DW_LNE_end_sequence
:
432 printf (_("End of Sequence\n\n"));
433 reset_state_machine (is_stmt
);
436 case DW_LNE_set_address
:
437 /* PR 17512: file: 002-100480-0.004. */
440 warn (_("Length (%zu) of DW_LNE_set_address op is too long\n"),
445 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
446 printf (_("set Address to 0x%" PRIx64
"\n"), adr
);
447 state_machine_regs
.address
= adr
;
448 state_machine_regs
.view
= 0;
449 state_machine_regs
.op_index
= 0;
452 case DW_LNE_define_file
:
453 printf (_("define new File Table entry\n"));
454 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
455 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
461 l
= strnlen ((char *) data
, end
- data
);
465 READ_ULEB (val
, data
, end
);
466 printf ("%" PRIu64
"\t", val
);
467 READ_ULEB (val
, data
, end
);
468 printf ("%" PRIu64
"\t", val
);
469 READ_ULEB (val
, data
, end
);
470 printf ("%" PRIu64
"\t", val
);
471 printf ("%.*s\n\n", (int) l
, name
);
474 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
>= end
)
475 warn (_("DW_LNE_define_file: Bad opcode length\n"));
478 case DW_LNE_set_discriminator
:
479 READ_ULEB (val
, data
, end
);
480 printf (_("set Discriminator to %" PRIu64
"\n"), val
);
484 case DW_LNE_HP_negate_is_UV_update
:
485 printf ("DW_LNE_HP_negate_is_UV_update\n");
487 case DW_LNE_HP_push_context
:
488 printf ("DW_LNE_HP_push_context\n");
490 case DW_LNE_HP_pop_context
:
491 printf ("DW_LNE_HP_pop_context\n");
493 case DW_LNE_HP_set_file_line_column
:
494 printf ("DW_LNE_HP_set_file_line_column\n");
496 case DW_LNE_HP_set_routine_name
:
497 printf ("DW_LNE_HP_set_routine_name\n");
499 case DW_LNE_HP_set_sequence
:
500 printf ("DW_LNE_HP_set_sequence\n");
502 case DW_LNE_HP_negate_post_semantics
:
503 printf ("DW_LNE_HP_negate_post_semantics\n");
505 case DW_LNE_HP_negate_function_exit
:
506 printf ("DW_LNE_HP_negate_function_exit\n");
508 case DW_LNE_HP_negate_front_end_logical
:
509 printf ("DW_LNE_HP_negate_front_end_logical\n");
511 case DW_LNE_HP_define_proc
:
512 printf ("DW_LNE_HP_define_proc\n");
514 case DW_LNE_HP_source_file_correlation
:
516 unsigned char *edata
= data
+ len
- 1;
518 printf ("DW_LNE_HP_source_file_correlation\n");
524 READ_ULEB (opc
, data
, edata
);
528 case DW_LNE_HP_SFC_formfeed
:
529 printf (" DW_LNE_HP_SFC_formfeed\n");
531 case DW_LNE_HP_SFC_set_listing_line
:
532 READ_ULEB (val
, data
, edata
);
533 printf (" DW_LNE_HP_SFC_set_listing_line (%" PRIu64
")\n",
536 case DW_LNE_HP_SFC_associate
:
537 printf (" DW_LNE_HP_SFC_associate ");
538 READ_ULEB (val
, data
, edata
);
539 printf ("(%" PRIu64
, val
);
540 READ_ULEB (val
, data
, edata
);
541 printf (",%" PRIu64
, val
);
542 READ_ULEB (val
, data
, edata
);
543 printf (",%" PRIu64
")\n", val
);
546 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
556 unsigned int rlen
= len
- 1;
558 if (op_code
>= DW_LNE_lo_user
559 /* The test against DW_LNW_hi_user is redundant due to
560 the limited range of the unsigned char data type used
562 /*&& op_code <= DW_LNE_hi_user*/)
563 printf (_("user defined: "));
565 printf (_("UNKNOWN: "));
566 printf (_("length %d ["), rlen
);
568 printf (" %02x", *data
++);
574 return len
+ header_len
;
577 static const unsigned char *
578 fetch_indirect_string (uint64_t offset
)
580 struct dwarf_section
*section
= &debug_displays
[str
].section
;
581 const unsigned char * ret
;
583 if (section
->start
== NULL
)
584 return (const unsigned char *) _("<no .debug_str section>");
586 if (offset
>= section
->size
)
588 warn (_("DW_FORM_strp offset too big: %#" PRIx64
"\n"), offset
);
589 return (const unsigned char *) _("<offset is too big>");
592 ret
= section
->start
+ offset
;
593 /* Unfortunately we cannot rely upon the .debug_str section ending with a
594 NUL byte. Since our caller is expecting to receive a well formed C
595 string we test for the lack of a terminating byte here. */
596 if (strnlen ((const char *) ret
, section
->size
- offset
)
597 == section
->size
- offset
)
598 ret
= (const unsigned char *)
599 _("<no NUL byte at end of .debug_str section>");
604 static const unsigned char *
605 fetch_indirect_line_string (uint64_t offset
)
607 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
608 const unsigned char * ret
;
610 if (section
->start
== NULL
)
611 return (const unsigned char *) _("<no .debug_line_str section>");
613 if (offset
>= section
->size
)
615 warn (_("DW_FORM_line_strp offset too big: %#" PRIx64
"\n"), offset
);
616 return (const unsigned char *) _("<offset is too big>");
619 ret
= section
->start
+ offset
;
620 /* Unfortunately we cannot rely upon the .debug_line_str section ending
621 with a NUL byte. Since our caller is expecting to receive a well formed
622 C string we test for the lack of a terminating byte here. */
623 if (strnlen ((const char *) ret
, section
->size
- offset
)
624 == section
->size
- offset
)
625 ret
= (const unsigned char *)
626 _("<no NUL byte at end of .debug_line_str section>");
632 fetch_indexed_string (uint64_t idx
,
633 struct cu_tu_set
*this_set
,
634 uint64_t offset_size
,
636 uint64_t str_offsets_base
)
638 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
639 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
640 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
641 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
642 uint64_t index_offset
;
646 if (index_section
->start
== NULL
)
647 return (dwo
? _("<no .debug_str_offsets.dwo section>")
648 : _("<no .debug_str_offsets section>"));
650 if (str_section
->start
== NULL
)
651 return (dwo
? _("<no .debug_str.dwo section>")
652 : _("<no .debug_str section>"));
654 index_offset
= idx
* offset_size
;
656 if (this_set
!= NULL
)
657 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
659 index_offset
+= str_offsets_base
;
661 if (index_offset
+ offset_size
> index_section
->size
)
663 warn (_("string index of %" PRIu64
" converts to an offset of %#" PRIx64
664 " which is too big for section %s"),
665 idx
, index_offset
, str_section
->name
);
667 return _("<string index too big>");
670 /* FIXME: If we are being paranoid then we should also check to see if
671 IDX references an entry beyond the end of the string table pointed to
672 by STR_OFFSETS_BASE. (Since there can be more than one string table
673 in a DWARF string section). */
675 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
677 str_offset
-= str_section
->address
;
678 if (str_offset
>= str_section
->size
)
680 warn (_("indirect offset too big: %#" PRIx64
"\n"), str_offset
);
681 return _("<indirect index offset is too big>");
684 ret
= (const char *) str_section
->start
+ str_offset
;
686 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
687 Since our caller is expecting to receive a well formed C string we test
688 for the lack of a terminating byte here. */
689 if (strnlen (ret
, str_section
->size
- str_offset
)
690 == str_section
->size
- str_offset
)
691 return _("<no NUL byte at end of section>");
697 fetch_indexed_addr (uint64_t offset
, uint32_t num_bytes
)
699 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
701 if (section
->start
== NULL
)
703 warn (_("Cannot fetch indexed address: the .debug_addr section is missing\n"));
707 if (offset
+ num_bytes
> section
->size
)
709 warn (_("Offset into section %s too big: %#" PRIx64
"\n"),
710 section
->name
, offset
);
714 return byte_get (section
->start
+ offset
, num_bytes
);
717 /* Fetch a value from a debug section that has been indexed by
718 something in another section (eg DW_FORM_loclistx or DW_FORM_rnglistx).
719 Returns -1 if the value could not be found. */
722 fetch_indexed_value (uint64_t idx
,
723 enum dwarf_section_display_enum sec_enum
,
724 uint64_t base_address
)
726 struct dwarf_section
*section
= &debug_displays
[sec_enum
].section
;
728 if (section
->start
== NULL
)
730 warn (_("Unable to locate %s section\n"), section
->uncompressed_name
);
734 uint32_t pointer_size
, bias
;
736 if (byte_get (section
->start
, 4) == 0xffffffff)
747 uint64_t offset
= idx
* pointer_size
;
749 /* Offsets are biased by the size of the section header
752 offset
+= base_address
;
756 if (offset
+ pointer_size
> section
->size
)
758 warn (_("Offset into section %s too big: %#" PRIx64
"\n"),
759 section
->name
, offset
);
763 return byte_get (section
->start
+ offset
, pointer_size
);
766 /* FIXME: There are better and more efficient ways to handle
767 these structures. For now though, I just want something that
768 is simple to implement. */
769 /* Records a single attribute in an abbrev. */
770 typedef struct abbrev_attr
772 unsigned long attribute
;
774 int64_t implicit_const
;
775 struct abbrev_attr
*next
;
779 /* Records a single abbrev. */
780 typedef struct abbrev_entry
782 unsigned long number
;
785 struct abbrev_attr
* first_attr
;
786 struct abbrev_attr
* last_attr
;
787 struct abbrev_entry
* next
;
791 /* Records a set of abbreviations. */
792 typedef struct abbrev_list
794 abbrev_entry
* first_abbrev
;
795 abbrev_entry
* last_abbrev
;
797 struct abbrev_list
* next
;
798 unsigned char * start_of_next_abbrevs
;
802 /* Records all the abbrevs found so far. */
803 static struct abbrev_list
* abbrev_lists
= NULL
;
805 typedef struct abbrev_map
812 /* Maps between CU offsets and abbrev sets. */
813 static abbrev_map
* cu_abbrev_map
= NULL
;
814 static unsigned long num_abbrev_map_entries
= 0;
815 static unsigned long next_free_abbrev_map_entry
= 0;
817 #define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
818 #define ABBREV_MAP_ENTRIES_INCREMENT 8
821 record_abbrev_list_for_cu (uint64_t start
, uint64_t end
,
822 abbrev_list
*list
, abbrev_list
*free_list
)
824 if (free_list
!= NULL
)
826 list
->next
= abbrev_lists
;
830 if (cu_abbrev_map
== NULL
)
832 num_abbrev_map_entries
= INITIAL_NUM_ABBREV_MAP_ENTRIES
;
833 cu_abbrev_map
= xmalloc (num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
835 else if (next_free_abbrev_map_entry
== num_abbrev_map_entries
)
837 num_abbrev_map_entries
+= ABBREV_MAP_ENTRIES_INCREMENT
;
838 cu_abbrev_map
= xrealloc (cu_abbrev_map
, num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
841 cu_abbrev_map
[next_free_abbrev_map_entry
].start
= start
;
842 cu_abbrev_map
[next_free_abbrev_map_entry
].end
= end
;
843 cu_abbrev_map
[next_free_abbrev_map_entry
].list
= list
;
844 next_free_abbrev_map_entry
++;
848 free_abbrev_list (abbrev_list
*list
)
850 abbrev_entry
*abbrv
= list
->first_abbrev
;
854 abbrev_attr
*attr
= abbrv
->first_attr
;
858 abbrev_attr
*next_attr
= attr
->next
;
863 abbrev_entry
*next_abbrev
= abbrv
->next
;
868 abbrev_list
*next
= list
->next
;
874 free_all_abbrevs (void)
877 abbrev_lists
= free_abbrev_list (abbrev_lists
);
879 free (cu_abbrev_map
);
880 cu_abbrev_map
= NULL
;
881 next_free_abbrev_map_entry
= 0;
885 find_abbrev_list_by_raw_abbrev (unsigned char *raw
)
889 for (list
= abbrev_lists
; list
!= NULL
; list
= list
->next
)
890 if (list
->raw
== raw
)
896 /* Find the abbreviation map for the CU that includes OFFSET.
897 OFFSET is an absolute offset from the start of the .debug_info section. */
898 /* FIXME: This function is going to slow down readelf & objdump.
899 Not caching abbrevs is likely the answer. */
902 find_abbrev_map_by_offset (uint64_t offset
)
906 for (i
= 0; i
< next_free_abbrev_map_entry
; i
++)
907 if (cu_abbrev_map
[i
].start
<= offset
908 && cu_abbrev_map
[i
].end
> offset
)
909 return cu_abbrev_map
+ i
;
915 add_abbrev (unsigned long number
,
920 abbrev_entry
* entry
;
922 entry
= (abbrev_entry
*) xmalloc (sizeof (*entry
));
924 entry
->number
= number
;
926 entry
->children
= children
;
927 entry
->first_attr
= NULL
;
928 entry
->last_attr
= NULL
;
931 assert (list
!= NULL
);
933 if (list
->first_abbrev
== NULL
)
934 list
->first_abbrev
= entry
;
936 list
->last_abbrev
->next
= entry
;
938 list
->last_abbrev
= entry
;
942 add_abbrev_attr (unsigned long attribute
,
944 int64_t implicit_const
,
949 attr
= (abbrev_attr
*) xmalloc (sizeof (*attr
));
951 attr
->attribute
= attribute
;
953 attr
->implicit_const
= implicit_const
;
956 assert (list
!= NULL
&& list
->last_abbrev
!= NULL
);
958 if (list
->last_abbrev
->first_attr
== NULL
)
959 list
->last_abbrev
->first_attr
= attr
;
961 list
->last_abbrev
->last_attr
->next
= attr
;
963 list
->last_abbrev
->last_attr
= attr
;
966 /* Return processed (partial) contents of a .debug_abbrev section.
967 Returns NULL on errors. */
970 process_abbrev_set (struct dwarf_section
*section
,
971 unsigned char *start
,
974 abbrev_list
*list
= xmalloc (sizeof (*list
));
975 list
->first_abbrev
= NULL
;
976 list
->last_abbrev
= NULL
;
983 unsigned long attribute
;
986 READ_ULEB (entry
, start
, end
);
988 /* A single zero is supposed to end the set according
989 to the standard. If there's more, then signal that to
991 if (start
== end
|| entry
== 0)
994 list
->start_of_next_abbrevs
= start
!= end
? start
: NULL
;
998 READ_ULEB (tag
, start
, end
);
1005 children
= *start
++;
1007 add_abbrev (entry
, tag
, children
, list
);
1012 /* Initialize it due to a false compiler warning. */
1013 int64_t implicit_const
= -1;
1015 READ_ULEB (attribute
, start
, end
);
1019 READ_ULEB (form
, start
, end
);
1023 if (form
== DW_FORM_implicit_const
)
1025 READ_SLEB (implicit_const
, start
, end
);
1030 add_abbrev_attr (attribute
, form
, implicit_const
, list
);
1032 while (attribute
!= 0);
1035 /* Report the missing single zero which ends the section. */
1036 error (_("%s section not zero terminated\n"), section
->name
);
1042 /* Return a sequence of abbrevs in SECTION starting at ABBREV_BASE
1043 plus ABBREV_OFFSET and finishing at ABBREV_BASE + ABBREV_SIZE.
1044 If FREE_LIST is non-NULL search the already decoded abbrevs on
1045 abbrev_lists first and if found set *FREE_LIST to NULL. If
1046 searching doesn't find a matching abbrev, set *FREE_LIST to the
1047 newly allocated list. If FREE_LIST is NULL, no search is done and
1048 the returned abbrev_list is always newly allocated. */
1050 static abbrev_list
*
1051 find_and_process_abbrev_set (struct dwarf_section
*section
,
1052 uint64_t abbrev_base
,
1053 uint64_t abbrev_size
,
1054 uint64_t abbrev_offset
,
1055 abbrev_list
**free_list
)
1060 if (abbrev_base
>= section
->size
1061 || abbrev_size
> section
->size
- abbrev_base
)
1063 /* PR 17531: file:4bcd9ce9. */
1064 warn (_("Debug info is corrupted, abbrev size (%#" PRIx64
")"
1065 " is larger than abbrev section size (%#" PRIx64
")\n"),
1066 abbrev_base
+ abbrev_size
, section
->size
);
1069 if (abbrev_offset
>= abbrev_size
)
1071 warn (_("Debug info is corrupted, abbrev offset (%#" PRIx64
")"
1072 " is larger than abbrev section size (%#" PRIx64
")\n"),
1073 abbrev_offset
, abbrev_size
);
1077 unsigned char *start
= section
->start
+ abbrev_base
+ abbrev_offset
;
1078 unsigned char *end
= section
->start
+ abbrev_base
+ abbrev_size
;
1079 abbrev_list
*list
= NULL
;
1081 list
= find_abbrev_list_by_raw_abbrev (start
);
1084 list
= process_abbrev_set (section
, start
, end
);
1092 get_TAG_name (uint64_t tag
)
1094 const char *name
= NULL
;
1096 if ((unsigned int) tag
== tag
)
1097 name
= get_DW_TAG_name ((unsigned int) tag
);
1100 static char buffer
[100];
1102 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1103 snprintf (buffer
, sizeof (buffer
),
1104 _("User TAG value: %#" PRIx64
), tag
);
1106 snprintf (buffer
, sizeof (buffer
),
1107 _("Unknown TAG value: %#" PRIx64
), tag
);
1115 get_FORM_name (unsigned long form
)
1117 const char *name
= NULL
;
1120 return "DW_FORM value: 0";
1122 if ((unsigned int) form
== form
)
1123 name
= get_DW_FORM_name ((unsigned int) form
);
1126 static char buffer
[100];
1128 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1136 get_IDX_name (unsigned long idx
)
1138 const char *name
= NULL
;
1140 if ((unsigned int) idx
== idx
)
1141 name
= get_DW_IDX_name ((unsigned int) idx
);
1144 static char buffer
[100];
1146 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1153 static unsigned char *
1154 display_block (unsigned char *data
,
1156 const unsigned char * const end
, char delimiter
)
1160 printf (_("%c%" PRIu64
" byte block: "), delimiter
, length
);
1162 return (unsigned char *) end
;
1164 maxlen
= end
- data
;
1165 length
= length
> maxlen
? maxlen
: length
;
1168 printf ("%" PRIx64
" ", byte_get (data
++, 1));
1174 decode_location_expression (unsigned char * data
,
1175 unsigned int pointer_size
,
1176 unsigned int offset_size
,
1180 struct dwarf_section
* section
)
1185 unsigned char *end
= data
+ length
;
1186 int need_frame_base
= 0;
1195 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1196 printf ("DW_OP_addr: %" PRIx64
, uvalue
);
1199 printf ("DW_OP_deref");
1202 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1203 printf ("DW_OP_const1u: %" PRIu64
, uvalue
);
1206 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1207 printf ("DW_OP_const1s: %" PRId64
, svalue
);
1210 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1211 printf ("DW_OP_const2u: %" PRIu64
, uvalue
);
1214 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1215 printf ("DW_OP_const2s: %" PRId64
, svalue
);
1218 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1219 printf ("DW_OP_const4u: %" PRIu64
, uvalue
);
1222 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1223 printf ("DW_OP_const4s: %" PRId64
, svalue
);
1226 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
1227 printf ("DW_OP_const8u: %" PRIu64
, uvalue
);
1230 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 8, end
);
1231 printf ("DW_OP_const8s: %" PRId64
, svalue
);
1234 READ_ULEB (uvalue
, data
, end
);
1235 printf ("DW_OP_constu: %" PRIu64
, uvalue
);
1238 READ_SLEB (svalue
, data
, end
);
1239 printf ("DW_OP_consts: %" PRId64
, svalue
);
1242 printf ("DW_OP_dup");
1245 printf ("DW_OP_drop");
1248 printf ("DW_OP_over");
1251 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1252 printf ("DW_OP_pick: %" PRIu64
, uvalue
);
1255 printf ("DW_OP_swap");
1258 printf ("DW_OP_rot");
1261 printf ("DW_OP_xderef");
1264 printf ("DW_OP_abs");
1267 printf ("DW_OP_and");
1270 printf ("DW_OP_div");
1273 printf ("DW_OP_minus");
1276 printf ("DW_OP_mod");
1279 printf ("DW_OP_mul");
1282 printf ("DW_OP_neg");
1285 printf ("DW_OP_not");
1288 printf ("DW_OP_or");
1291 printf ("DW_OP_plus");
1293 case DW_OP_plus_uconst
:
1294 READ_ULEB (uvalue
, data
, end
);
1295 printf ("DW_OP_plus_uconst: %" PRIu64
, uvalue
);
1298 printf ("DW_OP_shl");
1301 printf ("DW_OP_shr");
1304 printf ("DW_OP_shra");
1307 printf ("DW_OP_xor");
1310 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1311 printf ("DW_OP_bra: %" PRId64
, svalue
);
1314 printf ("DW_OP_eq");
1317 printf ("DW_OP_ge");
1320 printf ("DW_OP_gt");
1323 printf ("DW_OP_le");
1326 printf ("DW_OP_lt");
1329 printf ("DW_OP_ne");
1332 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1333 printf ("DW_OP_skip: %" PRId64
, svalue
);
1368 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1403 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1404 regname (op
- DW_OP_reg0
, 1));
1439 READ_SLEB (svalue
, data
, end
);
1440 printf ("DW_OP_breg%d (%s): %" PRId64
,
1441 op
- DW_OP_breg0
, regname (op
- DW_OP_breg0
, 1), svalue
);
1445 READ_ULEB (uvalue
, data
, end
);
1446 printf ("DW_OP_regx: %" PRIu64
" (%s)",
1447 uvalue
, regname (uvalue
, 1));
1450 need_frame_base
= 1;
1451 READ_SLEB (svalue
, data
, end
);
1452 printf ("DW_OP_fbreg: %" PRId64
, svalue
);
1455 READ_ULEB (uvalue
, data
, end
);
1456 READ_SLEB (svalue
, data
, end
);
1457 printf ("DW_OP_bregx: %" PRIu64
" (%s) %" PRId64
,
1458 uvalue
, regname (uvalue
, 1), svalue
);
1461 READ_ULEB (uvalue
, data
, end
);
1462 printf ("DW_OP_piece: %" PRIu64
, uvalue
);
1464 case DW_OP_deref_size
:
1465 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1466 printf ("DW_OP_deref_size: %" PRIu64
, uvalue
);
1468 case DW_OP_xderef_size
:
1469 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1470 printf ("DW_OP_xderef_size: %" PRIu64
, uvalue
);
1473 printf ("DW_OP_nop");
1476 /* DWARF 3 extensions. */
1477 case DW_OP_push_object_address
:
1478 printf ("DW_OP_push_object_address");
1481 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1482 this ought to be an 8-byte wide computation. */
1483 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1484 printf ("DW_OP_call2: <0x%" PRIx64
">", svalue
+ cu_offset
);
1487 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1488 this ought to be an 8-byte wide computation. */
1489 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1490 printf ("DW_OP_call4: <0x%" PRIx64
">", svalue
+ cu_offset
);
1492 case DW_OP_call_ref
:
1493 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1494 this ought to be an 8-byte wide computation. */
1495 if (dwarf_version
== -1)
1497 printf (_("(DW_OP_call_ref in frame info)"));
1498 /* No way to tell where the next op is, so just bail. */
1499 return need_frame_base
;
1501 if (dwarf_version
== 2)
1503 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1507 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1509 printf ("DW_OP_call_ref: <0x%" PRIx64
">", uvalue
);
1511 case DW_OP_form_tls_address
:
1512 printf ("DW_OP_form_tls_address");
1514 case DW_OP_call_frame_cfa
:
1515 printf ("DW_OP_call_frame_cfa");
1517 case DW_OP_bit_piece
:
1518 printf ("DW_OP_bit_piece: ");
1519 READ_ULEB (uvalue
, data
, end
);
1520 printf (_("size: %" PRIu64
" "), uvalue
);
1521 READ_ULEB (uvalue
, data
, end
);
1522 printf (_("offset: %" PRIu64
" "), uvalue
);
1525 /* DWARF 4 extensions. */
1526 case DW_OP_stack_value
:
1527 printf ("DW_OP_stack_value");
1530 case DW_OP_implicit_value
:
1531 printf ("DW_OP_implicit_value");
1532 READ_ULEB (uvalue
, data
, end
);
1533 data
= display_block (data
, uvalue
, end
, ' ');
1536 /* GNU extensions. */
1537 case DW_OP_GNU_push_tls_address
:
1538 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1540 case DW_OP_GNU_uninit
:
1541 printf ("DW_OP_GNU_uninit");
1542 /* FIXME: Is there data associated with this OP ? */
1544 case DW_OP_GNU_encoded_addr
:
1551 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1553 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1554 print_hex (addr
, pointer_size
);
1557 case DW_OP_implicit_pointer
:
1558 case DW_OP_GNU_implicit_pointer
:
1559 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1560 this ought to be an 8-byte wide computation. */
1561 if (dwarf_version
== -1)
1563 printf (_("(%s in frame info)"),
1564 (op
== DW_OP_implicit_pointer
1565 ? "DW_OP_implicit_pointer"
1566 : "DW_OP_GNU_implicit_pointer"));
1567 /* No way to tell where the next op is, so just bail. */
1568 return need_frame_base
;
1570 if (dwarf_version
== 2)
1572 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1576 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1578 READ_SLEB (svalue
, data
, end
);
1579 printf ("%s: <0x%" PRIx64
"> %" PRId64
,
1580 (op
== DW_OP_implicit_pointer
1581 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1584 case DW_OP_entry_value
:
1585 case DW_OP_GNU_entry_value
:
1586 READ_ULEB (uvalue
, data
, end
);
1587 /* PR 17531: file: 0cc9cd00. */
1588 if (uvalue
> (size_t) (end
- data
))
1589 uvalue
= end
- data
;
1590 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1591 : "DW_OP_GNU_entry_value"));
1592 if (decode_location_expression (data
, pointer_size
, offset_size
,
1593 dwarf_version
, uvalue
,
1594 cu_offset
, section
))
1595 need_frame_base
= 1;
1599 case DW_OP_const_type
:
1600 case DW_OP_GNU_const_type
:
1601 READ_ULEB (uvalue
, data
, end
);
1602 printf ("%s: <0x%" PRIx64
"> ",
1603 (op
== DW_OP_const_type
? "DW_OP_const_type"
1604 : "DW_OP_GNU_const_type"),
1605 cu_offset
+ uvalue
);
1606 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1607 data
= display_block (data
, uvalue
, end
, ' ');
1609 case DW_OP_regval_type
:
1610 case DW_OP_GNU_regval_type
:
1611 READ_ULEB (uvalue
, data
, end
);
1612 printf ("%s: %" PRIu64
" (%s)",
1613 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1614 : "DW_OP_GNU_regval_type"),
1615 uvalue
, regname (uvalue
, 1));
1616 READ_ULEB (uvalue
, data
, end
);
1617 printf (" <0x%" PRIx64
">", cu_offset
+ uvalue
);
1619 case DW_OP_deref_type
:
1620 case DW_OP_GNU_deref_type
:
1621 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1622 printf ("%s: %" PRId64
,
1623 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1624 : "DW_OP_GNU_deref_type"),
1626 READ_ULEB (uvalue
, data
, end
);
1627 printf (" <0x%" PRIx64
">", cu_offset
+ uvalue
);
1630 case DW_OP_GNU_convert
:
1631 READ_ULEB (uvalue
, data
, end
);
1632 printf ("%s <0x%" PRIx64
">",
1633 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1634 uvalue
? cu_offset
+ uvalue
: uvalue
);
1636 case DW_OP_reinterpret
:
1637 case DW_OP_GNU_reinterpret
:
1638 READ_ULEB (uvalue
, data
, end
);
1639 printf ("%s <0x%" PRIx64
">",
1640 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1641 : "DW_OP_GNU_reinterpret"),
1642 uvalue
? cu_offset
+ uvalue
: uvalue
);
1644 case DW_OP_GNU_parameter_ref
:
1645 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1646 printf ("DW_OP_GNU_parameter_ref: <0x%" PRIx64
">",
1647 cu_offset
+ uvalue
);
1650 READ_ULEB (uvalue
, data
, end
);
1651 printf ("DW_OP_addrx <0x%" PRIx64
">", uvalue
);
1653 case DW_OP_GNU_addr_index
:
1654 READ_ULEB (uvalue
, data
, end
);
1655 printf ("DW_OP_GNU_addr_index <0x%" PRIx64
">", uvalue
);
1657 case DW_OP_GNU_const_index
:
1658 READ_ULEB (uvalue
, data
, end
);
1659 printf ("DW_OP_GNU_const_index <0x%" PRIx64
">", uvalue
);
1661 case DW_OP_GNU_variable_value
:
1662 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1663 this ought to be an 8-byte wide computation. */
1664 if (dwarf_version
== -1)
1666 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1667 /* No way to tell where the next op is, so just bail. */
1668 return need_frame_base
;
1670 if (dwarf_version
== 2)
1672 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1676 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1678 printf ("DW_OP_GNU_variable_value: <0x%" PRIx64
">", uvalue
);
1681 /* HP extensions. */
1682 case DW_OP_HP_is_value
:
1683 printf ("DW_OP_HP_is_value");
1684 /* FIXME: Is there data associated with this OP ? */
1686 case DW_OP_HP_fltconst4
:
1687 printf ("DW_OP_HP_fltconst4");
1688 /* FIXME: Is there data associated with this OP ? */
1690 case DW_OP_HP_fltconst8
:
1691 printf ("DW_OP_HP_fltconst8");
1692 /* FIXME: Is there data associated with this OP ? */
1694 case DW_OP_HP_mod_range
:
1695 printf ("DW_OP_HP_mod_range");
1696 /* FIXME: Is there data associated with this OP ? */
1698 case DW_OP_HP_unmod_range
:
1699 printf ("DW_OP_HP_unmod_range");
1700 /* FIXME: Is there data associated with this OP ? */
1703 printf ("DW_OP_HP_tls");
1704 /* FIXME: Is there data associated with this OP ? */
1707 /* PGI (STMicroelectronics) extensions. */
1708 case DW_OP_PGI_omp_thread_num
:
1709 /* Pushes the thread number for the current thread as it would be
1710 returned by the standard OpenMP library function:
1711 omp_get_thread_num(). The "current thread" is the thread for
1712 which the expression is being evaluated. */
1713 printf ("DW_OP_PGI_omp_thread_num");
1717 if (op
>= DW_OP_lo_user
1718 && op
<= DW_OP_hi_user
)
1719 printf (_("(User defined location op 0x%x)"), op
);
1721 printf (_("(Unknown location op 0x%x)"), op
);
1722 /* No way to tell where the next op is, so just bail. */
1723 return need_frame_base
;
1726 /* Separate the ops. */
1731 return need_frame_base
;
1734 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1735 This is used for DWARF package files. */
1737 static struct cu_tu_set
*
1738 find_cu_tu_set_v2 (uint64_t cu_offset
, int do_types
)
1740 struct cu_tu_set
*p
;
1742 unsigned int dw_sect
;
1748 dw_sect
= DW_SECT_TYPES
;
1754 dw_sect
= DW_SECT_INFO
;
1758 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1767 fetch_alt_indirect_string (uint64_t offset
)
1771 if (! do_follow_links
)
1774 if (first_separate_info
== NULL
)
1775 return _("<no links available>");
1777 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1779 struct dwarf_section
* section
;
1782 if (! load_debug_section (separate_debug_str
, i
->handle
))
1785 section
= &debug_displays
[separate_debug_str
].section
;
1787 if (section
->start
== NULL
)
1790 if (offset
>= section
->size
)
1793 ret
= (const char *) (section
->start
+ offset
);
1794 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1795 NUL byte. Since our caller is expecting to receive a well formed C
1796 string we test for the lack of a terminating byte here. */
1797 if (strnlen ((const char *) ret
, section
->size
- offset
)
1798 == section
->size
- offset
)
1799 return _("<no NUL byte at end of alt .debug_str section>");
1804 warn (_("DW_FORM_GNU_strp_alt offset (%#" PRIx64
")"
1805 " too big or no string sections available\n"), offset
);
1806 return _("<offset is too big>");
1810 get_AT_name (unsigned long attribute
)
1815 return "DW_AT value: 0";
1817 /* One value is shared by the MIPS and HP extensions: */
1818 if (attribute
== DW_AT_MIPS_fde
)
1819 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1821 name
= get_DW_AT_name (attribute
);
1825 static char buffer
[100];
1827 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1836 add_dwo_info (const char * value
, uint64_t cu_offset
, dwo_type type
)
1838 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1840 dwinfo
->type
= type
;
1841 dwinfo
->value
= value
;
1842 dwinfo
->cu_offset
= cu_offset
;
1843 dwinfo
->next
= first_dwo_info
;
1844 first_dwo_info
= dwinfo
;
1848 add_dwo_name (const char * name
, uint64_t cu_offset
)
1850 add_dwo_info (name
, cu_offset
, DWO_NAME
);
1854 add_dwo_dir (const char * dir
, uint64_t cu_offset
)
1856 add_dwo_info (dir
, cu_offset
, DWO_DIR
);
1860 add_dwo_id (const char * id
, uint64_t cu_offset
)
1862 add_dwo_info (id
, cu_offset
, DWO_ID
);
1866 free_dwo_info (void)
1871 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1873 next
= dwinfo
->next
;
1876 first_dwo_info
= NULL
;
1879 /* Ensure that START + UVALUE is less than END.
1880 Return an adjusted UVALUE if necessary to ensure this relationship. */
1882 static inline uint64_t
1883 check_uvalue (const unsigned char *start
,
1885 const unsigned char *end
)
1887 uint64_t max_uvalue
= end
- start
;
1889 /* See PR 17512: file: 008-103549-0.001:0.1.
1890 and PR 24829 for examples of where these tests are triggered. */
1891 if (uvalue
> max_uvalue
)
1893 warn (_("Corrupt attribute block length: %#" PRIx64
"\n"), uvalue
);
1894 uvalue
= max_uvalue
;
1900 static unsigned char *
1901 skip_attr_bytes (unsigned long form
,
1902 unsigned char *data
,
1904 uint64_t pointer_size
,
1905 uint64_t offset_size
,
1907 uint64_t *value_return
)
1910 uint64_t uvalue
= 0;
1917 case DW_FORM_ref_addr
:
1918 if (dwarf_version
== 2)
1919 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1920 else if (dwarf_version
> 2)
1921 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1927 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1931 case DW_FORM_line_strp
:
1932 case DW_FORM_sec_offset
:
1933 case DW_FORM_GNU_ref_alt
:
1934 case DW_FORM_GNU_strp_alt
:
1935 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1938 case DW_FORM_flag_present
:
1946 case DW_FORM_addrx1
:
1947 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1951 case DW_FORM_addrx3
:
1952 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
1958 case DW_FORM_addrx2
:
1959 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1965 case DW_FORM_addrx4
:
1966 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1970 READ_SLEB (svalue
, data
, end
);
1974 case DW_FORM_ref_udata
:
1976 case DW_FORM_GNU_str_index
:
1978 case DW_FORM_GNU_addr_index
:
1980 case DW_FORM_loclistx
:
1981 case DW_FORM_rnglistx
:
1982 READ_ULEB (uvalue
, data
, end
);
1986 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
1990 case DW_FORM_ref_sig8
:
1994 case DW_FORM_data16
:
1998 case DW_FORM_string
:
1999 inc
= strnlen ((char *) data
, end
- data
) + 1;
2003 case DW_FORM_exprloc
:
2004 READ_ULEB (uvalue
, data
, end
);
2008 case DW_FORM_block1
:
2009 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2013 case DW_FORM_block2
:
2014 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2018 case DW_FORM_block4
:
2019 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2023 case DW_FORM_indirect
:
2024 READ_ULEB (form
, data
, end
);
2025 if (form
== DW_FORM_implicit_const
)
2026 SKIP_ULEB (data
, end
);
2027 return skip_attr_bytes (form
, data
, end
, pointer_size
, offset_size
,
2028 dwarf_version
, value_return
);
2034 * value_return
= uvalue
;
2035 if (inc
<= (size_t) (end
- data
))
2042 /* Given form FORM with value UVALUE, locate and return the abbreviation
2043 associated with it. */
2045 static abbrev_entry
*
2046 get_type_abbrev_from_form (unsigned long form
,
2047 unsigned long uvalue
,
2049 unsigned char *cu_end
,
2050 const struct dwarf_section
*section
,
2051 unsigned long *abbrev_num_return
,
2052 unsigned char **data_return
,
2053 abbrev_map
**map_return
)
2055 unsigned long abbrev_number
;
2057 abbrev_entry
* entry
;
2058 unsigned char * data
;
2060 if (abbrev_num_return
!= NULL
)
2061 * abbrev_num_return
= 0;
2062 if (data_return
!= NULL
)
2063 * data_return
= NULL
;
2067 case DW_FORM_GNU_ref_alt
:
2068 case DW_FORM_ref_sig8
:
2069 /* FIXME: We are unable to handle this form at the moment. */
2072 case DW_FORM_ref_addr
:
2073 if (uvalue
>= section
->size
)
2075 warn (_("Unable to resolve ref_addr form: uvalue %lx "
2076 "> section size %" PRIx64
" (%s)\n"),
2077 uvalue
, section
->size
, section
->name
);
2082 case DW_FORM_ref_sup4
:
2083 case DW_FORM_ref_sup8
:
2090 case DW_FORM_ref_udata
:
2091 if (uvalue
+ cu_offset
< uvalue
2092 || uvalue
+ cu_offset
> (size_t) (cu_end
- section
->start
))
2094 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %" PRIx64
2095 " > CU size %tx\n"),
2096 uvalue
, cu_offset
, cu_end
- section
->start
);
2099 uvalue
+= cu_offset
;
2102 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2105 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2109 data
= (unsigned char *) section
->start
+ uvalue
;
2110 map
= find_abbrev_map_by_offset (uvalue
);
2114 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2117 if (map
->list
== NULL
)
2119 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2123 if (map_return
!= NULL
)
2125 if (form
== DW_FORM_ref_addr
)
2131 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2133 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2134 if (entry
->number
== abbrev_number
)
2137 if (abbrev_num_return
!= NULL
)
2138 * abbrev_num_return
= abbrev_number
;
2140 if (data_return
!= NULL
)
2141 * data_return
= data
;
2144 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2149 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2150 can be determined to be a signed type. The data for ENTRY can be
2151 found starting at DATA. */
2154 get_type_signedness (abbrev_entry
*entry
,
2155 const struct dwarf_section
*section
,
2156 unsigned char *data
,
2159 uint64_t pointer_size
,
2160 uint64_t offset_size
,
2163 unsigned int nesting
)
2167 * is_signed
= false;
2169 #define MAX_NESTING 20
2170 if (nesting
> MAX_NESTING
)
2172 /* FIXME: Warn - or is this expected ?
2173 NB/ We need to avoid infinite recursion. */
2177 for (attr
= entry
->first_attr
;
2178 attr
!= NULL
&& attr
->attribute
;
2181 unsigned char * orig_data
= data
;
2182 uint64_t uvalue
= 0;
2184 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2185 offset_size
, dwarf_version
, & uvalue
);
2189 switch (attr
->attribute
)
2191 case DW_AT_linkage_name
:
2195 if (attr
->form
== DW_FORM_strp
)
2196 printf (", %s", fetch_indirect_string (uvalue
));
2197 else if (attr
->form
== DW_FORM_string
)
2198 printf (", %.*s", (int) (end
- orig_data
), orig_data
);
2205 abbrev_entry
*type_abbrev
;
2206 unsigned char *type_data
;
2209 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2214 NULL
/* abbrev num return */,
2217 if (type_abbrev
== NULL
)
2220 get_type_signedness (type_abbrev
, section
, type_data
,
2221 map
? section
->start
+ map
->end
: end
,
2222 map
? map
->start
: cu_offset
,
2223 pointer_size
, offset_size
, dwarf_version
,
2224 is_signed
, nesting
+ 1);
2228 case DW_AT_encoding
:
2229 /* Determine signness. */
2232 case DW_ATE_address
:
2233 /* FIXME - some architectures have signed addresses. */
2234 case DW_ATE_boolean
:
2235 case DW_ATE_unsigned
:
2236 case DW_ATE_unsigned_char
:
2237 case DW_ATE_unsigned_fixed
:
2238 * is_signed
= false;
2242 case DW_ATE_complex_float
:
2245 case DW_ATE_signed_char
:
2246 case DW_ATE_imaginary_float
:
2247 case DW_ATE_decimal_float
:
2248 case DW_ATE_signed_fixed
:
2258 read_and_print_leb128 (unsigned char *data
,
2259 unsigned int *bytes_read
,
2260 unsigned const char *end
,
2264 uint64_t val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2266 report_leb_status (status
);
2268 printf ("%" PRId64
, val
);
2270 printf ("%" PRIu64
, val
);
2274 display_discr_list (unsigned long form
,
2276 unsigned char *data
,
2279 unsigned char *end
= data
;
2283 printf ("[default]");
2290 case DW_FORM_block1
:
2291 case DW_FORM_block2
:
2292 case DW_FORM_block4
:
2293 /* Move data pointer back to the start of the byte array. */
2297 printf ("<corrupt>\n");
2298 warn (_("corrupt discr_list - not using a block form\n"));
2304 printf ("<corrupt>\n");
2305 warn (_("corrupt discr_list - block not long enough\n"));
2309 bool is_signed
= (level
> 0 && level
<= MAX_CU_NESTING
2310 ? level_type_signed
[level
- 1] : false);
2315 unsigned char discriminant
;
2316 unsigned int bytes_read
;
2318 SAFE_BYTE_GET_AND_INC (discriminant
, data
, 1, end
);
2320 switch (discriminant
)
2324 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2330 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2334 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2339 printf ("<corrupt>\n");
2340 warn (_("corrupt discr_list - unrecognized discriminant byte %#x\n"),
2350 printf (")(signed)");
2352 printf (")(unsigned)");
2355 static unsigned char *
2356 read_and_display_attr_value (unsigned long attribute
,
2358 int64_t implicit_const
,
2359 unsigned char *start
,
2360 unsigned char *data
,
2363 uint64_t pointer_size
,
2364 uint64_t offset_size
,
2366 debug_info
*debug_info_p
,
2368 struct dwarf_section
*section
,
2369 struct cu_tu_set
*this_set
,
2374 uint64_t uvalue
= 0;
2375 uint64_t uvalue_hi
= 0;
2376 unsigned char *block_start
= NULL
;
2377 unsigned char *orig_data
= data
;
2379 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2381 warn (_("Corrupt attribute\n"));
2385 if (do_wide
&& ! do_loc
)
2387 /* PR 26847: Display the name of the form. */
2388 const char * name
= get_FORM_name (form
);
2390 /* For convenience we skip the DW_FORM_ prefix to the name. */
2392 name
+= 8; /* strlen ("DW_FORM_") */
2393 printf ("%c(%s)", delimiter
, name
);
2398 case DW_FORM_ref_addr
:
2399 if (dwarf_version
== 2)
2400 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2401 else if (dwarf_version
> 2)
2402 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2404 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2408 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2411 case DW_FORM_strp_sup
:
2413 case DW_FORM_line_strp
:
2414 case DW_FORM_sec_offset
:
2415 case DW_FORM_GNU_ref_alt
:
2416 case DW_FORM_GNU_strp_alt
:
2417 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2420 case DW_FORM_flag_present
:
2428 case DW_FORM_addrx1
:
2429 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2435 case DW_FORM_addrx2
:
2436 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2440 case DW_FORM_addrx3
:
2441 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2444 case DW_FORM_ref_sup4
:
2448 case DW_FORM_addrx4
:
2449 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2452 case DW_FORM_ref_sup8
:
2455 case DW_FORM_ref_sig8
:
2456 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2459 case DW_FORM_data16
:
2460 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2461 SAFE_BYTE_GET_AND_INC (uvalue_hi
, data
, 8, end
);
2462 if (byte_get
!= byte_get_little_endian
)
2464 uint64_t utmp
= uvalue
;
2471 READ_SLEB (svalue
, data
, end
);
2475 case DW_FORM_GNU_str_index
:
2477 case DW_FORM_ref_udata
:
2479 case DW_FORM_GNU_addr_index
:
2481 case DW_FORM_loclistx
:
2482 case DW_FORM_rnglistx
:
2483 READ_ULEB (uvalue
, data
, end
);
2486 case DW_FORM_indirect
:
2487 READ_ULEB (form
, data
, end
);
2489 printf ("%c%s", delimiter
, get_FORM_name (form
));
2490 if (form
== DW_FORM_implicit_const
)
2491 READ_SLEB (implicit_const
, data
, end
);
2492 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2494 cu_offset
, pointer_size
,
2495 offset_size
, dwarf_version
,
2496 debug_info_p
, do_loc
,
2497 section
, this_set
, delimiter
, level
);
2499 case DW_FORM_implicit_const
:
2500 uvalue
= implicit_const
;
2509 case DW_FORM_ref_addr
:
2511 printf ("%c<0x%" PRIx64
">", delimiter
, uvalue
);
2514 case DW_FORM_GNU_ref_alt
:
2518 /* We have already printed the form name. */
2519 printf ("%c<0x%" PRIx64
">", delimiter
, uvalue
);
2521 printf ("%c<alt 0x%" PRIx64
">", delimiter
, uvalue
);
2523 /* FIXME: Follow the reference... */
2529 case DW_FORM_ref_sup4
:
2530 case DW_FORM_ref_udata
:
2532 printf ("%c<0x%" PRIx64
">", delimiter
, uvalue
+ cu_offset
);
2537 case DW_FORM_sec_offset
:
2539 printf ("%c0x%" PRIx64
, delimiter
, uvalue
);
2542 case DW_FORM_flag_present
:
2548 printf ("%c%" PRId64
, delimiter
, uvalue
);
2553 printf ("%c%" PRIu64
, delimiter
, uvalue
);
2556 case DW_FORM_implicit_const
:
2558 printf ("%c%" PRId64
, delimiter
, implicit_const
);
2561 case DW_FORM_ref_sup8
:
2566 uint64_t utmp
= uvalue
;
2567 if (form
== DW_FORM_ref8
)
2569 printf ("%c0x%" PRIx64
, delimiter
, utmp
);
2573 case DW_FORM_data16
:
2577 printf (" 0x%" PRIx64
, uvalue
);
2579 printf (" 0x%" PRIx64
"%016" PRIx64
, uvalue_hi
, uvalue
);
2583 case DW_FORM_string
:
2585 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2586 data
+= strnlen ((char *) data
, end
- data
);
2592 case DW_FORM_exprloc
:
2593 READ_ULEB (uvalue
, data
, end
);
2596 if (block_start
>= end
)
2598 warn (_("Block ends prematurely\n"));
2603 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2605 data
= block_start
+ uvalue
;
2610 SAFE_BYTE_GET (op
, block_start
, sizeof (op
), end
);
2611 if (op
!= DW_OP_addrx
)
2612 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2616 case DW_FORM_block1
:
2617 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2620 case DW_FORM_block2
:
2621 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2624 case DW_FORM_block4
:
2625 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2632 /* We have already displayed the form name. */
2633 printf (_("%c(offset: 0x%" PRIx64
"): %s"),
2634 delimiter
, uvalue
, fetch_indirect_string (uvalue
));
2636 printf (_("%c(indirect string, offset: 0x%" PRIx64
"): %s"),
2637 delimiter
, uvalue
, fetch_indirect_string (uvalue
));
2641 case DW_FORM_line_strp
:
2645 /* We have already displayed the form name. */
2646 printf (_("%c(offset: 0x%" PRIx64
"): %s"),
2647 delimiter
, uvalue
, fetch_indirect_line_string (uvalue
));
2649 printf (_("%c(indirect line string, offset: 0x%" PRIx64
"): %s"),
2650 delimiter
, uvalue
, fetch_indirect_line_string (uvalue
));
2654 case DW_FORM_GNU_str_index
:
2662 const char *suffix
= section
? strrchr (section
->name
, '.') : NULL
;
2663 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2666 strng
= fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
,
2667 debug_info_p
? debug_info_p
->str_offsets_base
: 0);
2669 /* We have already displayed the form name. */
2670 printf (_("%c(offset: 0x%" PRIx64
"): %s"),
2671 delimiter
, uvalue
, strng
);
2673 printf (_("%c(indexed string: 0x%" PRIx64
"): %s"),
2674 delimiter
, uvalue
, strng
);
2678 case DW_FORM_GNU_strp_alt
:
2682 /* We have already displayed the form name. */
2683 printf (_("%c(offset: 0x%" PRIx64
") %s"),
2684 delimiter
, uvalue
, fetch_alt_indirect_string (uvalue
));
2686 printf (_("%c(alt indirect string, offset: 0x%" PRIx64
") %s"),
2687 delimiter
, uvalue
, fetch_alt_indirect_string (uvalue
));
2691 case DW_FORM_indirect
:
2692 /* Handled above. */
2695 case DW_FORM_ref_sig8
:
2697 printf ("%c%s: 0x%" PRIx64
, delimiter
, do_wide
? "" : "signature",
2701 case DW_FORM_GNU_addr_index
:
2703 case DW_FORM_addrx1
:
2704 case DW_FORM_addrx2
:
2705 case DW_FORM_addrx3
:
2706 case DW_FORM_addrx4
:
2707 case DW_FORM_loclistx
:
2708 case DW_FORM_rnglistx
:
2712 const char *suffix
= strrchr (section
->name
, '.');
2713 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2715 if (form
== DW_FORM_loclistx
)
2719 idx
= fetch_indexed_value (uvalue
, loclists_dwo
, 0);
2720 if (idx
!= (uint64_t) -1)
2721 idx
+= (offset_size
== 8) ? 20 : 12;
2723 else if (debug_info_p
== NULL
)
2725 idx
= fetch_indexed_value (uvalue
, loclists
, 0);
2729 /* We want to compute:
2730 idx = fetch_indexed_value (uvalue, loclists, debug_info_p->loclists_base);
2731 idx += debug_info_p->loclists_base;
2732 Fortunately we already have that sum cached in the
2733 loc_offsets array. */
2734 if (uvalue
< debug_info_p
->num_loc_offsets
)
2735 idx
= debug_info_p
->loc_offsets
[uvalue
];
2738 warn (_("loc_offset %" PRIu64
" too big\n"), uvalue
);
2743 else if (form
== DW_FORM_rnglistx
)
2747 idx
= fetch_indexed_value (uvalue
, rnglists_dwo
, 0);
2748 if (idx
!= (uint64_t) -1)
2749 idx
+= (offset_size
== 8) ? 20 : 12;
2753 if (debug_info_p
== NULL
)
2756 base
= debug_info_p
->rnglists_base
;
2757 /* We do not have a cached value this time, so we perform the
2758 computation manually. */
2759 idx
= fetch_indexed_value (uvalue
, rnglists
, base
);
2760 if (idx
!= (uint64_t) -1)
2766 if (debug_info_p
== NULL
)
2768 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2771 base
= debug_info_p
->addr_base
;
2773 base
+= uvalue
* pointer_size
;
2774 idx
= fetch_indexed_addr (base
, pointer_size
);
2777 /* We have already displayed the form name. */
2778 if (idx
!= (uint64_t) -1)
2779 printf (_("%c(index: 0x%" PRIx64
"): %" PRIx64
),
2780 delimiter
, uvalue
, idx
);
2784 case DW_FORM_strp_sup
:
2786 printf ("%c<0x%" PRIx64
">", delimiter
, uvalue
+ cu_offset
);
2790 warn (_("Unrecognized form: 0x%lx\n"), form
);
2791 /* What to do? Consume a byte maybe? */
2796 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
2797 && num_debug_info_entries
== 0
2798 && debug_info_p
!= NULL
)
2802 case DW_AT_loclists_base
:
2803 if (debug_info_p
->loclists_base
)
2804 warn (_("CU @ %#" PRIx64
" has multiple loclists_base values "
2805 "(%#" PRIx64
" and %#" PRIx64
")"),
2806 debug_info_p
->cu_offset
,
2807 debug_info_p
->loclists_base
, uvalue
);
2808 debug_info_p
->loclists_base
= uvalue
;
2810 case DW_AT_rnglists_base
:
2811 if (debug_info_p
->rnglists_base
)
2812 warn (_("CU @ %#" PRIx64
" has multiple rnglists_base values "
2813 "(%#" PRIx64
" and %#" PRIx64
")"),
2814 debug_info_p
->cu_offset
,
2815 debug_info_p
->rnglists_base
, uvalue
);
2816 debug_info_p
->rnglists_base
= uvalue
;
2818 case DW_AT_str_offsets_base
:
2819 if (debug_info_p
->str_offsets_base
)
2820 warn (_("CU @ %#" PRIx64
" has multiple str_offsets_base values "
2821 "%#" PRIx64
" and %#" PRIx64
")"),
2822 debug_info_p
->cu_offset
,
2823 debug_info_p
->str_offsets_base
, uvalue
);
2824 debug_info_p
->str_offsets_base
= uvalue
;
2827 case DW_AT_frame_base
:
2828 have_frame_base
= 1;
2830 case DW_AT_location
:
2831 case DW_AT_GNU_locviews
:
2832 case DW_AT_string_length
:
2833 case DW_AT_return_addr
:
2834 case DW_AT_data_member_location
:
2835 case DW_AT_vtable_elem_location
:
2837 case DW_AT_static_link
:
2838 case DW_AT_use_location
:
2839 case DW_AT_call_value
:
2840 case DW_AT_GNU_call_site_value
:
2841 case DW_AT_call_data_value
:
2842 case DW_AT_GNU_call_site_data_value
:
2843 case DW_AT_call_target
:
2844 case DW_AT_GNU_call_site_target
:
2845 case DW_AT_call_target_clobbered
:
2846 case DW_AT_GNU_call_site_target_clobbered
:
2847 if ((dwarf_version
< 4
2848 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2849 || form
== DW_FORM_sec_offset
2850 || form
== DW_FORM_loclistx
)
2852 /* Process location list. */
2853 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2854 unsigned int num
= debug_info_p
->num_loc_offsets
;
2856 if (lmax
== 0 || num
>= lmax
)
2859 debug_info_p
->loc_offsets
= (uint64_t *)
2860 xcrealloc (debug_info_p
->loc_offsets
,
2861 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2862 debug_info_p
->loc_views
= (uint64_t *)
2863 xcrealloc (debug_info_p
->loc_views
,
2864 lmax
, sizeof (*debug_info_p
->loc_views
));
2865 debug_info_p
->have_frame_base
= (int *)
2866 xcrealloc (debug_info_p
->have_frame_base
,
2867 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2868 debug_info_p
->max_loc_offsets
= lmax
;
2870 if (form
== DW_FORM_loclistx
)
2871 uvalue
= fetch_indexed_value (num
, loclists
, debug_info_p
->loclists_base
);
2872 else if (this_set
!= NULL
)
2873 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2875 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2876 if (attribute
!= DW_AT_GNU_locviews
)
2878 uvalue
+= debug_info_p
->loclists_base
;
2880 /* Corrupt DWARF info can produce more offsets than views.
2881 See PR 23062 for an example. */
2882 if (debug_info_p
->num_loc_offsets
2883 > debug_info_p
->num_loc_views
)
2884 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2887 debug_info_p
->loc_offsets
[num
] = uvalue
;
2888 debug_info_p
->num_loc_offsets
++;
2893 assert (debug_info_p
->num_loc_views
<= num
);
2894 num
= debug_info_p
->num_loc_views
;
2895 if (num
> debug_info_p
->num_loc_offsets
)
2896 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2899 debug_info_p
->loc_views
[num
] = uvalue
;
2900 debug_info_p
->num_loc_views
++;
2907 if (need_base_address
)
2908 debug_info_p
->base_address
= uvalue
;
2911 case DW_AT_GNU_addr_base
:
2912 case DW_AT_addr_base
:
2913 debug_info_p
->addr_base
= uvalue
;
2916 case DW_AT_GNU_ranges_base
:
2917 debug_info_p
->ranges_base
= uvalue
;
2921 if ((dwarf_version
< 4
2922 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2923 || form
== DW_FORM_sec_offset
2924 || form
== DW_FORM_rnglistx
)
2926 /* Process range list. */
2927 unsigned int lmax
= debug_info_p
->max_range_lists
;
2928 unsigned int num
= debug_info_p
->num_range_lists
;
2930 if (lmax
== 0 || num
>= lmax
)
2933 debug_info_p
->range_lists
= (uint64_t *)
2934 xcrealloc (debug_info_p
->range_lists
,
2935 lmax
, sizeof (*debug_info_p
->range_lists
));
2936 debug_info_p
->max_range_lists
= lmax
;
2939 if (form
== DW_FORM_rnglistx
)
2940 uvalue
= fetch_indexed_value (uvalue
, rnglists
, 0);
2942 debug_info_p
->range_lists
[num
] = uvalue
;
2943 debug_info_p
->num_range_lists
++;
2947 case DW_AT_GNU_dwo_name
:
2948 case DW_AT_dwo_name
:
2953 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2955 case DW_FORM_GNU_strp_alt
:
2956 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2958 case DW_FORM_GNU_str_index
:
2964 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, false,
2965 debug_info_p
->str_offsets_base
),
2968 case DW_FORM_string
:
2969 add_dwo_name ((const char *) orig_data
, cu_offset
);
2972 warn (_("Unsupported form (%s) for attribute %s\n"),
2973 get_FORM_name (form
), get_AT_name (attribute
));
2978 case DW_AT_comp_dir
:
2979 /* FIXME: Also extract a build-id in a CU/TU. */
2984 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2986 case DW_FORM_GNU_strp_alt
:
2987 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2989 case DW_FORM_line_strp
:
2990 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2992 case DW_FORM_GNU_str_index
:
2998 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false,
2999 debug_info_p
->str_offsets_base
),
3002 case DW_FORM_string
:
3003 add_dwo_dir ((const char *) orig_data
, cu_offset
);
3006 warn (_("Unsupported form (%s) for attribute %s\n"),
3007 get_FORM_name (form
), get_AT_name (attribute
));
3012 case DW_AT_GNU_dwo_id
:
3017 /* FIXME: Record the length of the ID as well ? */
3018 add_dwo_id ((const char *) (data
- 8), cu_offset
);
3021 warn (_("Unsupported form (%s) for attribute %s\n"),
3022 get_FORM_name (form
), get_AT_name (attribute
));
3032 if (do_loc
|| attribute
== 0)
3035 /* For some attributes we can display further information. */
3039 if (level
>= 0 && level
< MAX_CU_NESTING
3040 && uvalue
< (size_t) (end
- start
))
3042 bool is_signed
= false;
3043 abbrev_entry
*type_abbrev
;
3044 unsigned char *type_data
;
3047 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
,
3051 if (type_abbrev
!= NULL
)
3053 get_type_signedness (type_abbrev
, section
, type_data
,
3054 map
? section
->start
+ map
->end
: end
,
3055 map
? map
->start
: cu_offset
,
3056 pointer_size
, offset_size
, dwarf_version
,
3059 level_type_signed
[level
] = is_signed
;
3067 case DW_INL_not_inlined
:
3068 printf (_("(not inlined)"));
3070 case DW_INL_inlined
:
3071 printf (_("(inlined)"));
3073 case DW_INL_declared_not_inlined
:
3074 printf (_("(declared as inline but ignored)"));
3076 case DW_INL_declared_inlined
:
3077 printf (_("(declared as inline and inlined)"));
3080 printf (_(" (Unknown inline attribute value: %#" PRIx64
")"),
3086 case DW_AT_language
:
3090 /* Ordered by the numeric value of these constants. */
3091 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3092 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3093 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3094 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3095 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3096 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3097 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3098 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3099 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3100 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3101 /* DWARF 2.1 values. */
3102 case DW_LANG_Java
: printf ("(Java)"); break;
3103 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3104 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3105 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3106 /* DWARF 3 values. */
3107 case DW_LANG_PLI
: printf ("(PLI)"); break;
3108 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3109 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3110 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3111 case DW_LANG_D
: printf ("(D)"); break;
3112 /* DWARF 4 values. */
3113 case DW_LANG_Python
: printf ("(Python)"); break;
3114 /* DWARF 5 values. */
3115 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3116 case DW_LANG_Go
: printf ("(Go)"); break;
3117 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3118 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3119 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3120 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3121 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3122 case DW_LANG_Rust
: printf ("(Rust)"); break;
3123 case DW_LANG_C11
: printf ("(C11)"); break;
3124 case DW_LANG_Swift
: printf ("(Swift)"); break;
3125 case DW_LANG_Julia
: printf ("(Julia)"); break;
3126 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3127 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3128 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3129 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3130 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3131 /* MIPS extension. */
3132 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3133 /* UPC extension. */
3134 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3136 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3137 printf (_("(implementation defined: %#" PRIx64
")"), uvalue
);
3139 printf (_("(unknown: %#" PRIx64
")"), uvalue
);
3144 case DW_AT_encoding
:
3148 case DW_ATE_void
: printf ("(void)"); break;
3149 case DW_ATE_address
: printf ("(machine address)"); break;
3150 case DW_ATE_boolean
: printf ("(boolean)"); break;
3151 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3152 case DW_ATE_float
: printf ("(float)"); break;
3153 case DW_ATE_signed
: printf ("(signed)"); break;
3154 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3155 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3156 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3157 /* DWARF 2.1 values: */
3158 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3159 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3160 /* DWARF 3 values: */
3161 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3162 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3163 case DW_ATE_edited
: printf ("(edited)"); break;
3164 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3165 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3166 /* DWARF 4 values: */
3167 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3168 /* DWARF 5 values: */
3169 case DW_ATE_UCS
: printf ("(UCS)"); break;
3170 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3172 /* HP extensions: */
3173 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3174 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3175 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3176 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3177 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3178 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3179 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3182 if (uvalue
>= DW_ATE_lo_user
3183 && uvalue
<= DW_ATE_hi_user
)
3184 printf (_("(user defined type)"));
3186 printf (_("(unknown type)"));
3191 case DW_AT_accessibility
:
3195 case DW_ACCESS_public
: printf ("(public)"); break;
3196 case DW_ACCESS_protected
: printf ("(protected)"); break;
3197 case DW_ACCESS_private
: printf ("(private)"); break;
3199 printf (_("(unknown accessibility)"));
3204 case DW_AT_visibility
:
3208 case DW_VIS_local
: printf ("(local)"); break;
3209 case DW_VIS_exported
: printf ("(exported)"); break;
3210 case DW_VIS_qualified
: printf ("(qualified)"); break;
3211 default: printf (_("(unknown visibility)")); break;
3215 case DW_AT_endianity
:
3219 case DW_END_default
: printf ("(default)"); break;
3220 case DW_END_big
: printf ("(big)"); break;
3221 case DW_END_little
: printf ("(little)"); break;
3223 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3224 printf (_("(user specified)"));
3226 printf (_("(unknown endianity)"));
3231 case DW_AT_virtuality
:
3235 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3236 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3237 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3238 default: printf (_("(unknown virtuality)")); break;
3242 case DW_AT_identifier_case
:
3246 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3247 case DW_ID_up_case
: printf ("(up_case)"); break;
3248 case DW_ID_down_case
: printf ("(down_case)"); break;
3249 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3250 default: printf (_("(unknown case)")); break;
3254 case DW_AT_calling_convention
:
3258 case DW_CC_normal
: printf ("(normal)"); break;
3259 case DW_CC_program
: printf ("(program)"); break;
3260 case DW_CC_nocall
: printf ("(nocall)"); break;
3261 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3262 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3263 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3264 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3266 if (uvalue
>= DW_CC_lo_user
3267 && uvalue
<= DW_CC_hi_user
)
3268 printf (_("(user defined)"));
3270 printf (_("(unknown convention)"));
3274 case DW_AT_ordering
:
3279 case -1: printf (_("(undefined)")); break;
3280 case 0: printf ("(row major)"); break;
3281 case 1: printf ("(column major)"); break;
3285 case DW_AT_decimal_sign
:
3289 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3290 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3291 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3292 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3293 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3294 default: printf (_("(unrecognised)")); break;
3298 case DW_AT_defaulted
:
3302 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3303 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3304 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3305 default: printf (_("(unrecognised)")); break;
3309 case DW_AT_discr_list
:
3311 display_discr_list (form
, uvalue
, data
, level
);
3314 case DW_AT_frame_base
:
3315 have_frame_base
= 1;
3317 case DW_AT_location
:
3318 case DW_AT_loclists_base
:
3319 case DW_AT_rnglists_base
:
3320 case DW_AT_str_offsets_base
:
3321 case DW_AT_string_length
:
3322 case DW_AT_return_addr
:
3323 case DW_AT_data_member_location
:
3324 case DW_AT_vtable_elem_location
:
3326 case DW_AT_static_link
:
3327 case DW_AT_use_location
:
3328 case DW_AT_call_value
:
3329 case DW_AT_GNU_call_site_value
:
3330 case DW_AT_call_data_value
:
3331 case DW_AT_GNU_call_site_data_value
:
3332 case DW_AT_call_target
:
3333 case DW_AT_GNU_call_site_target
:
3334 case DW_AT_call_target_clobbered
:
3335 case DW_AT_GNU_call_site_target_clobbered
:
3336 if ((dwarf_version
< 4
3337 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3338 || form
== DW_FORM_sec_offset
3339 || form
== DW_FORM_loclistx
)
3341 if (attribute
!= DW_AT_rnglists_base
3342 && attribute
!= DW_AT_str_offsets_base
)
3343 printf (_(" (location list)"));
3346 case DW_AT_allocated
:
3347 case DW_AT_associated
:
3348 case DW_AT_data_location
:
3350 case DW_AT_upper_bound
:
3351 case DW_AT_lower_bound
:
3355 int need_frame_base
;
3358 need_frame_base
= decode_location_expression (block_start
,
3363 cu_offset
, section
);
3365 if (need_frame_base
&& !have_frame_base
)
3366 printf (_(" [without DW_AT_frame_base]"));
3370 case DW_AT_data_bit_offset
:
3371 case DW_AT_byte_size
:
3372 case DW_AT_bit_size
:
3373 case DW_AT_string_length_byte_size
:
3374 case DW_AT_string_length_bit_size
:
3375 case DW_AT_bit_stride
:
3376 if (form
== DW_FORM_exprloc
)
3379 (void) decode_location_expression (block_start
, pointer_size
,
3380 offset_size
, dwarf_version
,
3381 uvalue
, cu_offset
, section
);
3388 unsigned long abbrev_number
;
3389 abbrev_entry
*entry
;
3391 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
, end
,
3392 section
, & abbrev_number
, NULL
, NULL
);
3395 if (form
!= DW_FORM_GNU_ref_alt
)
3396 warn (_("Offset %#" PRIx64
" used as value for DW_AT_import attribute of DIE at offset %#tx is too big.\n"),
3398 orig_data
- section
->start
);
3402 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3403 printf (" (%s)", get_TAG_name (entry
->tag
));
3416 static unsigned char *
3417 read_and_display_attr (unsigned long attribute
,
3419 int64_t implicit_const
,
3420 unsigned char *start
,
3421 unsigned char *data
,
3424 uint64_t pointer_size
,
3425 uint64_t offset_size
,
3427 debug_info
*debug_info_p
,
3429 struct dwarf_section
*section
,
3430 struct cu_tu_set
*this_set
,
3434 printf (" %-18s:", get_AT_name (attribute
));
3435 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3437 cu_offset
, pointer_size
, offset_size
,
3438 dwarf_version
, debug_info_p
,
3439 do_loc
, section
, this_set
, ' ', level
);
3445 /* Like load_debug_section, but if the ordinary call fails, and we are
3446 following debug links, then attempt to load the requested section
3447 from one of the separate debug info files. */
3450 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3453 if (load_debug_section (sec_enum
, handle
))
3455 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3457 /* See if we can associate a filename with this section. */
3460 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3461 if (i
->handle
== handle
)
3463 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3471 if (do_follow_links
)
3475 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3477 if (load_debug_section (sec_enum
, i
->handle
))
3479 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3481 /* FIXME: We should check to see if any of the remaining debug info
3482 files also contain this section, and, umm, do something about it. */
3492 introduce (struct dwarf_section
* section
, bool raw
)
3496 if (do_follow_links
&& section
->filename
)
3497 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3498 section
->name
, section
->filename
);
3500 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3504 if (do_follow_links
&& section
->filename
)
3505 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3506 section
->name
, section
->filename
);
3508 printf (_("Contents of the %s section:\n\n"), section
->name
);
3512 /* Process the contents of a .debug_info section.
3513 If do_loc is TRUE then we are scanning for location lists and dwo tags
3514 and we do not want to display anything to the user.
3515 If do_types is TRUE, we are processing a .debug_types section instead of
3516 a .debug_info section.
3517 The information displayed is restricted by the values in DWARF_START_DIE
3518 and DWARF_CUTOFF_LEVEL.
3519 Returns TRUE upon success. Otherwise an error or warning message is
3520 printed and FALSE is returned. */
3523 process_debug_info (struct dwarf_section
* section
,
3525 enum dwarf_section_display_enum abbrev_sec
,
3529 unsigned char *start
= section
->start
;
3530 unsigned char *end
= start
+ section
->size
;
3531 unsigned char *section_begin
;
3533 unsigned int num_units
= 0;
3535 /* First scan the section to get the number of comp units.
3536 Length sanity checks are done here. */
3537 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3542 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3543 will be the length. For a 64-bit DWARF section, it'll be
3544 the escape code 0xffffffff followed by an 8 byte length. */
3545 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3547 if (length
== 0xffffffff)
3548 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3549 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3551 warn (_("Reserved length value (%#" PRIx64
") found in section %s\n"),
3552 length
, section
->name
);
3556 /* Negative values are illegal, they may even cause infinite
3557 looping. This can happen if we can't accurately apply
3558 relocations to an object file, or if the file is corrupt. */
3559 if (length
> (size_t) (end
- section_begin
))
3561 warn (_("Corrupt unit length (got %#" PRIx64
3562 " expected at most %#tx) in section %s\n"),
3563 length
, end
- section_begin
, section
->name
);
3566 section_begin
+= length
;
3571 error (_("No comp units in %s section ?\n"), section
->name
);
3575 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
3576 && num_debug_info_entries
== 0
3580 /* Then allocate an array to hold the information. */
3581 debug_information
= (debug_info
*) cmalloc (num_units
,
3582 sizeof (* debug_information
));
3583 if (debug_information
== NULL
)
3585 error (_("Not enough memory for a debug info array of %u entries\n"),
3587 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3591 /* PR 17531: file: 92ca3797.
3592 We cannot rely upon the debug_information array being initialised
3593 before it is used. A corrupt file could easily contain references
3594 to a unit for which information has not been made available. So
3595 we ensure that the array is zeroed here. */
3596 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3598 alloc_num_debug_info_entries
= num_units
;
3603 load_debug_section_with_follow (str
, file
);
3604 load_debug_section_with_follow (line_str
, file
);
3605 load_debug_section_with_follow (str_dwo
, file
);
3606 load_debug_section_with_follow (str_index
, file
);
3607 load_debug_section_with_follow (str_index_dwo
, file
);
3608 load_debug_section_with_follow (debug_addr
, file
);
3611 load_debug_section_with_follow (abbrev_sec
, file
);
3612 load_debug_section_with_follow (loclists
, file
);
3613 load_debug_section_with_follow (rnglists
, file
);
3614 load_debug_section_with_follow (loclists_dwo
, file
);
3615 load_debug_section_with_follow (rnglists_dwo
, file
);
3617 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3619 warn (_("Unable to locate %s section!\n"),
3620 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3624 if (!do_loc
&& dwarf_start_die
== 0)
3625 introduce (section
, false);
3627 free_all_abbrevs ();
3629 /* In order to be able to resolve DW_FORM_ref_addr forms we need
3630 to load *all* of the abbrevs for all CUs in this .debug_info
3631 section. This does effectively mean that we (partially) read
3632 every CU header twice. */
3633 for (section_begin
= start
; start
< end
;)
3635 DWARF2_Internal_CompUnit compunit
;
3636 unsigned char *hdrptr
;
3637 uint64_t abbrev_base
;
3640 unsigned int offset_size
;
3641 struct cu_tu_set
*this_set
;
3642 unsigned char *end_cu
;
3645 cu_offset
= start
- section_begin
;
3647 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3649 if (compunit
.cu_length
== 0xffffffff)
3651 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3656 end_cu
= hdrptr
+ compunit
.cu_length
;
3658 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3660 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3662 if (compunit
.cu_version
< 5)
3664 compunit
.cu_unit_type
= DW_UT_compile
;
3665 /* Initialize it due to a false compiler warning. */
3666 compunit
.cu_pointer_size
= -1;
3670 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3671 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3673 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3676 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3679 if (compunit
.cu_unit_type
== DW_UT_split_compile
3680 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3683 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3686 if (this_set
== NULL
)
3689 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3693 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3694 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3698 abbrev_list
*free_list
;
3699 list
= find_and_process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3700 abbrev_base
, abbrev_size
,
3701 compunit
.cu_abbrev_offset
,
3704 if (list
!= NULL
&& list
->first_abbrev
!= NULL
)
3705 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
,
3707 else if (free_list
!= NULL
)
3708 free_abbrev_list (free_list
);
3711 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3713 DWARF2_Internal_CompUnit compunit
;
3714 unsigned char *hdrptr
;
3715 unsigned char *tags
;
3716 int level
, last_level
, saved_level
;
3718 unsigned int offset_size
;
3719 uint64_t signature
= 0;
3720 uint64_t type_offset
= 0;
3721 struct cu_tu_set
*this_set
;
3722 uint64_t abbrev_base
;
3724 unsigned char *end_cu
;
3727 cu_offset
= start
- section_begin
;
3729 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3731 if (compunit
.cu_length
== 0xffffffff)
3733 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3738 end_cu
= hdrptr
+ compunit
.cu_length
;
3740 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3742 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3744 if (compunit
.cu_version
< 5)
3746 compunit
.cu_unit_type
= DW_UT_compile
;
3747 /* Initialize it due to a false compiler warning. */
3748 compunit
.cu_pointer_size
= -1;
3752 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3753 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3755 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3758 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3760 if (this_set
== NULL
)
3763 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3767 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3768 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3771 if (compunit
.cu_version
< 5)
3772 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3774 bool do_dwo_id
= false;
3775 uint64_t dwo_id
= 0;
3776 if (compunit
.cu_unit_type
== DW_UT_split_compile
3777 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3779 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3783 /* PR 17512: file: 001-108546-0.001:0.1. */
3784 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3786 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3787 compunit
.cu_pointer_size
, offset_size
);
3788 compunit
.cu_pointer_size
= offset_size
;
3793 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
3794 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
3797 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
3803 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
3804 && num_debug_info_entries
== 0
3805 && alloc_num_debug_info_entries
> unit
3808 debug_information
[unit
].cu_offset
= cu_offset
;
3809 debug_information
[unit
].pointer_size
3810 = compunit
.cu_pointer_size
;
3811 debug_information
[unit
].offset_size
= offset_size
;
3812 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3813 debug_information
[unit
].base_address
= 0;
3814 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3815 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3816 debug_information
[unit
].rnglists_base
= 0;
3817 debug_information
[unit
].loc_offsets
= NULL
;
3818 debug_information
[unit
].have_frame_base
= NULL
;
3819 debug_information
[unit
].max_loc_offsets
= 0;
3820 debug_information
[unit
].num_loc_offsets
= 0;
3821 debug_information
[unit
].loclists_base
= 0;
3822 debug_information
[unit
].range_lists
= NULL
;
3823 debug_information
[unit
].max_range_lists
= 0;
3824 debug_information
[unit
].num_range_lists
= 0;
3825 debug_information
[unit
].rnglists_base
= 0;
3826 debug_information
[unit
].str_offsets_base
= 0;
3829 if (!do_loc
&& dwarf_start_die
== 0)
3831 printf (_(" Compilation Unit @ offset 0x%" PRIx64
":\n"),
3833 printf (_(" Length: 0x%" PRIx64
" (%s)\n"),
3835 offset_size
== 8 ? "64-bit" : "32-bit");
3836 printf (_(" Version: %d\n"), compunit
.cu_version
);
3837 if (compunit
.cu_version
>= 5)
3839 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
3841 printf (_(" Unit Type: %s (%x)\n"),
3842 name
? name
: "???",
3843 compunit
.cu_unit_type
);
3845 printf (_(" Abbrev Offset: 0x%" PRIx64
"\n"),
3846 compunit
.cu_abbrev_offset
);
3847 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3850 printf (_(" Signature: 0x%" PRIx64
"\n"), signature
);
3851 printf (_(" Type Offset: 0x%" PRIx64
"\n"), type_offset
);
3854 printf (_(" DWO ID: 0x%" PRIx64
"\n"), dwo_id
);
3855 if (this_set
!= NULL
)
3857 uint64_t *offsets
= this_set
->section_offsets
;
3858 size_t *sizes
= this_set
->section_sizes
;
3860 printf (_(" Section contributions:\n"));
3861 printf (_(" .debug_abbrev.dwo: 0x%" PRIx64
" 0x%zx\n"),
3862 offsets
[DW_SECT_ABBREV
], sizes
[DW_SECT_ABBREV
]);
3863 printf (_(" .debug_line.dwo: 0x%" PRIx64
" 0x%zx\n"),
3864 offsets
[DW_SECT_LINE
], sizes
[DW_SECT_LINE
]);
3865 printf (_(" .debug_loc.dwo: 0x%" PRIx64
" 0x%zx\n"),
3866 offsets
[DW_SECT_LOC
], sizes
[DW_SECT_LOC
]);
3867 printf (_(" .debug_str_offsets.dwo: 0x%" PRIx64
" 0x%zx\n"),
3868 offsets
[DW_SECT_STR_OFFSETS
], sizes
[DW_SECT_STR_OFFSETS
]);
3875 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3877 warn (_("CU at offset %#" PRIx64
" contains corrupt or "
3878 "unsupported version number: %d.\n"),
3879 cu_offset
, compunit
.cu_version
);
3883 if (compunit
.cu_unit_type
!= DW_UT_compile
3884 && compunit
.cu_unit_type
!= DW_UT_partial
3885 && compunit
.cu_unit_type
!= DW_UT_type
3886 && compunit
.cu_unit_type
!= DW_UT_split_compile
3887 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3889 warn (_("CU at offset %#" PRIx64
" contains corrupt or "
3890 "unsupported unit type: %d.\n"),
3891 cu_offset
, compunit
.cu_unit_type
);
3895 /* Process the abbrevs used by this compilation unit. */
3897 list
= find_and_process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3898 abbrev_base
, abbrev_size
,
3899 compunit
.cu_abbrev_offset
, NULL
);
3903 while (tags
< start
)
3905 unsigned long abbrev_number
;
3906 unsigned long die_offset
;
3907 abbrev_entry
*entry
;
3909 int do_printing
= 1;
3911 die_offset
= tags
- section_begin
;
3913 READ_ULEB (abbrev_number
, tags
, start
);
3915 /* A null DIE marks the end of a list of siblings or it may also be
3916 a section padding. */
3917 if (abbrev_number
== 0)
3919 /* Check if it can be a section padding for the last CU. */
3920 if (level
== 0 && start
== end
)
3924 for (chk
= tags
; chk
< start
; chk
++)
3931 if (!do_loc
&& die_offset
>= dwarf_start_die
3932 && (dwarf_cutoff_level
== -1
3933 || level
< dwarf_cutoff_level
))
3934 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3940 static unsigned num_bogus_warns
= 0;
3942 if (num_bogus_warns
< 3)
3944 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3945 die_offset
, section
->name
);
3947 if (num_bogus_warns
== 3)
3948 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3951 if (dwarf_start_die
!= 0 && level
< saved_level
)
3958 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3962 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3963 saved_level
= level
;
3964 do_printing
= (dwarf_cutoff_level
== -1
3965 || level
< dwarf_cutoff_level
);
3967 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3968 level
, die_offset
, abbrev_number
);
3969 else if (dwarf_cutoff_level
== -1
3970 || last_level
< dwarf_cutoff_level
)
3971 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3976 /* Scan through the abbreviation list until we reach the
3980 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3981 if (entry
->number
== abbrev_number
)
3986 if (!do_loc
&& do_printing
)
3991 warn (_("DIE at offset %#lx refers to abbreviation number %lu which does not exist\n"),
3992 die_offset
, abbrev_number
);
3996 if (!do_loc
&& do_printing
)
3997 printf (" (%s)\n", get_TAG_name (entry
->tag
));
4002 need_base_address
= 0;
4004 case DW_TAG_compile_unit
:
4005 case DW_TAG_skeleton_unit
:
4006 need_base_address
= 1;
4007 need_dwo_info
= do_loc
;
4009 case DW_TAG_entry_point
:
4010 case DW_TAG_subprogram
:
4011 need_base_address
= 0;
4012 /* Assuming that there is no DW_AT_frame_base. */
4013 have_frame_base
= 0;
4017 debug_info
*debug_info_p
=
4018 (debug_information
&& unit
< alloc_num_debug_info_entries
)
4019 ? debug_information
+ unit
: NULL
;
4021 assert (!debug_info_p
4022 || (debug_info_p
->num_loc_offsets
4023 == debug_info_p
->num_loc_views
));
4025 for (attr
= entry
->first_attr
;
4026 attr
&& attr
->attribute
;
4029 if (! do_loc
&& do_printing
)
4030 /* Show the offset from where the tag was extracted. */
4031 printf (" <%tx>", tags
- section_begin
);
4032 tags
= read_and_display_attr (attr
->attribute
,
4034 attr
->implicit_const
,
4039 compunit
.cu_pointer_size
,
4041 compunit
.cu_version
,
4043 do_loc
|| ! do_printing
,
4049 /* If a locview attribute appears before a location one,
4050 make sure we don't associate it with an earlier
4053 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
4056 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = -1;
4057 debug_info_p
->num_loc_views
++;
4058 assert (debug_info_p
->num_loc_views
4059 == debug_info_p
->num_loc_offsets
);
4066 warn(_("DIE has locviews without loclist\n"));
4067 debug_info_p
->num_loc_views
--;
4074 if (entry
->children
)
4078 free_abbrev_list (list
);
4081 /* Set num_debug_info_entries here so that it can be used to check if
4082 we need to process .debug_loc and .debug_ranges sections. */
4083 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
4084 && num_debug_info_entries
== 0
4087 if (num_units
> alloc_num_debug_info_entries
)
4088 num_debug_info_entries
= alloc_num_debug_info_entries
;
4090 num_debug_info_entries
= num_units
;
4099 /* Locate and scan the .debug_info section in the file and record the pointer
4100 sizes and offsets for the compilation units in it. Usually an executable
4101 will have just one pointer size, but this is not guaranteed, and so we try
4102 not to make any assumptions. Returns zero upon failure, or the number of
4103 compilation units upon success. */
4106 load_debug_info (void * file
)
4108 /* If we have already tried and failed to load the .debug_info
4109 section then do not bother to repeat the task. */
4110 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4113 /* If we already have the information there is nothing else to do. */
4114 if (num_debug_info_entries
> 0)
4115 return num_debug_info_entries
;
4117 /* If this is a DWARF package file, load the CU and TU indexes. */
4118 (void) load_cu_tu_indexes (file
);
4120 if (load_debug_section_with_follow (info
, file
)
4121 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4122 return num_debug_info_entries
;
4124 if (load_debug_section_with_follow (info_dwo
, file
)
4125 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4126 abbrev_dwo
, true, false))
4127 return num_debug_info_entries
;
4129 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4133 /* Read a DWARF .debug_line section header starting at DATA.
4134 Upon success returns an updated DATA pointer and the LINFO
4135 structure and the END_OF_SEQUENCE pointer will be filled in.
4136 Otherwise returns NULL. */
4138 static unsigned char *
4139 read_debug_line_header (struct dwarf_section
* section
,
4140 unsigned char * data
,
4141 unsigned char * end
,
4142 DWARF2_Internal_LineInfo
* linfo
,
4143 unsigned char ** end_of_sequence
)
4145 unsigned char *hdrptr
;
4147 /* Extract information from the Line Number Program Header.
4148 (section 6.2.4 in the Dwarf3 doc). */
4151 /* Get and check the length of the block. */
4152 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4154 if (linfo
->li_length
== 0xffffffff)
4156 /* This section is 64-bit DWARF 3. */
4157 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4158 linfo
->li_offset_size
= 8;
4161 linfo
->li_offset_size
= 4;
4163 if (linfo
->li_length
> (size_t) (end
- hdrptr
))
4165 /* If the length field has a relocation against it, then we should
4166 not complain if it is inaccurate (and probably negative). This
4167 happens in object files when the .debug_line section is actually
4168 comprised of several different .debug_line.* sections, (some of
4169 which may be removed by linker garbage collection), and a relocation
4170 is used to compute the correct length once that is done. */
4171 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4173 linfo
->li_length
= end
- hdrptr
;
4177 warn (_("The length field (%#" PRIx64
")"
4178 " in the debug_line header is wrong"
4179 " - the section is too small\n"),
4184 end
= hdrptr
+ linfo
->li_length
;
4186 /* Get and check the version number. */
4187 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4189 if (linfo
->li_version
!= 2
4190 && linfo
->li_version
!= 3
4191 && linfo
->li_version
!= 4
4192 && linfo
->li_version
!= 5)
4194 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4195 "is currently supported.\n"));
4199 if (linfo
->li_version
>= 5)
4201 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4203 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4204 if (linfo
->li_segment_size
!= 0)
4206 warn (_("The %s section contains "
4207 "unsupported segment selector size: %d.\n"),
4208 section
->name
, linfo
->li_segment_size
);
4213 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4214 linfo
->li_offset_size
, end
);
4215 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4217 if (linfo
->li_version
>= 4)
4219 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4221 if (linfo
->li_max_ops_per_insn
== 0)
4223 warn (_("Invalid maximum operations per insn.\n"));
4228 linfo
->li_max_ops_per_insn
= 1;
4230 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4231 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4232 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4233 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4235 *end_of_sequence
= end
;
4239 static unsigned char *
4240 display_formatted_table (unsigned char *data
,
4241 unsigned char *start
,
4243 const DWARF2_Internal_LineInfo
*linfo
,
4244 struct dwarf_section
*section
,
4247 unsigned char *format_start
, format_count
, *format
, formati
;
4248 uint64_t data_count
, datai
;
4249 unsigned int namepass
, last_entry
= 0;
4250 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4252 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4253 if (do_checks
&& format_count
> 5)
4254 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4255 table_name
, format_count
);
4257 format_start
= data
;
4258 for (formati
= 0; formati
< format_count
; formati
++)
4260 SKIP_ULEB (data
, end
);
4261 SKIP_ULEB (data
, end
);
4264 warn (_("%s: Corrupt format description entry\n"), table_name
);
4269 READ_ULEB (data_count
, data
, end
);
4270 if (data_count
== 0)
4272 printf (_("\n The %s is empty.\n"), table_name
);
4275 else if (data
>= end
)
4277 warn (_("%s: Corrupt entry count - expected %#" PRIx64
4278 " but none found\n"), table_name
, data_count
);
4282 else if (format_count
== 0)
4284 warn (_("%s: format count is zero, but the table is not empty\n"),
4289 printf (_("\n The %s (offset 0x%tx, lines %" PRIu64
", columns %u):\n"),
4290 table_name
, data
- start
, data_count
, format_count
);
4292 printf (_(" Entry"));
4293 /* Delay displaying name as the last entry for better screen layout. */
4294 for (namepass
= 0; namepass
< 2; namepass
++)
4296 format
= format_start
;
4297 for (formati
= 0; formati
< format_count
; formati
++)
4299 uint64_t content_type
;
4301 READ_ULEB (content_type
, format
, end
);
4302 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4303 switch (content_type
)
4306 printf (_("\tName"));
4308 case DW_LNCT_directory_index
:
4309 printf (_("\tDir"));
4311 case DW_LNCT_timestamp
:
4312 printf (_("\tTime"));
4315 printf (_("\tSize"));
4318 printf (_("\tMD5\t\t\t"));
4321 printf (_("\t(Unknown format content type %" PRIu64
")"),
4324 SKIP_ULEB (format
, end
);
4329 for (datai
= 0; datai
< data_count
; datai
++)
4331 unsigned char *datapass
= data
;
4333 printf (" %d", last_entry
++);
4334 /* Delay displaying name as the last entry for better screen layout. */
4335 for (namepass
= 0; namepass
< 2; namepass
++)
4337 format
= format_start
;
4339 for (formati
= 0; formati
< format_count
; formati
++)
4341 uint64_t content_type
, form
;
4343 READ_ULEB (content_type
, format
, end
);
4344 READ_ULEB (form
, format
, end
);
4345 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4346 0, 0, linfo
->li_offset_size
,
4347 linfo
->li_version
, NULL
,
4348 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4349 section
, NULL
, '\t', -1);
4353 if (data
>= end
&& (datai
< data_count
- 1))
4355 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4364 display_debug_sup (struct dwarf_section
* section
,
4365 void * file ATTRIBUTE_UNUSED
)
4367 unsigned char * start
= section
->start
;
4368 unsigned char * end
= section
->start
+ section
->size
;
4369 unsigned int version
;
4370 char is_supplementary
;
4371 const unsigned char * sup_filename
;
4372 size_t sup_filename_len
;
4373 unsigned int num_read
;
4375 uint64_t checksum_len
;
4378 introduce (section
, true);
4379 if (section
->size
< 4)
4381 error (_("corrupt .debug_sup section: size is too small\n"));
4385 /* Read the data. */
4386 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4388 warn (_("corrupt .debug_sup section: version < 5"));
4390 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4391 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4392 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4394 sup_filename
= start
;
4395 if (is_supplementary
&& sup_filename
[0] != 0)
4396 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4398 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4399 if (sup_filename_len
== (size_t) (end
- start
))
4401 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4404 start
+= sup_filename_len
+ 1;
4406 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4409 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4413 if (checksum_len
> (size_t) (end
- start
))
4415 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4416 checksum_len
= end
- start
;
4418 else if (checksum_len
< (size_t) (end
- start
))
4420 warn (_("corrupt .debug_sup section: there are %#" PRIx64
4421 " extra, unused bytes at the end of the section\n"),
4422 (end
- start
) - checksum_len
);
4425 printf (_(" Version: %u\n"), version
);
4426 printf (_(" Is Supp: %u\n"), is_supplementary
);
4427 printf (_(" Filename: %s\n"), sup_filename
);
4428 printf (_(" Checksum Len: %" PRIu64
"\n"), checksum_len
);
4429 if (checksum_len
> 0)
4431 printf (_(" Checksum: "));
4432 while (checksum_len
--)
4433 printf ("0x%x ", * start
++ );
4440 display_debug_lines_raw (struct dwarf_section
* section
,
4441 unsigned char * data
,
4442 unsigned char * end
,
4445 unsigned char *start
= section
->start
;
4446 int verbose_view
= 0;
4448 introduce (section
, true);
4452 static DWARF2_Internal_LineInfo saved_linfo
;
4453 DWARF2_Internal_LineInfo linfo
;
4454 unsigned char *standard_opcodes
;
4455 unsigned char *end_of_sequence
;
4458 if (startswith (section
->name
, ".debug_line.")
4459 /* Note: the following does not apply to .debug_line.dwo sections.
4460 These are full debug_line sections. */
4461 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4463 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4464 section containing just the Line Number Statements. They are
4465 created by the assembler and intended to be used alongside gcc's
4466 -ffunction-sections command line option. When the linker's
4467 garbage collection decides to discard a .text.<foo> section it
4468 can then also discard the line number information in .debug_line.<foo>.
4470 Since the section is a fragment it does not have the details
4471 needed to fill out a LineInfo structure, so instead we use the
4472 details from the last full debug_line section that we processed. */
4473 end_of_sequence
= end
;
4474 standard_opcodes
= NULL
;
4475 linfo
= saved_linfo
;
4476 /* PR 17531: file: 0522b371. */
4477 if (linfo
.li_line_range
== 0)
4479 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4482 reset_state_machine (linfo
.li_default_is_stmt
);
4486 unsigned char * hdrptr
;
4488 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4489 & end_of_sequence
)) == NULL
)
4492 printf (_(" Offset: 0x%tx\n"), data
- start
);
4493 printf (_(" Length: %" PRId64
"\n"), linfo
.li_length
);
4494 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4495 if (linfo
.li_version
>= 5)
4497 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4498 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4500 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4501 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4502 if (linfo
.li_version
>= 4)
4503 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4504 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4505 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4506 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4507 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4509 /* PR 17512: file: 1665-6428-0.004. */
4510 if (linfo
.li_line_range
== 0)
4512 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4513 linfo
.li_line_range
= 1;
4516 reset_state_machine (linfo
.li_default_is_stmt
);
4518 /* Display the contents of the Opcodes table. */
4519 standard_opcodes
= hdrptr
;
4521 /* PR 17512: file: 002-417945-0.004. */
4522 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4524 warn (_("Line Base extends beyond end of section\n"));
4528 printf (_("\n Opcodes:\n"));
4530 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4531 printf (ngettext (" Opcode %d has %d arg\n",
4532 " Opcode %d has %d args\n",
4533 standard_opcodes
[i
- 1]),
4534 i
, standard_opcodes
[i
- 1]);
4536 /* Display the contents of the Directory table. */
4537 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4539 if (linfo
.li_version
>= 5)
4541 load_debug_section_with_follow (line_str
, file
);
4543 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4545 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4551 printf (_("\n The Directory Table is empty.\n"));
4554 unsigned int last_dir_entry
= 0;
4556 printf (_("\n The Directory Table (offset 0x%tx):\n"),
4559 while (data
< end
&& *data
!= 0)
4561 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4563 data
+= strnlen ((char *) data
, end
- data
);
4568 /* PR 17512: file: 002-132094-0.004. */
4569 if (data
>= end
- 1)
4573 /* Skip the NUL at the end of the table. */
4577 /* Display the contents of the File Name table. */
4578 if (data
>= end
|| *data
== 0)
4579 printf (_("\n The File Name Table is empty.\n"));
4582 printf (_("\n The File Name Table (offset 0x%tx):\n"),
4584 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4586 while (data
< end
&& *data
!= 0)
4588 unsigned char *name
;
4591 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4593 data
+= strnlen ((char *) data
, end
- data
);
4597 READ_ULEB (val
, data
, end
);
4598 printf ("%" PRIu64
"\t", val
);
4599 READ_ULEB (val
, data
, end
);
4600 printf ("%" PRIu64
"\t", val
);
4601 READ_ULEB (val
, data
, end
);
4602 printf ("%" PRIu64
"\t", val
);
4603 printf ("%.*s\n", (int)(end
- name
), name
);
4607 warn (_("Corrupt file name table entry\n"));
4613 /* Skip the NUL at the end of the table. */
4619 saved_linfo
= linfo
;
4622 /* Now display the statements. */
4623 if (data
>= end_of_sequence
)
4624 printf (_(" No Line Number Statements.\n"));
4627 printf (_(" Line Number Statements:\n"));
4629 while (data
< end_of_sequence
)
4631 unsigned char op_code
;
4635 printf (" [0x%08tx]", data
- start
);
4639 if (op_code
>= linfo
.li_opcode_base
)
4641 op_code
-= linfo
.li_opcode_base
;
4642 uladv
= (op_code
/ linfo
.li_line_range
);
4643 if (linfo
.li_max_ops_per_insn
== 1)
4645 uladv
*= linfo
.li_min_insn_length
;
4646 state_machine_regs
.address
+= uladv
;
4648 state_machine_regs
.view
= 0;
4649 printf (_(" Special opcode %d: "
4650 "advance Address by %" PRIu64
4651 " to 0x%" PRIx64
"%s"),
4652 op_code
, uladv
, state_machine_regs
.address
,
4653 verbose_view
&& uladv
4654 ? _(" (reset view)") : "");
4659 = ((state_machine_regs
.op_index
+ uladv
)
4660 / linfo
.li_max_ops_per_insn
)
4661 * linfo
.li_min_insn_length
;
4663 state_machine_regs
.address
+= addrdelta
;
4664 state_machine_regs
.op_index
4665 = (state_machine_regs
.op_index
+ uladv
)
4666 % linfo
.li_max_ops_per_insn
;
4668 state_machine_regs
.view
= 0;
4669 printf (_(" Special opcode %d: "
4670 "advance Address by %" PRIu64
4671 " to 0x%" PRIx64
"[%d]%s"),
4672 op_code
, uladv
, state_machine_regs
.address
,
4673 state_machine_regs
.op_index
,
4674 verbose_view
&& addrdelta
4675 ? _(" (reset view)") : "");
4677 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4678 state_machine_regs
.line
+= adv
;
4679 printf (_(" and Line by %" PRId64
" to %d"),
4680 adv
, state_machine_regs
.line
);
4681 if (verbose_view
|| state_machine_regs
.view
)
4682 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4685 state_machine_regs
.view
++;
4690 case DW_LNS_extended_op
:
4691 data
+= process_extended_line_op (data
,
4692 linfo
.li_default_is_stmt
,
4697 printf (_(" Copy"));
4698 if (verbose_view
|| state_machine_regs
.view
)
4699 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4702 state_machine_regs
.view
++;
4705 case DW_LNS_advance_pc
:
4706 READ_ULEB (uladv
, data
, end
);
4707 if (linfo
.li_max_ops_per_insn
== 1)
4709 uladv
*= linfo
.li_min_insn_length
;
4710 state_machine_regs
.address
+= uladv
;
4712 state_machine_regs
.view
= 0;
4713 printf (_(" Advance PC by %" PRIu64
4714 " to 0x%" PRIx64
"%s\n"),
4715 uladv
, state_machine_regs
.address
,
4716 verbose_view
&& uladv
4717 ? _(" (reset view)") : "");
4722 = ((state_machine_regs
.op_index
+ uladv
)
4723 / linfo
.li_max_ops_per_insn
)
4724 * linfo
.li_min_insn_length
;
4725 state_machine_regs
.address
4727 state_machine_regs
.op_index
4728 = (state_machine_regs
.op_index
+ uladv
)
4729 % linfo
.li_max_ops_per_insn
;
4731 state_machine_regs
.view
= 0;
4732 printf (_(" Advance PC by %" PRIu64
4733 " to 0x%" PRIx64
"[%d]%s\n"),
4734 uladv
, state_machine_regs
.address
,
4735 state_machine_regs
.op_index
,
4736 verbose_view
&& addrdelta
4737 ? _(" (reset view)") : "");
4741 case DW_LNS_advance_line
:
4742 READ_SLEB (adv
, data
, end
);
4743 state_machine_regs
.line
+= adv
;
4744 printf (_(" Advance Line by %" PRId64
" to %d\n"),
4745 adv
, state_machine_regs
.line
);
4748 case DW_LNS_set_file
:
4749 READ_ULEB (uladv
, data
, end
);
4750 printf (_(" Set File Name to entry %" PRIu64
4751 " in the File Name Table\n"), uladv
);
4752 state_machine_regs
.file
= uladv
;
4755 case DW_LNS_set_column
:
4756 READ_ULEB (uladv
, data
, end
);
4757 printf (_(" Set column to %" PRIu64
"\n"), uladv
);
4758 state_machine_regs
.column
= uladv
;
4761 case DW_LNS_negate_stmt
:
4762 adv
= state_machine_regs
.is_stmt
;
4764 printf (_(" Set is_stmt to %" PRId64
"\n"), adv
);
4765 state_machine_regs
.is_stmt
= adv
;
4768 case DW_LNS_set_basic_block
:
4769 printf (_(" Set basic block\n"));
4770 state_machine_regs
.basic_block
= 1;
4773 case DW_LNS_const_add_pc
:
4774 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4775 if (linfo
.li_max_ops_per_insn
)
4777 uladv
*= linfo
.li_min_insn_length
;
4778 state_machine_regs
.address
+= uladv
;
4780 state_machine_regs
.view
= 0;
4781 printf (_(" Advance PC by constant %" PRIu64
4782 " to 0x%" PRIx64
"%s\n"),
4783 uladv
, state_machine_regs
.address
,
4784 verbose_view
&& uladv
4785 ? _(" (reset view)") : "");
4790 = ((state_machine_regs
.op_index
+ uladv
)
4791 / linfo
.li_max_ops_per_insn
)
4792 * linfo
.li_min_insn_length
;
4793 state_machine_regs
.address
4795 state_machine_regs
.op_index
4796 = (state_machine_regs
.op_index
+ uladv
)
4797 % linfo
.li_max_ops_per_insn
;
4799 state_machine_regs
.view
= 0;
4800 printf (_(" Advance PC by constant %" PRIu64
4801 " to 0x%" PRIx64
"[%d]%s\n"),
4802 uladv
, state_machine_regs
.address
,
4803 state_machine_regs
.op_index
,
4804 verbose_view
&& addrdelta
4805 ? _(" (reset view)") : "");
4809 case DW_LNS_fixed_advance_pc
:
4810 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4811 state_machine_regs
.address
+= uladv
;
4812 state_machine_regs
.op_index
= 0;
4813 printf (_(" Advance PC by fixed size amount %" PRIu64
4814 " to 0x%" PRIx64
"\n"),
4815 uladv
, state_machine_regs
.address
);
4816 /* Do NOT reset view. */
4819 case DW_LNS_set_prologue_end
:
4820 printf (_(" Set prologue_end to true\n"));
4823 case DW_LNS_set_epilogue_begin
:
4824 printf (_(" Set epilogue_begin to true\n"));
4827 case DW_LNS_set_isa
:
4828 READ_ULEB (uladv
, data
, end
);
4829 printf (_(" Set ISA to %" PRIu64
"\n"), uladv
);
4833 printf (_(" Unknown opcode %d with operands: "), op_code
);
4835 if (standard_opcodes
!= NULL
)
4836 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4838 READ_ULEB (uladv
, data
, end
);
4839 printf ("0x%" PRIx64
"%s", uladv
, i
== 1 ? "" : ", ");
4854 unsigned char *name
;
4855 unsigned int directory_index
;
4856 unsigned int modification_date
;
4857 unsigned int length
;
4860 /* Output a decoded representation of the .debug_line section. */
4863 display_debug_lines_decoded (struct dwarf_section
* section
,
4864 unsigned char * start
,
4865 unsigned char * data
,
4866 unsigned char * end
,
4869 static DWARF2_Internal_LineInfo saved_linfo
;
4871 introduce (section
, false);
4875 /* This loop amounts to one iteration per compilation unit. */
4876 DWARF2_Internal_LineInfo linfo
;
4877 unsigned char *standard_opcodes
;
4878 unsigned char *end_of_sequence
;
4880 File_Entry
*file_table
= NULL
;
4881 unsigned int n_files
= 0;
4882 unsigned char **directory_table
= NULL
;
4883 uint64_t n_directories
= 0;
4885 if (startswith (section
->name
, ".debug_line.")
4886 /* Note: the following does not apply to .debug_line.dwo sections.
4887 These are full debug_line sections. */
4888 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4890 /* See comment in display_debug_lines_raw(). */
4891 end_of_sequence
= end
;
4892 standard_opcodes
= NULL
;
4893 linfo
= saved_linfo
;
4894 /* PR 17531: file: 0522b371. */
4895 if (linfo
.li_line_range
== 0)
4897 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4900 reset_state_machine (linfo
.li_default_is_stmt
);
4904 unsigned char *hdrptr
;
4906 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4907 & end_of_sequence
)) == NULL
)
4910 /* PR 17531: file: 0522b371. */
4911 if (linfo
.li_line_range
== 0)
4913 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4914 linfo
.li_line_range
= 1;
4916 reset_state_machine (linfo
.li_default_is_stmt
);
4918 /* Save a pointer to the contents of the Opcodes table. */
4919 standard_opcodes
= hdrptr
;
4921 /* Traverse the Directory table just to count entries. */
4922 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4926 warn (_("opcode base of %d extends beyond end of section\n"),
4927 linfo
.li_opcode_base
);
4931 if (linfo
.li_version
>= 5)
4933 unsigned char *format_start
, format_count
, *format
;
4934 uint64_t formati
, entryi
;
4936 load_debug_section_with_follow (line_str
, fileptr
);
4938 /* Skip directories format. */
4939 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4940 if (do_checks
&& format_count
> 1)
4941 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4943 format_start
= data
;
4944 for (formati
= 0; formati
< format_count
; formati
++)
4946 SKIP_ULEB (data
, end
);
4947 SKIP_ULEB (data
, end
);
4950 READ_ULEB (n_directories
, data
, end
);
4953 warn (_("Corrupt directories list\n"));
4957 if (n_directories
== 0)
4958 directory_table
= NULL
;
4960 directory_table
= (unsigned char **)
4961 xmalloc (n_directories
* sizeof (unsigned char *));
4963 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4965 unsigned char **pathp
= &directory_table
[entryi
];
4967 format
= format_start
;
4968 for (formati
= 0; formati
< format_count
; formati
++)
4970 uint64_t content_type
, form
;
4973 READ_ULEB (content_type
, format
, end
);
4974 READ_ULEB (form
, format
, end
);
4977 warn (_("Corrupt directories list\n"));
4980 switch (content_type
)
4985 case DW_FORM_string
:
4988 case DW_FORM_line_strp
:
4989 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4991 /* Remove const by the cast. */
4992 *pathp
= (unsigned char *)
4993 fetch_indirect_line_string (uvalue
);
4998 data
= read_and_display_attr_value (0, form
, 0, start
,
5000 linfo
.li_offset_size
,
5007 warn (_("Corrupt directories list\n"));
5012 /* Skip files format. */
5013 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
5014 if (do_checks
&& format_count
> 5)
5015 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
5017 format_start
= data
;
5018 for (formati
= 0; formati
< format_count
; formati
++)
5020 SKIP_ULEB (data
, end
);
5021 SKIP_ULEB (data
, end
);
5024 READ_ULEB (n_files
, data
, end
);
5025 if (data
>= end
&& n_files
> 0)
5027 warn (_("Corrupt file name list\n"));
5034 file_table
= (File_Entry
*) xcalloc (1, n_files
5035 * sizeof (File_Entry
));
5037 for (entryi
= 0; entryi
< n_files
; entryi
++)
5039 File_Entry
*file
= &file_table
[entryi
];
5041 format
= format_start
;
5042 for (formati
= 0; formati
< format_count
; formati
++)
5044 uint64_t content_type
, form
;
5048 READ_ULEB (content_type
, format
, end
);
5049 READ_ULEB (form
, format
, end
);
5052 warn (_("Corrupt file name list\n"));
5055 switch (content_type
)
5060 case DW_FORM_string
:
5063 case DW_FORM_line_strp
:
5064 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
5066 /* Remove const by the cast. */
5067 file
->name
= (unsigned char *)
5068 fetch_indirect_line_string (uvalue
);
5072 case DW_LNCT_directory_index
:
5076 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5080 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5085 READ_ULEB (file
->directory_index
, tmp
, end
);
5090 data
= read_and_display_attr_value (0, form
, 0, start
,
5092 linfo
.li_offset_size
,
5099 warn (_("Corrupt file name list\n"));
5108 unsigned char *ptr_directory_table
= data
;
5110 while (data
< end
&& *data
!= 0)
5112 data
+= strnlen ((char *) data
, end
- data
);
5121 warn (_("directory table ends unexpectedly\n"));
5126 /* Go through the directory table again to save the directories. */
5127 directory_table
= (unsigned char **)
5128 xmalloc (n_directories
* sizeof (unsigned char *));
5131 while (*ptr_directory_table
!= 0)
5133 directory_table
[i
] = ptr_directory_table
;
5135 += strlen ((char *) ptr_directory_table
) + 1;
5139 /* Skip the NUL at the end of the table. */
5142 /* Traverse the File Name table just to count the entries. */
5143 if (data
< end
&& *data
!= 0)
5145 unsigned char *ptr_file_name_table
= data
;
5147 while (data
< end
&& *data
!= 0)
5149 /* Skip Name, directory index, last modification
5150 time and length of file. */
5151 data
+= strnlen ((char *) data
, end
- data
);
5154 SKIP_ULEB (data
, end
);
5155 SKIP_ULEB (data
, end
);
5156 SKIP_ULEB (data
, end
);
5162 warn (_("file table ends unexpectedly\n"));
5167 /* Go through the file table again to save the strings. */
5168 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5171 while (*ptr_file_name_table
!= 0)
5173 file_table
[i
].name
= ptr_file_name_table
;
5175 += strlen ((char *) ptr_file_name_table
) + 1;
5177 /* We are not interested in directory, time or size. */
5178 READ_ULEB (file_table
[i
].directory_index
,
5179 ptr_file_name_table
, end
);
5180 READ_ULEB (file_table
[i
].modification_date
,
5181 ptr_file_name_table
, end
);
5182 READ_ULEB (file_table
[i
].length
,
5183 ptr_file_name_table
, end
);
5189 /* Skip the NUL at the end of the table. */
5193 /* Print the Compilation Unit's name and a header. */
5194 if (file_table
== NULL
)
5195 printf (_("CU: No directory table\n"));
5196 else if (directory_table
== NULL
)
5197 printf (_("CU: %s:\n"), file_table
[0].name
);
5200 unsigned int ix
= file_table
[0].directory_index
;
5201 const char *directory
;
5206 else if (n_directories
== 0)
5207 directory
= _("<unknown>");
5208 else if (ix
> n_directories
)
5210 warn (_("directory index %u > number of directories %" PRIu64
"\n"),
5212 directory
= _("<corrupt>");
5215 directory
= (char *) directory_table
[ix
- 1];
5218 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5220 printf ("%s:\n", file_table
[0].name
);
5224 printf (_("File name Line number Starting address View Stmt\n"));
5226 printf (_("CU: Empty file name table\n"));
5227 saved_linfo
= linfo
;
5230 /* This loop iterates through the Dwarf Line Number Program. */
5231 while (data
< end_of_sequence
)
5233 unsigned char op_code
;
5236 unsigned long int uladv
;
5237 int is_special_opcode
= 0;
5242 if (op_code
>= linfo
.li_opcode_base
)
5244 op_code
-= linfo
.li_opcode_base
;
5245 uladv
= (op_code
/ linfo
.li_line_range
);
5246 if (linfo
.li_max_ops_per_insn
== 1)
5248 uladv
*= linfo
.li_min_insn_length
;
5249 state_machine_regs
.address
+= uladv
;
5251 state_machine_regs
.view
= 0;
5256 = ((state_machine_regs
.op_index
+ uladv
)
5257 / linfo
.li_max_ops_per_insn
)
5258 * linfo
.li_min_insn_length
;
5259 state_machine_regs
.address
5261 state_machine_regs
.op_index
5262 = (state_machine_regs
.op_index
+ uladv
)
5263 % linfo
.li_max_ops_per_insn
;
5265 state_machine_regs
.view
= 0;
5268 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5269 state_machine_regs
.line
+= adv
;
5270 is_special_opcode
= 1;
5271 /* Increment view after printing this row. */
5276 case DW_LNS_extended_op
:
5278 unsigned int ext_op_code_len
;
5279 unsigned char ext_op_code
;
5280 unsigned char *op_code_end
;
5281 unsigned char *op_code_data
= data
;
5283 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5284 op_code_end
= op_code_data
+ ext_op_code_len
;
5285 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5287 warn (_("Badly formed extended line op encountered!\n"));
5290 ext_op_code
= *op_code_data
++;
5294 switch (ext_op_code
)
5296 case DW_LNE_end_sequence
:
5297 /* Reset stuff after printing this row. */
5299 case DW_LNE_set_address
:
5300 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5302 op_code_end
- op_code_data
,
5304 state_machine_regs
.op_index
= 0;
5305 state_machine_regs
.view
= 0;
5307 case DW_LNE_define_file
:
5308 file_table
= (File_Entry
*) xrealloc
5309 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5311 ++state_machine_regs
.last_file_entry
;
5312 /* Source file name. */
5313 file_table
[n_files
].name
= op_code_data
;
5314 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5315 /* Directory index. */
5316 READ_ULEB (file_table
[n_files
].directory_index
,
5317 op_code_data
, op_code_end
);
5318 /* Last modification time. */
5319 READ_ULEB (file_table
[n_files
].modification_date
,
5320 op_code_data
, op_code_end
);
5322 READ_ULEB (file_table
[n_files
].length
,
5323 op_code_data
, op_code_end
);
5327 case DW_LNE_set_discriminator
:
5328 case DW_LNE_HP_set_sequence
:
5329 /* Simply ignored. */
5333 printf (_("UNKNOWN (%u): length %ld\n"),
5334 ext_op_code
, (long int) (op_code_data
- data
));
5341 /* Increment view after printing this row. */
5344 case DW_LNS_advance_pc
:
5345 READ_ULEB (uladv
, data
, end
);
5346 if (linfo
.li_max_ops_per_insn
== 1)
5348 uladv
*= linfo
.li_min_insn_length
;
5349 state_machine_regs
.address
+= uladv
;
5351 state_machine_regs
.view
= 0;
5356 = ((state_machine_regs
.op_index
+ uladv
)
5357 / linfo
.li_max_ops_per_insn
)
5358 * linfo
.li_min_insn_length
;
5359 state_machine_regs
.address
5361 state_machine_regs
.op_index
5362 = (state_machine_regs
.op_index
+ uladv
)
5363 % linfo
.li_max_ops_per_insn
;
5365 state_machine_regs
.view
= 0;
5369 case DW_LNS_advance_line
:
5370 READ_SLEB (adv
, data
, end
);
5371 state_machine_regs
.line
+= adv
;
5374 case DW_LNS_set_file
:
5375 READ_ULEB (uladv
, data
, end
);
5376 state_machine_regs
.file
= uladv
;
5379 unsigned file
= state_machine_regs
.file
;
5382 if (linfo
.li_version
< 5)
5384 if (file_table
== NULL
|| n_files
== 0)
5385 printf (_("\n [Use file table entry %d]\n"), file
);
5387 else if (file
>= n_files
)
5389 warn (_("file index %u > number of files %u\n"), file
, n_files
);
5390 printf (_("\n <over large file table index %u>"), file
);
5392 else if ((dir
= file_table
[file
].directory_index
) == 0)
5393 /* If directory index is 0, that means current directory. */
5394 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5395 else if (directory_table
== NULL
|| n_directories
== 0)
5396 printf (_("\n [Use file %s in directory table entry %d]\n"),
5397 file_table
[file
].name
, dir
);
5399 else if (dir
> n_directories
)
5401 warn (_("directory index %u > number of directories %" PRIu64
"\n"),
5402 dir
, n_directories
);
5403 printf (_("\n <over large directory table entry %u>\n"), dir
);
5406 printf ("\n%s/%s:\n",
5407 /* The directory index starts counting at 1. */
5408 directory_table
[dir
- 1], file_table
[file
].name
);
5412 case DW_LNS_set_column
:
5413 READ_ULEB (uladv
, data
, end
);
5414 state_machine_regs
.column
= uladv
;
5417 case DW_LNS_negate_stmt
:
5418 adv
= state_machine_regs
.is_stmt
;
5420 state_machine_regs
.is_stmt
= adv
;
5423 case DW_LNS_set_basic_block
:
5424 state_machine_regs
.basic_block
= 1;
5427 case DW_LNS_const_add_pc
:
5428 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5429 if (linfo
.li_max_ops_per_insn
== 1)
5431 uladv
*= linfo
.li_min_insn_length
;
5432 state_machine_regs
.address
+= uladv
;
5434 state_machine_regs
.view
= 0;
5439 = ((state_machine_regs
.op_index
+ uladv
)
5440 / linfo
.li_max_ops_per_insn
)
5441 * linfo
.li_min_insn_length
;
5442 state_machine_regs
.address
5444 state_machine_regs
.op_index
5445 = (state_machine_regs
.op_index
+ uladv
)
5446 % linfo
.li_max_ops_per_insn
;
5448 state_machine_regs
.view
= 0;
5452 case DW_LNS_fixed_advance_pc
:
5453 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5454 state_machine_regs
.address
+= uladv
;
5455 state_machine_regs
.op_index
= 0;
5456 /* Do NOT reset view. */
5459 case DW_LNS_set_prologue_end
:
5462 case DW_LNS_set_epilogue_begin
:
5465 case DW_LNS_set_isa
:
5466 READ_ULEB (uladv
, data
, end
);
5467 printf (_(" Set ISA to %lu\n"), uladv
);
5471 printf (_(" Unknown opcode %d with operands: "), op_code
);
5473 if (standard_opcodes
!= NULL
)
5474 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5478 READ_ULEB (val
, data
, end
);
5479 printf ("0x%" PRIx64
"%s", val
, i
== 1 ? "" : ", ");
5485 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5486 to the DWARF address/line matrix. */
5487 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5488 || (xop
== DW_LNS_copy
))
5490 const unsigned int MAX_FILENAME_LENGTH
= 35;
5492 char *newFileName
= NULL
;
5493 size_t fileNameLength
;
5497 unsigned indx
= state_machine_regs
.file
;
5499 if (linfo
.li_version
< 5)
5502 if (indx
>= n_files
)
5504 warn (_("corrupt file index %u encountered\n"), indx
);
5505 fileName
= _("<corrupt>");
5508 fileName
= (char *) file_table
[indx
].name
;
5511 fileName
= _("<unknown>");
5513 fileNameLength
= strlen (fileName
);
5514 newFileName
= fileName
;
5515 if (fileNameLength
> MAX_FILENAME_LENGTH
&& !do_wide
)
5517 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5518 /* Truncate file name */
5519 memcpy (newFileName
,
5520 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5521 MAX_FILENAME_LENGTH
);
5522 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5525 /* A row with end_seq set to true has a meaningful address, but
5526 the other information in the same row is not significant.
5527 In such a row, print line as "-", and don't print
5529 if (!do_wide
|| fileNameLength
<= MAX_FILENAME_LENGTH
)
5531 if (linfo
.li_max_ops_per_insn
== 1)
5533 if (xop
== -DW_LNE_end_sequence
)
5534 printf ("%-35s %11s %#18" PRIx64
,
5536 state_machine_regs
.address
);
5538 printf ("%-35s %11d %#18" PRIx64
,
5539 newFileName
, state_machine_regs
.line
,
5540 state_machine_regs
.address
);
5544 if (xop
== -DW_LNE_end_sequence
)
5545 printf ("%-35s %11s %#18" PRIx64
"[%d]",
5547 state_machine_regs
.address
,
5548 state_machine_regs
.op_index
);
5550 printf ("%-35s %11d %#18" PRIx64
"[%d]",
5551 newFileName
, state_machine_regs
.line
,
5552 state_machine_regs
.address
,
5553 state_machine_regs
.op_index
);
5558 if (linfo
.li_max_ops_per_insn
== 1)
5560 if (xop
== -DW_LNE_end_sequence
)
5561 printf ("%s %11s %#18" PRIx64
,
5563 state_machine_regs
.address
);
5565 printf ("%s %11d %#18" PRIx64
,
5566 newFileName
, state_machine_regs
.line
,
5567 state_machine_regs
.address
);
5571 if (xop
== -DW_LNE_end_sequence
)
5572 printf ("%s %11s %#18" PRIx64
"[%d]",
5574 state_machine_regs
.address
,
5575 state_machine_regs
.op_index
);
5577 printf ("%s %11d %#18" PRIx64
"[%d]",
5578 newFileName
, state_machine_regs
.line
,
5579 state_machine_regs
.address
,
5580 state_machine_regs
.op_index
);
5584 if (xop
!= -DW_LNE_end_sequence
)
5586 if (state_machine_regs
.view
)
5587 printf (" %6u", state_machine_regs
.view
);
5591 if (state_machine_regs
.is_stmt
)
5596 state_machine_regs
.view
++;
5598 if (xop
== -DW_LNE_end_sequence
)
5600 reset_state_machine (linfo
.li_default_is_stmt
);
5604 if (newFileName
!= fileName
)
5616 if (directory_table
)
5618 free (directory_table
);
5619 directory_table
= NULL
;
5630 display_debug_lines (struct dwarf_section
*section
, void *file
)
5632 unsigned char *data
= section
->start
;
5633 unsigned char *end
= data
+ section
->size
;
5635 int retValDecoded
= 1;
5637 if (do_debug_lines
== 0)
5638 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5640 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5641 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5643 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5644 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5646 if (!retValRaw
|| !retValDecoded
)
5653 find_debug_info_for_offset (uint64_t offset
)
5657 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5660 for (i
= 0; i
< num_debug_info_entries
; i
++)
5661 if (debug_information
[i
].cu_offset
== offset
)
5662 return debug_information
+ i
;
5668 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5670 /* See gdb/gdb-index.h. */
5671 static const char * const kinds
[] =
5683 return _ (kinds
[kind
]);
5687 display_debug_pubnames_worker (struct dwarf_section
*section
,
5688 void *file ATTRIBUTE_UNUSED
,
5691 DWARF2_Internal_PubNames names
;
5692 unsigned char *start
= section
->start
;
5693 unsigned char *end
= start
+ section
->size
;
5695 /* It does not matter if this load fails,
5696 we test for that later on. */
5697 load_debug_info (file
);
5699 introduce (section
, false);
5703 unsigned char *data
;
5704 unsigned long sec_off
= start
- section
->start
;
5705 unsigned int offset_size
;
5707 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5708 if (names
.pn_length
== 0xffffffff)
5710 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5716 if (names
.pn_length
> (size_t) (end
- start
))
5718 warn (_("Debug info is corrupted, "
5719 "%s header at %#lx has length %#" PRIx64
"\n"),
5720 section
->name
, sec_off
, names
.pn_length
);
5725 start
+= names
.pn_length
;
5727 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
5728 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
5730 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5731 && num_debug_info_entries
> 0
5732 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5733 warn (_(".debug_info offset of %#" PRIx64
5734 " in %s section does not point to a CU header.\n"),
5735 names
.pn_offset
, section
->name
);
5737 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
5739 printf (_(" Length: %" PRId64
"\n"),
5741 printf (_(" Version: %d\n"),
5743 printf (_(" Offset into .debug_info section: 0x%" PRIx64
"\n"),
5745 printf (_(" Size of area in .debug_info section: %" PRId64
"\n"),
5748 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5750 static int warned
= 0;
5754 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5762 printf (_("\n Offset Kind Name\n"));
5764 printf (_("\n Offset\tName\n"));
5771 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
5778 maxprint
= (start
- data
) - 1;
5782 unsigned int kind_data
;
5783 gdb_index_symbol_kind kind
;
5784 const char *kind_name
;
5787 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
5789 /* GCC computes the kind as the upper byte in the CU index
5790 word, and then right shifts it by the CU index size.
5791 Left shift KIND to where the gdb-index.h accessor macros
5793 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5794 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5795 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5796 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5797 printf (" %-6" PRIx64
" %s,%-10s %.*s\n",
5798 offset
, is_static
? _("s") : _("g"),
5799 kind_name
, (int) maxprint
, data
);
5802 printf (" %-6" PRIx64
"\t%.*s\n",
5803 offset
, (int) maxprint
, data
);
5805 data
+= strnlen ((char *) data
, maxprint
);
5818 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5820 return display_debug_pubnames_worker (section
, file
, 0);
5824 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5826 return display_debug_pubnames_worker (section
, file
, 1);
5830 display_debug_macinfo (struct dwarf_section
*section
,
5831 void *file ATTRIBUTE_UNUSED
)
5833 unsigned char *start
= section
->start
;
5834 unsigned char *end
= start
+ section
->size
;
5835 unsigned char *curr
= start
;
5836 enum dwarf_macinfo_record_type op
;
5838 introduce (section
, false);
5842 unsigned int lineno
;
5843 const unsigned char *string
;
5845 op
= (enum dwarf_macinfo_record_type
) *curr
;
5850 case DW_MACINFO_start_file
:
5852 unsigned int filenum
;
5854 READ_ULEB (lineno
, curr
, end
);
5855 READ_ULEB (filenum
, curr
, end
);
5856 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5861 case DW_MACINFO_end_file
:
5862 printf (_(" DW_MACINFO_end_file\n"));
5865 case DW_MACINFO_define
:
5866 READ_ULEB (lineno
, curr
, end
);
5868 curr
+= strnlen ((char *) string
, end
- string
);
5869 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
5870 lineno
, (int) (curr
- string
), string
);
5875 case DW_MACINFO_undef
:
5876 READ_ULEB (lineno
, curr
, end
);
5878 curr
+= strnlen ((char *) string
, end
- string
);
5879 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
5880 lineno
, (int) (curr
- string
), string
);
5885 case DW_MACINFO_vendor_ext
:
5887 unsigned int constant
;
5889 READ_ULEB (constant
, curr
, end
);
5891 curr
+= strnlen ((char *) string
, end
- string
);
5892 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
5893 constant
, (int) (curr
- string
), string
);
5904 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5905 filename and dirname corresponding to file name table entry with index
5906 FILEIDX. Return NULL on failure. */
5908 static unsigned char *
5909 get_line_filename_and_dirname (uint64_t line_offset
,
5911 unsigned char **dir_name
)
5913 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5914 unsigned char *hdrptr
, *dirtable
, *file_name
;
5915 unsigned int offset_size
;
5916 unsigned int version
, opcode_base
;
5917 uint64_t length
, diridx
;
5918 const unsigned char * end
;
5921 if (section
->start
== NULL
5922 || line_offset
>= section
->size
5926 hdrptr
= section
->start
+ line_offset
;
5927 end
= section
->start
+ section
->size
;
5929 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5930 if (length
== 0xffffffff)
5932 /* This section is 64-bit DWARF 3. */
5933 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5939 if (length
> (size_t) (end
- hdrptr
)
5940 || length
< 2 + offset_size
+ 1 + 3 + 1)
5942 end
= hdrptr
+ length
;
5944 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5945 if (version
!= 2 && version
!= 3 && version
!= 4)
5947 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5949 hdrptr
++; /* Skip max_ops_per_insn. */
5950 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5952 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5953 if (opcode_base
== 0
5954 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
5957 hdrptr
+= opcode_base
- 1;
5960 /* Skip over dirname table. */
5961 while (*hdrptr
!= '\0')
5963 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5969 hdrptr
++; /* Skip the NUL at the end of the table. */
5971 /* Now skip over preceding filename table entries. */
5972 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5974 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5977 SKIP_ULEB (hdrptr
, end
);
5978 SKIP_ULEB (hdrptr
, end
);
5979 SKIP_ULEB (hdrptr
, end
);
5981 if (hdrptr
>= end
|| *hdrptr
== '\0')
5985 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5990 READ_ULEB (diridx
, hdrptr
, end
);
5993 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5995 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
5999 if (dirtable
>= end
|| *dirtable
== '\0')
6001 *dir_name
= dirtable
;
6006 display_debug_macro (struct dwarf_section
*section
,
6009 unsigned char *start
= section
->start
;
6010 unsigned char *end
= start
+ section
->size
;
6011 unsigned char *curr
= start
;
6012 unsigned char *extended_op_buf
[256];
6013 bool is_dwo
= false;
6014 const char *suffix
= strrchr (section
->name
, '.');
6016 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6019 load_debug_section_with_follow (str
, file
);
6020 load_debug_section_with_follow (line
, file
);
6021 load_debug_section_with_follow (str_index
, file
);
6023 introduce (section
, false);
6027 unsigned int lineno
, version
, flags
;
6028 unsigned int offset_size
;
6029 const unsigned char *string
;
6030 uint64_t line_offset
= 0, sec_offset
= curr
- start
, offset
;
6031 unsigned char **extended_ops
= NULL
;
6033 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6034 if (version
!= 4 && version
!= 5)
6036 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
6037 section
->name
, version
);
6041 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
6042 offset_size
= (flags
& 1) ? 8 : 4;
6043 printf (_(" Offset: 0x%" PRIx64
"\n"), sec_offset
);
6044 printf (_(" Version: %d\n"), version
);
6045 printf (_(" Offset size: %d\n"), offset_size
);
6048 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
6049 printf (_(" Offset into .debug_line: 0x%" PRIx64
"\n"),
6054 unsigned int i
, count
, op
;
6057 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
6059 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
6060 extended_ops
= extended_op_buf
;
6063 printf (_(" Extension opcode arguments:\n"));
6064 for (i
= 0; i
< count
; i
++)
6066 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6067 extended_ops
[op
] = curr
;
6068 READ_ULEB (nargs
, curr
, end
);
6070 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
6073 printf (_(" DW_MACRO_%02x arguments: "), op
);
6074 for (n
= 0; n
< nargs
; n
++)
6078 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6079 printf ("%s%s", get_FORM_name (form
),
6080 n
== nargs
- 1 ? "\n" : ", ");
6090 case DW_FORM_block1
:
6091 case DW_FORM_block2
:
6092 case DW_FORM_block4
:
6094 case DW_FORM_string
:
6096 case DW_FORM_sec_offset
:
6099 error (_("Invalid extension opcode form %s\n"),
6100 get_FORM_name (form
));
6116 error (_(".debug_macro section not zero terminated\n"));
6120 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6126 case DW_MACRO_define
:
6127 READ_ULEB (lineno
, curr
, end
);
6129 curr
+= strnlen ((char *) string
, end
- string
);
6130 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6131 lineno
, (int) (curr
- string
), string
);
6136 case DW_MACRO_undef
:
6137 READ_ULEB (lineno
, curr
, end
);
6139 curr
+= strnlen ((char *) string
, end
- string
);
6140 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6141 lineno
, (int) (curr
- string
), string
);
6146 case DW_MACRO_start_file
:
6148 unsigned int filenum
;
6149 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6151 READ_ULEB (lineno
, curr
, end
);
6152 READ_ULEB (filenum
, curr
, end
);
6154 if ((flags
& 2) == 0)
6155 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6158 = get_line_filename_and_dirname (line_offset
, filenum
,
6160 if (file_name
== NULL
)
6161 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6164 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6166 dir_name
!= NULL
? (const char *) dir_name
: "",
6167 dir_name
!= NULL
? "/" : "", file_name
);
6171 case DW_MACRO_end_file
:
6172 printf (_(" DW_MACRO_end_file\n"));
6175 case DW_MACRO_define_strp
:
6176 READ_ULEB (lineno
, curr
, end
);
6177 if (version
== 4 && is_dwo
)
6178 READ_ULEB (offset
, curr
, end
);
6180 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6181 string
= fetch_indirect_string (offset
);
6182 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6186 case DW_MACRO_undef_strp
:
6187 READ_ULEB (lineno
, curr
, end
);
6188 if (version
== 4 && is_dwo
)
6189 READ_ULEB (offset
, curr
, end
);
6191 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6192 string
= fetch_indirect_string (offset
);
6193 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6197 case DW_MACRO_import
:
6198 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6199 printf (_(" DW_MACRO_import - offset : 0x%" PRIx64
"\n"),
6203 case DW_MACRO_define_sup
:
6204 READ_ULEB (lineno
, curr
, end
);
6205 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6206 printf (_(" DW_MACRO_define_sup - lineno : %d"
6207 " macro offset : 0x%" PRIx64
"\n"),
6211 case DW_MACRO_undef_sup
:
6212 READ_ULEB (lineno
, curr
, end
);
6213 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6214 printf (_(" DW_MACRO_undef_sup - lineno : %d"
6215 " macro offset : 0x%" PRIx64
"\n"),
6219 case DW_MACRO_import_sup
:
6220 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6221 printf (_(" DW_MACRO_import_sup - offset : 0x%" PRIx64
"\n"),
6225 case DW_MACRO_define_strx
:
6226 case DW_MACRO_undef_strx
:
6227 READ_ULEB (lineno
, curr
, end
);
6228 READ_ULEB (offset
, curr
, end
);
6229 string
= (const unsigned char *)
6230 fetch_indexed_string (offset
, NULL
, offset_size
, false, 0);
6231 if (op
== DW_MACRO_define_strx
)
6232 printf (" DW_MACRO_define_strx ");
6234 printf (" DW_MACRO_undef_strx ");
6236 printf (_("(with offset %" PRIx64
") "), offset
);
6237 printf (_("lineno : %d macro : %s\n"),
6242 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6244 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6248 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6250 error (_(" Unknown macro opcode %02x seen\n"), op
);
6255 /* Skip over unhandled opcodes. */
6257 unsigned char *desc
= extended_ops
[op
];
6258 READ_ULEB (nargs
, desc
, end
);
6261 printf (_(" DW_MACRO_%02x\n"), op
);
6264 printf (_(" DW_MACRO_%02x -"), op
);
6265 for (n
= 0; n
< nargs
; n
++)
6269 /* DW_FORM_implicit_const is not expected here. */
6270 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6272 = read_and_display_attr_value (0, val
, 0,
6273 start
, curr
, end
, 0, 0,
6274 offset_size
, version
,
6293 display_debug_abbrev (struct dwarf_section
*section
,
6294 void *file ATTRIBUTE_UNUSED
)
6296 abbrev_entry
*entry
;
6297 unsigned char *start
= section
->start
;
6299 introduce (section
, false);
6303 uint64_t offset
= start
- section
->start
;
6304 abbrev_list
*list
= find_and_process_abbrev_set (section
, 0,
6305 section
->size
, offset
,
6310 if (list
->first_abbrev
)
6311 printf (_(" Number TAG (0x%" PRIx64
")\n"), offset
);
6313 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6317 printf (" %ld %s [%s]\n",
6319 get_TAG_name (entry
->tag
),
6320 entry
->children
? _("has children") : _("no children"));
6322 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6324 printf (" %-18s %s",
6325 get_AT_name (attr
->attribute
),
6326 get_FORM_name (attr
->form
));
6327 if (attr
->form
== DW_FORM_implicit_const
)
6328 printf (": %" PRId64
, attr
->implicit_const
);
6332 start
= list
->start_of_next_abbrevs
;
6333 free_abbrev_list (list
);
6342 /* Return true when ADDR is the maximum address, when addresses are
6343 POINTER_SIZE bytes long. */
6346 is_max_address (uint64_t addr
, unsigned int pointer_size
)
6348 uint64_t mask
= ~(~(uint64_t) 0 << 1 << (pointer_size
* 8 - 1));
6349 return ((addr
& mask
) == mask
);
6352 /* Display a view pair list starting at *VSTART_PTR and ending at
6353 VLISTEND within SECTION. */
6356 display_view_pair_list (struct dwarf_section
*section
,
6357 unsigned char **vstart_ptr
,
6358 unsigned int debug_info_entry
,
6359 unsigned char *vlistend
)
6361 unsigned char *vstart
= *vstart_ptr
;
6362 unsigned char *section_end
= section
->start
+ section
->size
;
6363 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6365 if (vlistend
< section_end
)
6366 section_end
= vlistend
;
6370 while (vstart
< section_end
)
6372 uint64_t off
= vstart
- section
->start
;
6373 uint64_t vbegin
, vend
;
6375 READ_ULEB (vbegin
, vstart
, section_end
);
6376 if (vstart
== section_end
)
6379 READ_ULEB (vend
, vstart
, section_end
);
6380 printf (" %8.8" PRIx64
" ", off
);
6382 print_view (vbegin
, pointer_size
);
6383 print_view (vend
, pointer_size
);
6384 printf (_("location view pair\n"));
6388 *vstart_ptr
= vstart
;
6391 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6394 display_loc_list (struct dwarf_section
*section
,
6395 unsigned char **start_ptr
,
6396 unsigned int debug_info_entry
,
6398 uint64_t base_address
,
6399 unsigned char **vstart_ptr
,
6402 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6403 unsigned char *section_end
= section
->start
+ section
->size
;
6405 unsigned int pointer_size
;
6406 unsigned int offset_size
;
6410 unsigned short length
;
6411 int need_frame_base
;
6413 if (debug_info_entry
>= num_debug_info_entries
)
6415 warn (_("No debug information available for loc lists of entry: %u\n"),
6420 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6421 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6422 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6423 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6425 if (pointer_size
< 2 || pointer_size
> 8)
6427 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6428 pointer_size
, debug_info_entry
);
6434 uint64_t off
= offset
+ (start
- *start_ptr
);
6435 uint64_t vbegin
= -1, vend
= -1;
6437 if (2 * pointer_size
> (size_t) (section_end
- start
))
6439 warn (_("Location list starting at offset %#" PRIx64
6440 " is not terminated.\n"), offset
);
6447 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6448 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6450 if (begin
== 0 && end
== 0)
6452 /* PR 18374: In a object file we can have a location list that
6453 starts with a begin and end of 0 because there are relocations
6454 that need to be applied to the addresses. Actually applying
6455 the relocations now does not help as they will probably resolve
6456 to 0, since the object file has not been fully linked. Real
6457 end of list markers will not have any relocations against them. */
6458 if (! reloc_at (section
, off
)
6459 && ! reloc_at (section
, off
+ pointer_size
))
6461 printf (_("<End of list>\n"));
6466 /* Check base address specifiers. */
6467 if (is_max_address (begin
, pointer_size
)
6468 && !is_max_address (end
, pointer_size
))
6471 print_hex (begin
, pointer_size
);
6472 print_hex (end
, pointer_size
);
6473 printf (_("(base address)\n"));
6479 off
= offset
+ (vstart
- *start_ptr
);
6481 READ_ULEB (vbegin
, vstart
, section_end
);
6482 print_view (vbegin
, pointer_size
);
6484 READ_ULEB (vend
, vstart
, section_end
);
6485 print_view (vend
, pointer_size
);
6487 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6490 if (2 > (size_t) (section_end
- start
))
6492 warn (_("Location list starting at offset %#" PRIx64
6493 " is not terminated.\n"), offset
);
6497 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6499 if (length
> (size_t) (section_end
- start
))
6501 warn (_("Location list starting at offset %#" PRIx64
6502 " is not terminated.\n"), offset
);
6506 print_hex (begin
+ base_address
, pointer_size
);
6507 print_hex (end
+ base_address
, pointer_size
);
6510 need_frame_base
= decode_location_expression (start
,
6515 cu_offset
, section
);
6518 if (need_frame_base
&& !has_frame_base
)
6519 printf (_(" [without DW_AT_frame_base]"));
6521 if (begin
== end
&& vbegin
== vend
)
6522 fputs (_(" (start == end)"), stdout
);
6523 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6524 fputs (_(" (start > end)"), stdout
);
6532 *vstart_ptr
= vstart
;
6535 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6538 display_loclists_list (struct dwarf_section
* section
,
6539 unsigned char ** start_ptr
,
6540 unsigned int debug_info_entry
,
6542 uint64_t base_address
,
6543 unsigned char ** vstart_ptr
,
6546 unsigned char *start
= *start_ptr
;
6547 unsigned char *vstart
= *vstart_ptr
;
6548 unsigned char *section_end
= section
->start
+ section
->size
;
6550 unsigned int pointer_size
;
6551 unsigned int offset_size
;
6552 unsigned int dwarf_version
;
6554 /* Initialize it due to a false compiler warning. */
6555 uint64_t begin
= -1, vbegin
= -1;
6556 uint64_t end
= -1, vend
= -1;
6558 int need_frame_base
;
6560 if (debug_info_entry
>= num_debug_info_entries
)
6562 warn (_("No debug information available for "
6563 "loclists lists of entry: %u\n"),
6568 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6569 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6570 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6571 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6573 if (pointer_size
< 2 || pointer_size
> 8)
6575 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6576 pointer_size
, debug_info_entry
);
6582 uint64_t off
= offset
+ (start
- *start_ptr
);
6583 enum dwarf_location_list_entry_type llet
;
6585 if (start
+ 1 > section_end
)
6587 warn (_("Location list starting at offset %#" PRIx64
6588 " is not terminated.\n"), offset
);
6595 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6597 if (vstart
&& (llet
== DW_LLE_offset_pair
6598 || llet
== DW_LLE_start_end
6599 || llet
== DW_LLE_start_length
))
6601 off
= offset
+ (vstart
- *start_ptr
);
6603 READ_ULEB (vbegin
, vstart
, section_end
);
6604 print_view (vbegin
, pointer_size
);
6606 READ_ULEB (vend
, vstart
, section_end
);
6607 print_view (vend
, pointer_size
);
6609 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6614 case DW_LLE_end_of_list
:
6615 printf (_("<End of list>\n"));
6618 case DW_LLE_base_addressx
:
6619 READ_ULEB (base_address
, start
, section_end
);
6620 print_hex (base_address
, pointer_size
);
6621 printf (_("(index into .debug_addr) "));
6622 base_address
= fetch_indexed_addr (base_address
, pointer_size
);
6623 print_hex (base_address
, pointer_size
);
6624 printf (_("(base address)\n"));
6627 case DW_LLE_startx_endx
:
6628 READ_ULEB (begin
, start
, section_end
);
6629 begin
= fetch_indexed_addr (begin
, pointer_size
);
6630 READ_ULEB (end
, start
, section_end
);
6631 end
= fetch_indexed_addr (end
, pointer_size
);
6634 case DW_LLE_startx_length
:
6635 READ_ULEB (begin
, start
, section_end
);
6636 begin
= fetch_indexed_addr (begin
, pointer_size
);
6637 READ_ULEB (end
, start
, section_end
);
6641 case DW_LLE_default_location
:
6645 case DW_LLE_offset_pair
:
6646 READ_ULEB (begin
, start
, section_end
);
6647 begin
+= base_address
;
6648 READ_ULEB (end
, start
, section_end
);
6649 end
+= base_address
;
6652 case DW_LLE_base_address
:
6653 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6655 print_hex (base_address
, pointer_size
);
6656 printf (_("(base address)\n"));
6659 case DW_LLE_start_end
:
6660 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6661 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6664 case DW_LLE_start_length
:
6665 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6666 READ_ULEB (end
, start
, section_end
);
6670 #ifdef DW_LLE_view_pair
6671 case DW_LLE_view_pair
:
6673 printf (_("View pair entry in loclist with locviews attribute\n"));
6674 READ_ULEB (vbegin
, start
, section_end
);
6675 print_view (vbegin
, pointer_size
);
6677 READ_ULEB (vend
, start
, section_end
);
6678 print_view (vend
, pointer_size
);
6680 printf (_("views for:\n"));
6685 error (_("Invalid location list entry type %d\n"), llet
);
6689 if (llet
== DW_LLE_end_of_list
)
6692 if (llet
== DW_LLE_base_address
6693 || llet
== DW_LLE_base_addressx
)
6696 if (start
== section_end
)
6698 warn (_("Location list starting at offset %#" PRIx64
6699 " is not terminated.\n"), offset
);
6702 READ_ULEB (length
, start
, section_end
);
6704 if (length
> (size_t) (section_end
- start
))
6706 warn (_("Location list starting at offset %#" PRIx64
6707 " is not terminated.\n"), offset
);
6711 print_hex (begin
, pointer_size
);
6712 print_hex (end
, pointer_size
);
6715 need_frame_base
= decode_location_expression (start
,
6720 cu_offset
, section
);
6723 if (need_frame_base
&& !has_frame_base
)
6724 printf (_(" [without DW_AT_frame_base]"));
6726 if (begin
== end
&& vbegin
== vend
)
6727 fputs (_(" (start == end)"), stdout
);
6728 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6729 fputs (_(" (start > end)"), stdout
);
6737 if (vbegin
!= (uint64_t) -1 || vend
!= (uint64_t) -1)
6738 printf (_("Trailing view pair not used in a range"));
6741 *vstart_ptr
= vstart
;
6744 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6745 right-adjusted in a field of length LEN, and followed by a space. */
6748 print_addr_index (unsigned int idx
, unsigned int len
)
6750 static char buf
[15];
6751 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6752 printf ("%*s ", len
, buf
);
6755 /* Display a location list from a .dwo section. It uses address indexes rather
6756 than embedded addresses. This code closely follows display_loc_list, but the
6757 two are sufficiently different that combining things is very ugly. */
6760 display_loc_list_dwo (struct dwarf_section
*section
,
6761 unsigned char **start_ptr
,
6762 unsigned int debug_info_entry
,
6764 unsigned char **vstart_ptr
,
6767 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6768 unsigned char *section_end
= section
->start
+ section
->size
;
6770 unsigned int pointer_size
;
6771 unsigned int offset_size
;
6774 unsigned short length
;
6775 int need_frame_base
;
6778 if (debug_info_entry
>= num_debug_info_entries
)
6780 warn (_("No debug information for loc lists of entry: %u\n"),
6785 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6786 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6787 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6788 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6790 if (pointer_size
< 2 || pointer_size
> 8)
6792 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6793 pointer_size
, debug_info_entry
);
6800 print_hex (offset
+ (start
- *start_ptr
), 4);
6802 if (start
>= section_end
)
6804 warn (_("Location list starting at offset %#" PRIx64
6805 " is not terminated.\n"), offset
);
6809 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6822 uint64_t off
= offset
+ (vstart
- *start_ptr
);
6824 READ_ULEB (view
, vstart
, section_end
);
6825 print_view (view
, 8);
6827 READ_ULEB (view
, vstart
, section_end
);
6828 print_view (view
, 8);
6830 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6838 case 0: /* A terminating entry. */
6840 *vstart_ptr
= vstart
;
6841 printf (_("<End of list>\n"));
6843 case 1: /* A base-address entry. */
6844 READ_ULEB (idx
, start
, section_end
);
6845 print_addr_index (idx
, 8);
6846 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6847 printf (_("(base address selection entry)\n"));
6849 case 2: /* A start/end entry. */
6850 READ_ULEB (idx
, start
, section_end
);
6851 print_addr_index (idx
, 8);
6852 READ_ULEB (idx
, start
, section_end
);
6853 print_addr_index (idx
, 8);
6855 case 3: /* A start/length entry. */
6856 READ_ULEB (idx
, start
, section_end
);
6857 print_addr_index (idx
, 8);
6858 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6859 printf ("%08x ", idx
);
6861 case 4: /* An offset pair entry. */
6862 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6863 printf ("%08x ", idx
);
6864 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6865 printf ("%08x ", idx
);
6868 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6870 *vstart_ptr
= vstart
;
6874 if (2 > (size_t) (section_end
- start
))
6876 warn (_("Location list starting at offset %#" PRIx64
6877 " is not terminated.\n"), offset
);
6881 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6882 if (length
> (size_t) (section_end
- start
))
6884 warn (_("Location list starting at offset %#" PRIx64
6885 " is not terminated.\n"), offset
);
6890 need_frame_base
= decode_location_expression (start
,
6895 cu_offset
, section
);
6898 if (need_frame_base
&& !has_frame_base
)
6899 printf (_(" [without DW_AT_frame_base]"));
6907 *vstart_ptr
= vstart
;
6910 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6913 static uint64_t *loc_offsets
, *loc_views
;
6916 loc_offsets_compar (const void *ap
, const void *bp
)
6918 uint64_t a
= loc_offsets
[*(const unsigned int *) ap
];
6919 uint64_t b
= loc_offsets
[*(const unsigned int *) bp
];
6921 int ret
= (a
> b
) - (b
> a
);
6925 a
= loc_views
[*(const unsigned int *) ap
];
6926 b
= loc_views
[*(const unsigned int *) bp
];
6928 ret
= (a
> b
) - (b
> a
);
6934 display_offset_entry_loclists (struct dwarf_section
*section
)
6936 unsigned char * start
= section
->start
;
6937 unsigned char * const end
= start
+ section
->size
;
6939 introduce (section
, false);
6944 unsigned short version
;
6945 unsigned char address_size
;
6946 unsigned char segment_selector_size
;
6947 uint32_t offset_entry_count
;
6951 printf (_("Table at Offset 0x%tx\n"), start
- section
->start
);
6953 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
6954 if (length
== 0xffffffff)
6957 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
6962 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
6963 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, end
);
6964 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, end
);
6965 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, end
);
6967 printf (_(" Length: 0x%" PRIx64
"\n"), length
);
6968 printf (_(" DWARF version: %u\n"), version
);
6969 printf (_(" Address size: %u\n"), address_size
);
6970 printf (_(" Segment size: %u\n"), segment_selector_size
);
6971 printf (_(" Offset entries: %u\n"), offset_entry_count
);
6975 warn (_("The %s section contains a corrupt or "
6976 "unsupported version number: %d.\n"),
6977 section
->name
, version
);
6981 if (segment_selector_size
!= 0)
6983 warn (_("The %s section contains an "
6984 "unsupported segment selector size: %d.\n"),
6985 section
->name
, segment_selector_size
);
6989 if (offset_entry_count
== 0)
6991 warn (_("The %s section contains a table without offset\n"),
6996 printf (_("\n Offset Entries starting at 0x%tx:\n"),
6997 start
- section
->start
);
6999 for (i
= 0; i
< offset_entry_count
; i
++)
7003 SAFE_BYTE_GET_AND_INC (entry
, start
, is_64bit
? 8 : 4, end
);
7004 printf (_(" [%6u] 0x%" PRIx64
"\n"), i
, entry
);
7011 for (j
= 1, i
= 0; i
< offset_entry_count
;)
7014 uint64_t base_address
= 0;
7017 uint64_t off
= start
- section
->start
;
7021 printf (_(" Offset Entry %u\n"), i
);
7028 SAFE_BYTE_GET_AND_INC (lle
, start
, 1, end
);
7032 case DW_LLE_end_of_list
:
7033 printf (_("<End of list>\n\n"));
7037 case DW_LLE_base_addressx
:
7038 READ_ULEB (base_address
, start
, end
);
7039 print_hex (base_address
, address_size
);
7040 printf (_("(index into .debug_addr) "));
7041 base_address
= fetch_indexed_addr (base_address
, address_size
);
7042 print_hex (base_address
, address_size
);
7043 printf (_("(base address)\n"));
7046 case DW_LLE_startx_endx
:
7047 READ_ULEB (begin
, start
, end
);
7048 begin
= fetch_indexed_addr (begin
, address_size
);
7049 READ_ULEB (finish
, start
, end
);
7050 finish
= fetch_indexed_addr (finish
, address_size
);
7053 case DW_LLE_startx_length
:
7054 READ_ULEB (begin
, start
, end
);
7055 begin
= fetch_indexed_addr (begin
, address_size
);
7056 READ_ULEB (finish
, start
, end
);
7060 case DW_LLE_offset_pair
:
7061 READ_ULEB (begin
, start
, end
);
7062 begin
+= base_address
;
7063 READ_ULEB (finish
, start
, end
);
7064 finish
+= base_address
;
7067 case DW_LLE_default_location
:
7071 case DW_LLE_base_address
:
7072 SAFE_BYTE_GET_AND_INC (base_address
, start
, address_size
, end
);
7073 print_hex (base_address
, address_size
);
7074 printf (_("(base address)\n"));
7077 case DW_LLE_start_end
:
7078 SAFE_BYTE_GET_AND_INC (begin
, start
, address_size
, end
);
7079 SAFE_BYTE_GET_AND_INC (finish
, start
, address_size
, end
);
7082 case DW_LLE_start_length
:
7083 SAFE_BYTE_GET_AND_INC (begin
, start
, address_size
, end
);
7084 READ_ULEB (finish
, start
, end
);
7089 error (_("Invalid location list entry type %d\n"), lle
);
7095 warn (_("Location list starting at offset %#" PRIx64
7096 " is not terminated.\n"), off
);
7100 print_hex (begin
, address_size
);
7101 print_hex (finish
, address_size
);
7103 if (begin
== finish
)
7104 fputs (_("(start == end)"), stdout
);
7105 else if (begin
> finish
)
7106 fputs (_("(start > end)"), stdout
);
7108 /* Read the counted location descriptions. */
7109 READ_ULEB (length
, start
, end
);
7111 if (length
> (size_t) (end
- start
))
7113 warn (_("Location list starting at offset %#" PRIx64
7114 " is not terminated.\n"), off
);
7118 (void) decode_location_expression (start
, address_size
, address_size
,
7119 version
, length
, 0, section
);
7126 while (start
< end
);
7132 display_debug_loc (struct dwarf_section
*section
, void *file
)
7134 unsigned char *start
= section
->start
, *vstart
= NULL
;
7136 unsigned char *section_begin
= start
;
7137 unsigned int num_loc_list
= 0;
7138 uint64_t last_offset
= 0;
7139 uint64_t last_view
= 0;
7140 unsigned int first
= 0;
7143 int seen_first_offset
= 0;
7144 int locs_sorted
= 1;
7145 unsigned char *next
= start
, *vnext
= vstart
;
7146 unsigned int *array
= NULL
;
7147 const char *suffix
= strrchr (section
->name
, '.');
7148 bool is_dwo
= false;
7149 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
7150 uint64_t expected_start
= 0;
7152 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
7155 bytes
= section
->size
;
7159 printf (_("\nThe %s section is empty.\n"), section
->name
);
7165 unsigned char *hdrptr
= section_begin
;
7167 unsigned short ll_version
;
7168 unsigned char *end
= section_begin
+ section
->size
;
7169 unsigned char address_size
, segment_selector_size
;
7170 uint32_t offset_entry_count
;
7172 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
7173 if (ll_length
== 0xffffffff)
7174 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
7176 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
7177 if (ll_version
!= 5)
7179 warn (_("The %s section contains corrupt or "
7180 "unsupported version number: %d.\n"),
7181 section
->name
, ll_version
);
7185 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
7187 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
7188 if (segment_selector_size
!= 0)
7190 warn (_("The %s section contains "
7191 "unsupported segment selector size: %d.\n"),
7192 section
->name
, segment_selector_size
);
7196 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
7198 if (offset_entry_count
!= 0)
7199 return display_offset_entry_loclists (section
);
7201 expected_start
= hdrptr
- section_begin
;
7204 if (load_debug_info (file
) == 0)
7206 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7211 /* Check the order of location list in .debug_info section. If
7212 offsets of location lists are in the ascending order, we can
7213 use `debug_information' directly. */
7214 for (i
= 0; i
< num_debug_info_entries
; i
++)
7218 num
= debug_information
[i
].num_loc_offsets
;
7219 if (num
> num_loc_list
)
7222 /* Check if we can use `debug_information' directly. */
7223 if (locs_sorted
&& num
!= 0)
7225 if (!seen_first_offset
)
7227 /* This is the first location list. */
7228 last_offset
= debug_information
[i
].loc_offsets
[0];
7229 last_view
= debug_information
[i
].loc_views
[0];
7231 seen_first_offset
= 1;
7237 for (; j
< num
; j
++)
7240 debug_information
[i
].loc_offsets
[j
]
7241 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
7242 && last_view
> debug_information
[i
].loc_views
[j
]))
7247 last_offset
= debug_information
[i
].loc_offsets
[j
];
7248 last_view
= debug_information
[i
].loc_views
[j
];
7253 if (!seen_first_offset
)
7254 error (_("No location lists in .debug_info section!\n"));
7256 if (debug_information
[first
].num_loc_offsets
> 0
7257 && debug_information
[first
].loc_offsets
[0] != expected_start
7258 && debug_information
[first
].loc_views
[0] != expected_start
)
7259 warn (_("Location lists in %s section start at %#" PRIx64
7260 " rather than %#" PRIx64
"\n"),
7261 section
->name
, debug_information
[first
].loc_offsets
[0],
7265 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
7267 introduce (section
, false);
7269 if (reloc_at (section
, 0))
7270 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
7272 printf (_(" Offset Begin End Expression\n"));
7274 seen_first_offset
= 0;
7275 for (i
= first
; i
< num_debug_info_entries
; i
++)
7277 uint64_t offset
, voffset
;
7278 uint64_t base_address
;
7284 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
7286 loc_offsets
= debug_information
[i
].loc_offsets
;
7287 loc_views
= debug_information
[i
].loc_views
;
7288 qsort (array
, debug_information
[i
].num_loc_offsets
,
7289 sizeof (*array
), loc_offsets_compar
);
7292 int adjacent_view_loclists
= 1;
7293 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
7295 j
= locs_sorted
? k
: array
[k
];
7297 && (debug_information
[i
].loc_offsets
[locs_sorted
7298 ? k
- 1 : array
[k
- 1]]
7299 == debug_information
[i
].loc_offsets
[j
])
7300 && (debug_information
[i
].loc_views
[locs_sorted
7301 ? k
- 1 : array
[k
- 1]]
7302 == debug_information
[i
].loc_views
[j
]))
7304 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
7305 offset
= debug_information
[i
].loc_offsets
[j
];
7306 next
= section_begin
+ offset
;
7307 voffset
= debug_information
[i
].loc_views
[j
];
7308 if (voffset
!= (uint64_t) -1)
7309 vnext
= section_begin
+ voffset
;
7312 base_address
= debug_information
[i
].base_address
;
7314 if (vnext
&& vnext
< next
)
7317 display_view_pair_list (section
, &vstart
, i
, next
);
7322 if (!seen_first_offset
|| !adjacent_view_loclists
)
7323 seen_first_offset
= 1;
7327 warn (_("There is a hole [%#tx - %#" PRIx64
"]"
7328 " in %s section.\n"),
7329 start
- section_begin
, offset
, section
->name
);
7330 else if (start
> next
)
7331 warn (_("There is an overlap [%#tx - %#" PRIx64
"]"
7332 " in %s section.\n"),
7333 start
- section_begin
, offset
, section
->name
);
7338 if (offset
>= bytes
)
7340 warn (_("Offset %#" PRIx64
" is bigger than %s section size.\n"),
7341 offset
, section
->name
);
7345 if (vnext
&& voffset
>= bytes
)
7347 warn (_("View Offset %#" PRIx64
" is bigger than %s section size.\n"),
7348 voffset
, section
->name
);
7355 display_loc_list_dwo (section
, &start
, i
, offset
,
7356 &vstart
, has_frame_base
);
7358 display_loc_list (section
, &start
, i
, offset
, base_address
,
7359 &vstart
, has_frame_base
);
7364 warn (_("DWO is not yet supported.\n"));
7366 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7367 &vstart
, has_frame_base
);
7370 /* FIXME: this arrangement is quite simplistic. Nothing
7371 requires locview lists to be adjacent to corresponding
7372 loclists, and a single loclist could be augmented by
7373 different locview lists, and vice-versa, unlikely as it
7374 is that it would make sense to do so. Hopefully we'll
7375 have view pair support built into loclists before we ever
7376 need to address all these possibilities. */
7377 if (adjacent_view_loclists
&& vnext
7378 && vnext
!= start
&& vstart
!= next
)
7380 adjacent_view_loclists
= 0;
7381 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7384 if (vnext
&& vnext
== start
)
7385 display_view_pair_list (section
, &start
, i
, vstart
);
7389 if (start
< section
->start
+ section
->size
)
7390 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7391 "There are %ld unused bytes at the end of section %s\n",
7392 (long) (section
->start
+ section
->size
- start
)),
7393 (long) (section
->start
+ section
->size
- start
), section
->name
);
7400 display_debug_str (struct dwarf_section
*section
,
7401 void *file ATTRIBUTE_UNUSED
)
7403 unsigned char *start
= section
->start
;
7404 uint64_t bytes
= section
->size
;
7405 uint64_t addr
= section
->address
;
7409 printf (_("\nThe %s section is empty.\n"), section
->name
);
7413 introduce (section
, false);
7421 lbytes
= (bytes
> 16 ? 16 : bytes
);
7423 printf (" 0x%8.8" PRIx64
" ", addr
);
7425 for (j
= 0; j
< 16; j
++)
7428 printf ("%2.2x", start
[j
]);
7436 for (j
= 0; j
< lbytes
; j
++)
7439 if (k
>= ' ' && k
< 0x80)
7458 display_debug_info (struct dwarf_section
*section
, void *file
)
7460 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7464 display_debug_types (struct dwarf_section
*section
, void *file
)
7466 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7470 display_trace_info (struct dwarf_section
*section
, void *file
)
7472 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7476 display_debug_aranges (struct dwarf_section
*section
,
7477 void *file ATTRIBUTE_UNUSED
)
7479 unsigned char *start
= section
->start
;
7480 unsigned char *end
= start
+ section
->size
;
7482 introduce (section
, false);
7484 /* It does not matter if this load fails,
7485 we test for that later on. */
7486 load_debug_info (file
);
7490 unsigned char *hdrptr
;
7491 DWARF2_Internal_ARange arange
;
7492 unsigned char *addr_ranges
;
7496 unsigned char address_size
;
7497 unsigned int offset_size
;
7498 unsigned char *end_ranges
;
7501 sec_off
= hdrptr
- section
->start
;
7503 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7504 if (arange
.ar_length
== 0xffffffff)
7506 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7512 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7514 warn (_("Debug info is corrupted, %s header at %#" PRIx64
7515 " has length %#" PRIx64
"\n"),
7516 section
->name
, sec_off
, arange
.ar_length
);
7519 end_ranges
= hdrptr
+ arange
.ar_length
;
7521 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7522 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7525 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7526 && num_debug_info_entries
> 0
7527 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7528 warn (_(".debug_info offset of %#" PRIx64
7529 " in %s section does not point to a CU header.\n"),
7530 arange
.ar_info_offset
, section
->name
);
7532 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7533 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7535 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7537 /* PR 19872: A version number of 0 probably means that there is
7538 padding at the end of the .debug_aranges section. Gold puts
7539 it there when performing an incremental link, for example.
7540 So do not generate a warning in this case. */
7541 if (arange
.ar_version
)
7542 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7546 printf (_(" Length: %" PRId64
"\n"), arange
.ar_length
);
7547 printf (_(" Version: %d\n"), arange
.ar_version
);
7548 printf (_(" Offset into .debug_info: 0x%" PRIx64
"\n"),
7549 arange
.ar_info_offset
);
7550 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7551 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7553 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7555 /* PR 17512: file: 001-108546-0.001:0.1. */
7556 if (address_size
== 0 || address_size
> 8)
7558 error (_("Invalid address size in %s section!\n"),
7563 /* The DWARF spec does not require that the address size be a power
7564 of two, but we do. This will have to change if we ever encounter
7565 an uneven architecture. */
7566 if ((address_size
& (address_size
- 1)) != 0)
7568 warn (_("Pointer size + Segment size is not a power of two.\n"));
7572 if (address_size
> 4)
7573 printf (_("\n Address Length\n"));
7575 printf (_("\n Address Length\n"));
7577 addr_ranges
= hdrptr
;
7579 /* Must pad to an alignment boundary that is twice the address size. */
7580 addr_ranges
+= (2 * address_size
- 1
7581 - (hdrptr
- start
- 1) % (2 * address_size
));
7583 while (2 * address_size
<= end_ranges
- addr_ranges
)
7585 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
,
7587 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
,
7590 print_hex (address
, address_size
);
7591 print_hex (length
, address_size
);
7603 /* Comparison function for qsort. */
7605 comp_addr_base (const void * v0
, const void * v1
)
7607 debug_info
*info0
= *(debug_info
**) v0
;
7608 debug_info
*info1
= *(debug_info
**) v1
;
7609 return info0
->addr_base
- info1
->addr_base
;
7612 /* Display the debug_addr section. */
7614 display_debug_addr (struct dwarf_section
*section
,
7617 debug_info
**debug_addr_info
;
7618 unsigned char *entry
;
7622 unsigned char * header
;
7624 if (section
->size
== 0)
7626 printf (_("\nThe %s section is empty.\n"), section
->name
);
7630 if (load_debug_info (file
) == 0)
7632 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7637 introduce (section
, false);
7639 /* PR 17531: file: cf38d01b.
7640 We use xcalloc because a corrupt file may not have initialised all of the
7641 fields in the debug_info structure, which means that the sort below might
7642 try to move uninitialised data. */
7643 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7644 sizeof (debug_info
*));
7647 for (i
= 0; i
< num_debug_info_entries
; i
++)
7648 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7650 /* PR 17531: file: cf38d01b. */
7651 if (debug_information
[i
].addr_base
>= section
->size
)
7652 warn (_("Corrupt address base (%#" PRIx64
")"
7653 " found in debug section %u\n"),
7654 debug_information
[i
].addr_base
, i
);
7656 debug_addr_info
[count
++] = debug_information
+ i
;
7659 /* Add a sentinel to make iteration convenient. */
7660 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7661 debug_addr_info
[count
]->addr_base
= section
->size
;
7662 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7664 header
= section
->start
;
7665 for (i
= 0; i
< count
; i
++)
7668 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7670 printf (_(" For compilation unit at offset 0x%" PRIx64
":\n"),
7671 debug_addr_info
[i
]->cu_offset
);
7673 printf (_("\tIndex\tAddress\n"));
7674 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7675 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7677 size_t header_size
= entry
- header
;
7678 unsigned char *curr_header
= header
;
7681 int segment_selector_size
;
7683 if (header_size
!= 8 && header_size
!= 16)
7685 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %zd instead\n"),
7686 section
->name
, header_size
);
7690 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7691 if (length
== 0xffffffff)
7692 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7693 end
= curr_header
+ length
;
7695 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7697 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7698 section
->name
, version
);
7700 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7701 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7702 address_size
+= segment_selector_size
;
7705 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7710 uint64_t base
= byte_get (entry
, address_size
);
7711 printf (_("\t%d:\t"), idx
);
7712 print_hex (base
, address_size
);
7714 entry
+= address_size
;
7720 free (debug_addr_info
);
7724 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7727 display_debug_str_offsets (struct dwarf_section
*section
,
7728 void *file ATTRIBUTE_UNUSED
)
7732 if (section
->size
== 0)
7734 printf (_("\nThe %s section is empty.\n"), section
->name
);
7738 unsigned char *start
= section
->start
;
7739 unsigned char *end
= start
+ section
->size
;
7740 unsigned char *curr
= start
;
7741 uint64_t debug_str_offsets_hdr_len
;
7743 const char *suffix
= strrchr (section
->name
, '.');
7744 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7747 load_debug_section_with_follow (str_dwo
, file
);
7749 load_debug_section_with_follow (str
, file
);
7751 introduce (section
, false);
7756 uint64_t entry_length
;
7758 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7759 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7760 if (length
== 0xffffffff)
7762 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7764 debug_str_offsets_hdr_len
= 16;
7769 debug_str_offsets_hdr_len
= 8;
7772 unsigned char *entries_end
;
7775 /* This is probably an old style .debug_str_offset section which
7776 just contains offsets and no header (and the first offset is 0). */
7777 length
= section
->size
;
7778 curr
= section
->start
;
7781 printf (_(" Length: %#" PRIx64
"\n"), length
);
7782 printf (_(" Index Offset [String]\n"));
7786 if (length
<= (size_t) (end
- curr
))
7787 entries_end
= curr
+ length
;
7790 warn (_("Section %s is too small %#" PRIx64
"\n"),
7791 section
->name
, section
->size
);
7796 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7798 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7801 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
7803 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7805 printf (_(" Length: %#" PRIx64
"\n"), length
);
7806 printf (_(" Version: %#x\n"), version
);
7807 printf (_(" Index Offset [String]\n"));
7810 for (idx
= 0; curr
< entries_end
; idx
++)
7813 const unsigned char * string
;
7815 if ((size_t) (entries_end
- curr
) < entry_length
)
7816 /* Not enough space to read one entry_length, give up. */
7819 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7821 string
= (const unsigned char *)
7822 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
, debug_str_offsets_hdr_len
);
7824 string
= fetch_indirect_string (offset
);
7826 printf (" %8lu ", idx
);
7827 print_hex (offset
, entry_length
);
7828 printf (" %s\n", string
);
7835 /* Each debug_information[x].range_lists[y] gets this representation for
7836 sorting purposes. */
7840 /* The debug_information[x].range_lists[y] value. */
7841 uint64_t ranges_offset
;
7843 /* Original debug_information to find parameters of the data. */
7844 debug_info
*debug_info_p
;
7847 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7850 range_entry_compar (const void *ap
, const void *bp
)
7852 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7853 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7854 const uint64_t a
= a_re
->ranges_offset
;
7855 const uint64_t b
= b_re
->ranges_offset
;
7857 return (a
> b
) - (b
> a
);
7861 display_debug_ranges_list (unsigned char * start
,
7862 unsigned char * finish
,
7863 unsigned int pointer_size
,
7865 uint64_t base_address
)
7867 while (start
< finish
)
7872 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7873 if (start
>= finish
)
7875 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7878 print_hex (offset
, 4);
7880 if (begin
== 0 && end
== 0)
7882 printf (_("<End of list>\n"));
7886 /* Check base address specifiers. */
7887 if (is_max_address (begin
, pointer_size
)
7888 && !is_max_address (end
, pointer_size
))
7891 print_hex (begin
, pointer_size
);
7892 print_hex (end
, pointer_size
);
7893 printf ("(base address)\n");
7897 print_hex (begin
+ base_address
, pointer_size
);
7898 print_hex (end
+ base_address
, pointer_size
);
7901 fputs (_("(start == end)"), stdout
);
7902 else if (begin
> end
)
7903 fputs (_("(start > end)"), stdout
);
7909 static unsigned char *
7910 display_debug_rnglists_list (unsigned char * start
,
7911 unsigned char * finish
,
7912 unsigned int pointer_size
,
7914 uint64_t base_address
,
7915 unsigned int offset_size
)
7917 unsigned char *next
= start
;
7918 unsigned int debug_addr_section_hdr_len
;
7920 if (offset_size
== 4)
7921 debug_addr_section_hdr_len
= 8;
7923 debug_addr_section_hdr_len
= 16;
7927 uint64_t off
= offset
+ (start
- next
);
7928 enum dwarf_range_list_entry rlet
;
7929 /* Initialize it due to a false compiler warning. */
7930 uint64_t begin
= -1, length
, end
= -1;
7932 if (start
>= finish
)
7934 warn (_("Range list starting at offset %#" PRIx64
7935 " is not terminated.\n"), offset
);
7942 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7946 case DW_RLE_end_of_list
:
7947 printf (_("<End of list>\n"));
7949 case DW_RLE_base_addressx
:
7950 READ_ULEB (base_address
, start
, finish
);
7951 print_hex (base_address
, pointer_size
);
7952 printf (_("(base address index) "));
7953 base_address
= fetch_indexed_addr ((base_address
* pointer_size
)
7954 + debug_addr_section_hdr_len
, pointer_size
);
7955 print_hex (base_address
, pointer_size
);
7956 printf (_("(base address)\n"));
7958 case DW_RLE_startx_endx
:
7959 READ_ULEB (begin
, start
, finish
);
7960 READ_ULEB (end
, start
, finish
);
7961 begin
= fetch_indexed_addr ((begin
* pointer_size
)
7962 + debug_addr_section_hdr_len
, pointer_size
);
7963 end
= fetch_indexed_addr ((begin
* pointer_size
)
7964 + debug_addr_section_hdr_len
, pointer_size
);
7966 case DW_RLE_startx_length
:
7967 READ_ULEB (begin
, start
, finish
);
7968 READ_ULEB (length
, start
, finish
);
7969 begin
= fetch_indexed_addr ((begin
* pointer_size
)
7970 + debug_addr_section_hdr_len
, pointer_size
);
7971 end
= begin
+ length
;
7973 case DW_RLE_offset_pair
:
7974 READ_ULEB (begin
, start
, finish
);
7975 READ_ULEB (end
, start
, finish
);
7977 case DW_RLE_base_address
:
7978 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7979 print_hex (base_address
, pointer_size
);
7980 printf (_("(base address)\n"));
7982 case DW_RLE_start_end
:
7983 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7984 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7986 case DW_RLE_start_length
:
7987 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7988 READ_ULEB (length
, start
, finish
);
7989 end
= begin
+ length
;
7992 error (_("Invalid range list entry type %d\n"), rlet
);
7993 rlet
= DW_RLE_end_of_list
;
7997 if (rlet
== DW_RLE_end_of_list
)
7999 if (rlet
== DW_RLE_base_address
|| rlet
== DW_RLE_base_addressx
)
8002 /* Only a DW_RLE_offset_pair needs the base address added. */
8003 if (rlet
== DW_RLE_offset_pair
)
8005 begin
+= base_address
;
8006 end
+= base_address
;
8009 print_hex (begin
, pointer_size
);
8010 print_hex (end
, pointer_size
);
8013 fputs (_(" (start == end)"), stdout
);
8014 else if (begin
> end
)
8015 fputs (_(" (start > end)"), stdout
);
8024 display_debug_rnglists (struct dwarf_section
*section
)
8026 unsigned char *start
= section
->start
;
8027 unsigned char *finish
= start
+ section
->size
;
8029 while (start
< finish
)
8031 unsigned char *table_start
;
8032 uint64_t offset
= start
- section
->start
;
8034 uint64_t initial_length
;
8035 unsigned char segment_selector_size
;
8036 unsigned int offset_entry_count
;
8038 unsigned short version
;
8039 unsigned char address_size
= 0;
8040 unsigned char offset_size
;
8042 /* Get and check the length of the block. */
8043 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
8045 if (initial_length
== 0xffffffff)
8047 /* This section is 64-bit DWARF 3. */
8048 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
8054 if (initial_length
> (size_t) (finish
- start
))
8056 /* If the length field has a relocation against it, then we should
8057 not complain if it is inaccurate (and probably negative).
8058 It is copied from .debug_line handling code. */
8059 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
8060 initial_length
= finish
- start
;
8063 warn (_("The length field (%#" PRIx64
8064 ") in the debug_rnglists header is wrong"
8065 " - the section is too small\n"),
8071 end
= start
+ initial_length
;
8073 /* Get the other fields in the header. */
8074 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
8075 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
8076 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
8077 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
8079 printf (_(" Table at Offset: 0x%" PRIx64
":\n"), offset
);
8080 printf (_(" Length: 0x%" PRIx64
"\n"), initial_length
);
8081 printf (_(" DWARF version: %u\n"), version
);
8082 printf (_(" Address size: %u\n"), address_size
);
8083 printf (_(" Segment size: %u\n"), segment_selector_size
);
8084 printf (_(" Offset entries: %u\n"), offset_entry_count
);
8086 /* Check the fields. */
8087 if (segment_selector_size
!= 0)
8089 warn (_("The %s section contains "
8090 "unsupported segment selector size: %d.\n"),
8091 section
->name
, segment_selector_size
);
8097 warn (_("Only DWARF version 5+ debug_rnglists info "
8098 "is currently supported.\n"));
8102 table_start
= start
;
8104 if (offset_entry_count
!= 0)
8106 printf (_("\n Offsets starting at 0x%tx:\n"),
8107 start
- section
->start
);
8109 for (i
= 0; i
< offset_entry_count
; i
++)
8113 SAFE_BYTE_GET_AND_INC (entry
, start
, offset_size
, finish
);
8114 printf (_(" [%6u] 0x%" PRIx64
"\n"), i
, entry
);
8118 offset_entry_count
= 1;
8120 for (i
= 0; i
< offset_entry_count
; i
++)
8122 uint64_t indx
= start
- table_start
;
8124 offset
= start
- section
->start
;
8125 printf (_("\n Offset: %" PRIx64
", Index: 0x%" PRIx64
"\n"),
8127 printf (_(" Offset Begin End\n"));
8128 start
= display_debug_rnglists_list
8129 (start
, end
, address_size
, offset
, 0, offset_size
);
8145 display_debug_ranges (struct dwarf_section
*section
,
8146 void *file ATTRIBUTE_UNUSED
)
8148 unsigned char *start
= section
->start
;
8149 unsigned char *last_start
= start
;
8150 uint64_t bytes
= section
->size
;
8151 unsigned char *section_begin
= start
;
8152 unsigned char *finish
= start
+ bytes
;
8153 unsigned int num_range_list
, i
;
8154 struct range_entry
*range_entries
;
8155 struct range_entry
*range_entry_fill
;
8156 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
8157 /* Initialize it due to a false compiler warning. */
8158 unsigned char address_size
= 0;
8159 uint64_t last_offset
= 0;
8163 printf (_("\nThe %s section is empty.\n"), section
->name
);
8167 introduce (section
, false);
8170 return display_debug_rnglists (section
);
8172 if (load_debug_info (file
) == 0)
8174 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
8180 for (i
= 0; i
< num_debug_info_entries
; i
++)
8181 num_range_list
+= debug_information
[i
].num_range_lists
;
8183 if (num_range_list
== 0)
8185 /* This can happen when the file was compiled with -gsplit-debug
8186 which removes references to range lists from the primary .o file. */
8187 printf (_("No range lists in .debug_info section.\n"));
8191 range_entries
= (struct range_entry
*)
8192 xmalloc (sizeof (*range_entries
) * num_range_list
);
8193 range_entry_fill
= range_entries
;
8195 for (i
= 0; i
< num_debug_info_entries
; i
++)
8197 debug_info
*debug_info_p
= &debug_information
[i
];
8200 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
8202 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
8203 range_entry_fill
->debug_info_p
= debug_info_p
;
8208 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
8209 range_entry_compar
);
8211 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
8212 warn (_("Range lists in %s section start at %#" PRIx64
"\n"),
8213 section
->name
, range_entries
[0].ranges_offset
);
8216 printf (_(" Offset Begin End\n"));
8218 for (i
= 0; i
< num_range_list
; i
++)
8220 struct range_entry
*range_entry
= &range_entries
[i
];
8221 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
8222 unsigned int pointer_size
;
8224 unsigned char *next
;
8225 uint64_t base_address
;
8227 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
8228 offset
= range_entry
->ranges_offset
;
8229 base_address
= debug_info_p
->base_address
;
8231 /* PR 17512: file: 001-101485-0.001:0.1. */
8232 if (pointer_size
< 2 || pointer_size
> 8)
8234 warn (_("Corrupt pointer size (%d) in debug entry at offset %#" PRIx64
"\n"),
8235 pointer_size
, offset
);
8239 if (offset
> (size_t) (finish
- section_begin
))
8241 warn (_("Corrupt offset (%#" PRIx64
") in range entry %u\n"),
8246 next
= section_begin
+ offset
+ debug_info_p
->rnglists_base
;
8248 /* If multiple DWARF entities reference the same range then we will
8249 have multiple entries in the `range_entries' list for the same
8250 offset. Thanks to the sort above these will all be consecutive in
8251 the `range_entries' list, so we can easily ignore duplicates
8253 if (i
> 0 && last_offset
== offset
)
8255 last_offset
= offset
;
8257 if (dwarf_check
!= 0 && i
> 0)
8260 warn (_("There is a hole [%#tx - %#tx] in %s section.\n"),
8261 start
- section_begin
, next
- section_begin
, section
->name
);
8262 else if (start
> next
)
8264 if (next
== last_start
)
8266 warn (_("There is an overlap [%#tx - %#tx] in %s section.\n"),
8267 start
- section_begin
, next
- section_begin
, section
->name
);
8274 display_debug_ranges_list
8275 (start
, finish
, pointer_size
, offset
, base_address
);
8279 free (range_entries
);
8284 typedef struct Frame_Chunk
8286 struct Frame_Chunk
*next
;
8287 unsigned char *chunk_start
;
8289 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8290 short int *col_type
;
8293 unsigned int code_factor
;
8297 unsigned int cfa_reg
;
8298 uint64_t cfa_offset
;
8300 unsigned char fde_encoding
;
8301 unsigned char cfa_exp
;
8302 unsigned char ptr_size
;
8303 unsigned char segment_size
;
8307 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
8308 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
8309 static const char *const *dwarf_regnames
;
8310 static unsigned int dwarf_regnames_count
;
8311 static bool is_aarch64
;
8313 /* A marker for a col_type that means this column was never referenced
8314 in the frame info. */
8315 #define DW_CFA_unreferenced (-1)
8317 /* Return 0 if no more space is needed, 1 if more space is needed,
8318 -1 for invalid reg. */
8321 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
8323 unsigned int prev
= fc
->ncols
;
8325 if (reg
< (unsigned int) fc
->ncols
)
8328 if (dwarf_regnames_count
> 0
8329 && reg
> dwarf_regnames_count
)
8332 fc
->ncols
= reg
+ 1;
8333 /* PR 17512: file: 10450-2643-0.004.
8334 If reg == -1 then this can happen... */
8338 /* PR 17512: file: 2844a11d. */
8339 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
8341 error (_("Unfeasibly large register number: %u\n"), reg
);
8343 /* FIXME: 1024 is an arbitrary limit. Increase it if
8344 we ever encounter a valid binary that exceeds it. */
8348 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
8349 sizeof (short int));
8350 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
8351 /* PR 17512: file:002-10025-0.005. */
8352 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
8354 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
8360 while (prev
< fc
->ncols
)
8362 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8363 fc
->col_offset
[prev
] = 0;
8369 static const char *const dwarf_regnames_i386
[] =
8371 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8372 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8373 "eip", "eflags", NULL
, /* 8 - 10 */
8374 "st0", "st1", "st2", "st3", /* 11 - 14 */
8375 "st4", "st5", "st6", "st7", /* 15 - 18 */
8376 NULL
, NULL
, /* 19 - 20 */
8377 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
8378 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
8379 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
8380 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
8381 "fcw", "fsw", "mxcsr", /* 37 - 39 */
8382 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8383 "tr", "ldtr", /* 48 - 49 */
8384 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8385 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8386 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8387 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8388 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8389 NULL
, NULL
, NULL
, /* 90 - 92 */
8390 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8393 static const char *const dwarf_regnames_iamcu
[] =
8395 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8396 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8397 "eip", "eflags", NULL
, /* 8 - 10 */
8398 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8399 NULL
, NULL
, /* 19 - 20 */
8400 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8401 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8402 NULL
, NULL
, NULL
, /* 37 - 39 */
8403 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8404 "tr", "ldtr", /* 48 - 49 */
8405 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8406 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8407 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8408 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8409 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8410 NULL
, NULL
, NULL
, /* 90 - 92 */
8411 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8415 init_dwarf_regnames_i386 (void)
8417 dwarf_regnames
= dwarf_regnames_i386
;
8418 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8419 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8423 init_dwarf_regnames_iamcu (void)
8425 dwarf_regnames
= dwarf_regnames_iamcu
;
8426 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8427 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8430 static const char *const DW_CFA_GNU_window_save_name
[] =
8432 "DW_CFA_GNU_window_save",
8433 "DW_CFA_AARCH64_negate_ra_state"
8436 static const char *const dwarf_regnames_x86_64
[] =
8438 "rax", "rdx", "rcx", "rbx",
8439 "rsi", "rdi", "rbp", "rsp",
8440 "r8", "r9", "r10", "r11",
8441 "r12", "r13", "r14", "r15",
8443 "xmm0", "xmm1", "xmm2", "xmm3",
8444 "xmm4", "xmm5", "xmm6", "xmm7",
8445 "xmm8", "xmm9", "xmm10", "xmm11",
8446 "xmm12", "xmm13", "xmm14", "xmm15",
8447 "st0", "st1", "st2", "st3",
8448 "st4", "st5", "st6", "st7",
8449 "mm0", "mm1", "mm2", "mm3",
8450 "mm4", "mm5", "mm6", "mm7",
8452 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8453 "fs.base", "gs.base", NULL
, NULL
,
8455 "mxcsr", "fcw", "fsw",
8456 "xmm16", "xmm17", "xmm18", "xmm19",
8457 "xmm20", "xmm21", "xmm22", "xmm23",
8458 "xmm24", "xmm25", "xmm26", "xmm27",
8459 "xmm28", "xmm29", "xmm30", "xmm31",
8460 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8461 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8462 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8463 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8464 NULL
, NULL
, NULL
, /* 115 - 117 */
8465 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8469 init_dwarf_regnames_x86_64 (void)
8471 dwarf_regnames
= dwarf_regnames_x86_64
;
8472 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8473 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8476 static const char *const dwarf_regnames_aarch64
[] =
8478 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8479 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8480 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8481 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8482 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8483 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8484 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8485 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8486 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8487 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8488 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8489 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8490 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8491 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8492 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8493 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8497 init_dwarf_regnames_aarch64 (void)
8499 dwarf_regnames
= dwarf_regnames_aarch64
;
8500 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8501 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8505 static const char *const dwarf_regnames_s390
[] =
8507 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8508 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8509 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8510 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8511 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8512 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8513 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8514 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8515 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8518 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8519 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8523 init_dwarf_regnames_s390 (void)
8525 dwarf_regnames
= dwarf_regnames_s390
;
8526 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8527 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8530 static const char *const dwarf_regnames_riscv
[] =
8532 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8533 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8534 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8535 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8536 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8537 "fs0", "fs1", /* 40 - 41 */
8538 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8539 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8540 "fs10", "fs11", /* 58 - 59 */
8541 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8544 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8545 the large number of CSRs. */
8548 regname_internal_riscv (unsigned int regno
)
8550 const char *name
= NULL
;
8552 /* Lookup in the table first, this covers GPR and FPR. */
8553 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8554 name
= dwarf_regnames_riscv
[regno
];
8555 else if (regno
>= 4096 && regno
<= 8191)
8557 /* This might be a CSR, these live in a sparse number space from 4096
8558 to 8191 These numbers are defined in the RISC-V ELF ABI
8562 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8563 case VALUE + 4096: name = #NAME; break;
8564 #include "opcode/riscv-opc.h"
8569 static char csr_name
[10];
8570 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8581 init_dwarf_regnames_riscv (void)
8583 dwarf_regnames
= NULL
;
8584 dwarf_regnames_count
= 8192;
8585 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8589 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8591 dwarf_regnames_lookup_func
= NULL
;
8597 init_dwarf_regnames_i386 ();
8601 init_dwarf_regnames_iamcu ();
8607 init_dwarf_regnames_x86_64 ();
8611 init_dwarf_regnames_aarch64 ();
8615 init_dwarf_regnames_s390 ();
8619 init_dwarf_regnames_riscv ();
8627 /* Initialize the DWARF register name lookup state based on the
8628 architecture and specific machine type of a BFD. */
8631 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8634 dwarf_regnames_lookup_func
= NULL
;
8642 case bfd_mach_x86_64
:
8643 case bfd_mach_x86_64_intel_syntax
:
8644 case bfd_mach_x64_32
:
8645 case bfd_mach_x64_32_intel_syntax
:
8646 init_dwarf_regnames_x86_64 ();
8650 init_dwarf_regnames_i386 ();
8655 case bfd_arch_iamcu
:
8656 init_dwarf_regnames_iamcu ();
8659 case bfd_arch_aarch64
:
8660 init_dwarf_regnames_aarch64();
8664 init_dwarf_regnames_s390 ();
8667 case bfd_arch_riscv
:
8668 init_dwarf_regnames_riscv ();
8677 regname_internal_by_table_only (unsigned int regno
)
8679 if (dwarf_regnames
!= NULL
8680 && regno
< dwarf_regnames_count
8681 && dwarf_regnames
[regno
] != NULL
)
8682 return dwarf_regnames
[regno
];
8688 regname (unsigned int regno
, int name_only_p
)
8690 static char reg
[64];
8692 const char *name
= NULL
;
8694 if (dwarf_regnames_lookup_func
!= NULL
)
8695 name
= dwarf_regnames_lookup_func (regno
);
8701 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8704 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8709 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8714 if (*max_regs
!= fc
->ncols
)
8715 *max_regs
= fc
->ncols
;
8717 if (*need_col_headers
)
8719 *need_col_headers
= 0;
8721 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8723 for (r
= 0; r
< *max_regs
; r
++)
8724 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8729 printf ("%-5s ", regname (r
, 1));
8735 print_hex (fc
->pc_begin
, eh_addr_size
);
8737 strcpy (tmp
, "exp");
8739 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8740 printf ("%-8s ", tmp
);
8742 for (r
= 0; r
< fc
->ncols
; r
++)
8744 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8746 switch (fc
->col_type
[r
])
8748 case DW_CFA_undefined
:
8751 case DW_CFA_same_value
:
8755 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8757 case DW_CFA_val_offset
:
8758 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8760 case DW_CFA_register
:
8761 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8763 case DW_CFA_expression
:
8764 strcpy (tmp
, "exp");
8766 case DW_CFA_val_expression
:
8767 strcpy (tmp
, "vexp");
8770 strcpy (tmp
, "n/a");
8773 printf ("%-5s ", tmp
);
8779 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8781 static unsigned char *
8782 read_cie (unsigned char *start
, unsigned char *end
,
8783 Frame_Chunk
**p_cie
, int *p_version
,
8784 uint64_t *p_aug_len
, unsigned char **p_aug
)
8788 unsigned char *augmentation_data
= NULL
;
8789 uint64_t augmentation_data_len
= 0;
8792 /* PR 17512: file: 001-228113-0.004. */
8796 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8797 memset (fc
, 0, sizeof (Frame_Chunk
));
8799 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8800 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8804 fc
->augmentation
= (char *) start
;
8805 /* PR 17512: file: 001-228113-0.004.
8806 Skip past augmentation name, but avoid running off the end of the data. */
8808 if (* start
++ == '\0')
8812 warn (_("No terminator for augmentation name\n"));
8816 if (strcmp (fc
->augmentation
, "eh") == 0)
8818 if (eh_addr_size
> (size_t) (end
- start
))
8820 start
+= eh_addr_size
;
8825 if (2 > (size_t) (end
- start
))
8827 GET (fc
->ptr_size
, 1);
8828 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8830 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8834 GET (fc
->segment_size
, 1);
8835 /* PR 17512: file: e99d2804. */
8836 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8838 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8842 eh_addr_size
= fc
->ptr_size
;
8846 fc
->ptr_size
= eh_addr_size
;
8847 fc
->segment_size
= 0;
8850 READ_ULEB (fc
->code_factor
, start
, end
);
8851 READ_SLEB (fc
->data_factor
, start
, end
);
8862 READ_ULEB (fc
->ra
, start
, end
);
8865 if (fc
->augmentation
[0] == 'z')
8869 READ_ULEB (augmentation_data_len
, start
, end
);
8870 augmentation_data
= start
;
8871 /* PR 17512: file: 11042-2589-0.004. */
8872 if (augmentation_data_len
> (size_t) (end
- start
))
8874 warn (_("Augmentation data too long: %#" PRIx64
8875 ", expected at most %#tx\n"),
8876 augmentation_data_len
, end
- start
);
8879 start
+= augmentation_data_len
;
8882 if (augmentation_data_len
)
8886 unsigned char *qend
;
8888 p
= (unsigned char *) fc
->augmentation
+ 1;
8889 q
= augmentation_data
;
8890 qend
= q
+ augmentation_data_len
;
8892 while (p
< end
&& q
< qend
)
8897 q
+= 1 + size_of_encoded_value (*q
);
8899 fc
->fde_encoding
= *q
++;
8908 /* Note - it is OK if this loop terminates with q < qend.
8909 Padding may have been inserted to align the end of the CIE. */
8914 *p_version
= version
;
8917 *p_aug_len
= augmentation_data_len
;
8918 *p_aug
= augmentation_data
;
8923 free (fc
->col_offset
);
8924 free (fc
->col_type
);
8929 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8930 If do_wide is not enabled, then formats the output to fit into 80 columns.
8931 PRINTED contains the number of characters already written to the current
8935 display_data (size_t printed
, const unsigned char *data
, size_t len
)
8937 if (do_wide
|| len
< ((80 - printed
) / 3))
8938 for (printed
= 0; printed
< len
; ++printed
)
8939 printf (" %02x", data
[printed
]);
8942 for (printed
= 0; printed
< len
; ++printed
)
8944 if (printed
% (80 / 3) == 0)
8946 printf (" %02x", data
[printed
]);
8951 /* Prints out the contents on the augmentation data array.
8952 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8955 display_augmentation_data (const unsigned char * data
, uint64_t len
)
8959 i
= printf (_(" Augmentation data: "));
8960 display_data (i
, data
, len
);
8964 display_debug_frames (struct dwarf_section
*section
,
8965 void *file ATTRIBUTE_UNUSED
)
8967 unsigned char *start
= section
->start
;
8968 unsigned char *end
= start
+ section
->size
;
8969 unsigned char *section_start
= start
;
8970 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8971 Frame_Chunk
*remembered_state
= NULL
;
8973 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8974 unsigned int max_regs
= 0;
8975 const char *bad_reg
= _("bad register: ");
8976 unsigned int saved_eh_addr_size
= eh_addr_size
;
8978 introduce (section
, false);
8982 unsigned char *saved_start
;
8983 unsigned char *block_end
;
8988 int need_col_headers
= 1;
8989 unsigned char *augmentation_data
= NULL
;
8990 uint64_t augmentation_data_len
= 0;
8991 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8992 unsigned int offset_size
;
8994 static Frame_Chunk fde_fc
;
8996 saved_start
= start
;
8998 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
9002 printf ("\n%08tx ZERO terminator\n\n",
9003 saved_start
- section_start
);
9004 /* Skip any zero terminators that directly follow.
9005 A corrupt section size could have loaded a whole
9006 slew of zero filled memory bytes. eg
9007 PR 17512: file: 070-19381-0.004. */
9008 while (start
< end
&& * start
== 0)
9013 if (length
== 0xffffffff)
9015 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
9021 if (length
> (size_t) (end
- start
))
9023 warn ("Invalid length %#" PRIx64
" in FDE at %#tx\n",
9024 length
, saved_start
- section_start
);
9028 block_end
= start
+ length
;
9030 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
9032 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
9033 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
9038 start
= read_cie (start
, block_end
, &cie
, &version
,
9039 &augmentation_data_len
, &augmentation_data
);
9040 /* PR 17512: file: 027-135133-0.005. */
9047 fc
->chunk_start
= saved_start
;
9048 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
9051 if (frame_need_space (fc
, mreg
) < 0)
9053 if (fc
->fde_encoding
)
9054 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9056 printf ("\n%08tx ", saved_start
- section_start
);
9057 print_hex (length
, fc
->ptr_size
);
9058 print_hex (cie_id
, offset_size
);
9060 if (do_debug_frames_interp
)
9062 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
9063 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
9068 printf (" Version: %d\n", version
);
9069 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9072 printf (" Pointer Size: %u\n", fc
->ptr_size
);
9073 printf (" Segment Size: %u\n", fc
->segment_size
);
9075 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9076 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9077 printf (" Return address column: %d\n", fc
->ra
);
9079 if (augmentation_data_len
)
9080 display_augmentation_data (augmentation_data
, augmentation_data_len
);
9087 unsigned char *look_for
;
9088 unsigned long segment_selector
;
9094 uint64_t sign
= (uint64_t) 1 << (offset_size
* 8 - 1);
9095 cie_off
= (cie_off
^ sign
) - sign
;
9096 cie_off
= start
- 4 - section_start
- cie_off
;
9099 look_for
= section_start
+ cie_off
;
9100 if (cie_off
<= (size_t) (saved_start
- section_start
))
9102 for (cie
= chunks
; cie
; cie
= cie
->next
)
9103 if (cie
->chunk_start
== look_for
)
9106 else if (cie_off
>= section
->size
)
9110 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
9111 if (cie
->chunk_start
== look_for
)
9115 unsigned int off_size
;
9116 unsigned char *cie_scan
;
9118 cie_scan
= look_for
;
9120 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
9121 if (length
== 0xffffffff)
9123 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
9126 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
9129 unsigned char *cie_end
= cie_scan
+ length
;
9131 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
9135 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
9136 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
9141 read_cie (cie_scan
, cie_end
, &cie
, &version
,
9142 &augmentation_data_len
, &augmentation_data
);
9143 /* PR 17512: file: 3450-2098-0.004. */
9146 warn (_("Failed to read CIE information\n"));
9149 cie
->next
= forward_refs
;
9151 cie
->chunk_start
= look_for
;
9152 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
9155 if (frame_need_space (cie
, mreg
) < 0)
9157 warn (_("Invalid max register\n"));
9160 if (cie
->fde_encoding
)
9162 = size_of_encoded_value (cie
->fde_encoding
);
9169 memset (fc
, 0, sizeof (Frame_Chunk
));
9174 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
9175 fc
->col_offset
= (int *) xmalloc (sizeof (int));
9176 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
9178 warn (_("Invalid max register\n"));
9182 fc
->augmentation
= "";
9183 fc
->fde_encoding
= 0;
9184 fc
->ptr_size
= eh_addr_size
;
9185 fc
->segment_size
= 0;
9189 fc
->ncols
= cie
->ncols
;
9190 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
9191 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
9192 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9193 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9194 fc
->augmentation
= cie
->augmentation
;
9195 fc
->ptr_size
= cie
->ptr_size
;
9196 eh_addr_size
= cie
->ptr_size
;
9197 fc
->segment_size
= cie
->segment_size
;
9198 fc
->code_factor
= cie
->code_factor
;
9199 fc
->data_factor
= cie
->data_factor
;
9200 fc
->cfa_reg
= cie
->cfa_reg
;
9201 fc
->cfa_offset
= cie
->cfa_offset
;
9203 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
9205 warn (_("Invalid max register\n"));
9208 fc
->fde_encoding
= cie
->fde_encoding
;
9211 if (fc
->fde_encoding
)
9212 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9214 segment_selector
= 0;
9215 if (fc
->segment_size
)
9217 if (fc
->segment_size
> sizeof (segment_selector
))
9219 /* PR 17512: file: 9e196b3e. */
9220 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
9221 fc
->segment_size
= 4;
9223 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
9224 fc
->segment_size
, block_end
);
9227 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9230 /* FIXME: It appears that sometimes the final pc_range value is
9231 encoded in less than encoded_ptr_size bytes. See the x86_64
9232 run of the "objcopy on compressed debug sections" test for an
9234 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
9237 if (cie
->augmentation
[0] == 'z')
9239 READ_ULEB (augmentation_data_len
, start
, block_end
);
9240 augmentation_data
= start
;
9241 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
9242 if (augmentation_data_len
> (size_t) (block_end
- start
))
9244 warn (_("Augmentation data too long: %#" PRIx64
", "
9245 "expected at most %#tx\n"),
9246 augmentation_data_len
, block_end
- start
);
9248 augmentation_data
= NULL
;
9249 augmentation_data_len
= 0;
9251 start
+= augmentation_data_len
;
9254 printf ("\n%08tx ", saved_start
- section_start
);
9255 print_hex (length
, fc
->ptr_size
);
9256 print_hex (cie_id
, offset_size
);
9259 if (cie
->chunk_start
)
9260 printf ("cie=%08tx", cie
->chunk_start
- section_start
);
9262 /* Ideally translate "invalid " to 8 chars, trailing space
9264 printf (_("cie=invalid "));
9267 if (fc
->segment_size
)
9268 printf ("%04lx:", segment_selector
);
9270 print_hex_ns (fc
->pc_begin
, fc
->ptr_size
);
9272 print_hex_ns (fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
);
9275 if (! do_debug_frames_interp
&& augmentation_data_len
)
9277 display_augmentation_data (augmentation_data
, augmentation_data_len
);
9282 /* At this point, fc is the current chunk, cie (if any) is set, and
9283 we're about to interpret instructions for the chunk. */
9284 /* ??? At present we need to do this always, since this sizes the
9285 fc->col_type and fc->col_offset arrays, which we write into always.
9286 We should probably split the interpreted and non-interpreted bits
9287 into two different routines, since there's so much that doesn't
9288 really overlap between them. */
9289 if (1 || do_debug_frames_interp
)
9291 /* Start by making a pass over the chunk, allocating storage
9292 and taking note of what registers are used. */
9293 unsigned char *tmp
= start
;
9295 while (start
< block_end
)
9297 unsigned int reg
, op
, opa
;
9305 /* Warning: if you add any more cases to this switch, be
9306 sure to add them to the corresponding switch below. */
9310 case DW_CFA_advance_loc
:
9313 SKIP_ULEB (start
, block_end
);
9316 case DW_CFA_restore
:
9319 case DW_CFA_set_loc
:
9320 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
9323 start
+= encoded_ptr_size
;
9325 case DW_CFA_advance_loc1
:
9326 if ((size_t) (block_end
- start
) < 1)
9331 case DW_CFA_advance_loc2
:
9332 if ((size_t) (block_end
- start
) < 2)
9337 case DW_CFA_advance_loc4
:
9338 if ((size_t) (block_end
- start
) < 4)
9343 case DW_CFA_offset_extended
:
9344 case DW_CFA_val_offset
:
9345 READ_ULEB (reg
, start
, block_end
);
9346 SKIP_ULEB (start
, block_end
);
9348 case DW_CFA_restore_extended
:
9349 READ_ULEB (reg
, start
, block_end
);
9351 case DW_CFA_undefined
:
9352 READ_ULEB (reg
, start
, block_end
);
9354 case DW_CFA_same_value
:
9355 READ_ULEB (reg
, start
, block_end
);
9357 case DW_CFA_register
:
9358 READ_ULEB (reg
, start
, block_end
);
9359 SKIP_ULEB (start
, block_end
);
9361 case DW_CFA_def_cfa
:
9362 SKIP_ULEB (start
, block_end
);
9363 SKIP_ULEB (start
, block_end
);
9365 case DW_CFA_def_cfa_register
:
9366 SKIP_ULEB (start
, block_end
);
9368 case DW_CFA_def_cfa_offset
:
9369 SKIP_ULEB (start
, block_end
);
9371 case DW_CFA_def_cfa_expression
:
9372 READ_ULEB (temp
, start
, block_end
);
9373 if ((size_t) (block_end
- start
) < temp
)
9378 case DW_CFA_expression
:
9379 case DW_CFA_val_expression
:
9380 READ_ULEB (reg
, start
, block_end
);
9381 READ_ULEB (temp
, start
, block_end
);
9382 if ((size_t) (block_end
- start
) < temp
)
9387 case DW_CFA_offset_extended_sf
:
9388 case DW_CFA_val_offset_sf
:
9389 READ_ULEB (reg
, start
, block_end
);
9390 SKIP_SLEB (start
, block_end
);
9392 case DW_CFA_def_cfa_sf
:
9393 SKIP_ULEB (start
, block_end
);
9394 SKIP_SLEB (start
, block_end
);
9396 case DW_CFA_def_cfa_offset_sf
:
9397 SKIP_SLEB (start
, block_end
);
9399 case DW_CFA_MIPS_advance_loc8
:
9400 if ((size_t) (block_end
- start
) < 8)
9405 case DW_CFA_GNU_args_size
:
9406 SKIP_ULEB (start
, block_end
);
9408 case DW_CFA_GNU_negative_offset_extended
:
9409 READ_ULEB (reg
, start
, block_end
);
9410 SKIP_ULEB (start
, block_end
);
9415 if (reg
!= -1u && frame_need_space (fc
, reg
) >= 0)
9417 /* Don't leave any reg as DW_CFA_unreferenced so
9418 that frame_display_row prints name of regs in
9419 header, and all referenced regs in each line. */
9420 if (reg
>= cie
->ncols
9421 || cie
->col_type
[reg
] == DW_CFA_unreferenced
)
9422 fc
->col_type
[reg
] = DW_CFA_undefined
;
9424 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9432 /* Now we know what registers are used, make a second pass over
9433 the chunk, this time actually printing out the info. */
9435 while (start
< block_end
)
9438 unsigned long ul
, roffs
;
9439 /* Note: It is tempting to use an unsigned long for 'reg' but there
9440 are various functions, notably frame_space_needed() that assume that
9441 reg is an unsigned int. */
9446 const char *reg_prefix
= "";
9453 /* Make a note if something other than DW_CFA_nop happens. */
9454 if (op
!= DW_CFA_nop
)
9457 /* Warning: if you add any more cases to this switch, be
9458 sure to add them to the corresponding switch above. */
9461 case DW_CFA_advance_loc
:
9462 if (do_debug_frames_interp
)
9463 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9466 printf (" DW_CFA_advance_loc: %d to ",
9467 opa
* fc
->code_factor
);
9468 print_hex_ns (fc
->pc_begin
+ opa
* fc
->code_factor
,
9472 fc
->pc_begin
+= opa
* fc
->code_factor
;
9476 READ_ULEB (roffs
, start
, block_end
);
9477 if (opa
>= fc
->ncols
)
9478 reg_prefix
= bad_reg
;
9479 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9480 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9481 reg_prefix
, regname (opa
, 0),
9482 roffs
* fc
->data_factor
);
9483 if (*reg_prefix
== '\0')
9485 fc
->col_type
[opa
] = DW_CFA_offset
;
9486 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9490 case DW_CFA_restore
:
9491 if (opa
>= fc
->ncols
)
9492 reg_prefix
= bad_reg
;
9493 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9494 printf (" DW_CFA_restore: %s%s\n",
9495 reg_prefix
, regname (opa
, 0));
9496 if (*reg_prefix
!= '\0')
9499 if (opa
>= cie
->ncols
9500 || cie
->col_type
[opa
] == DW_CFA_unreferenced
)
9502 fc
->col_type
[opa
] = DW_CFA_undefined
;
9503 fc
->col_offset
[opa
] = 0;
9507 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9508 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9512 case DW_CFA_set_loc
:
9513 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9515 if (do_debug_frames_interp
)
9516 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9519 printf (" DW_CFA_set_loc: ");
9520 print_hex_ns (vma
, fc
->ptr_size
);
9526 case DW_CFA_advance_loc1
:
9527 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9528 if (do_debug_frames_interp
)
9529 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9532 printf (" DW_CFA_advance_loc1: %" PRId64
" to ",
9533 ofs
* fc
->code_factor
);
9534 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9538 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9541 case DW_CFA_advance_loc2
:
9542 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9543 if (do_debug_frames_interp
)
9544 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9547 printf (" DW_CFA_advance_loc2: %" PRId64
" to ",
9548 ofs
* fc
->code_factor
);
9549 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9553 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9556 case DW_CFA_advance_loc4
:
9557 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9558 if (do_debug_frames_interp
)
9559 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9562 printf (" DW_CFA_advance_loc4: %" PRId64
" to ",
9563 ofs
* fc
->code_factor
);
9564 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9568 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9571 case DW_CFA_offset_extended
:
9572 READ_ULEB (reg
, start
, block_end
);
9573 READ_ULEB (roffs
, start
, block_end
);
9574 if (reg
>= fc
->ncols
)
9575 reg_prefix
= bad_reg
;
9576 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9577 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9578 reg_prefix
, regname (reg
, 0),
9579 roffs
* fc
->data_factor
);
9580 if (*reg_prefix
== '\0')
9582 fc
->col_type
[reg
] = DW_CFA_offset
;
9583 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9587 case DW_CFA_val_offset
:
9588 READ_ULEB (reg
, start
, block_end
);
9589 READ_ULEB (roffs
, start
, block_end
);
9590 if (reg
>= fc
->ncols
)
9591 reg_prefix
= bad_reg
;
9592 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9593 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9594 reg_prefix
, regname (reg
, 0),
9595 roffs
* fc
->data_factor
);
9596 if (*reg_prefix
== '\0')
9598 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9599 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9603 case DW_CFA_restore_extended
:
9604 READ_ULEB (reg
, start
, block_end
);
9605 if (reg
>= fc
->ncols
)
9606 reg_prefix
= bad_reg
;
9607 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9608 printf (" DW_CFA_restore_extended: %s%s\n",
9609 reg_prefix
, regname (reg
, 0));
9610 if (*reg_prefix
!= '\0')
9613 if (reg
>= cie
->ncols
9614 || cie
->col_type
[reg
] == DW_CFA_unreferenced
)
9616 fc
->col_type
[reg
] = DW_CFA_undefined
;
9617 fc
->col_offset
[reg
] = 0;
9621 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9622 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9626 case DW_CFA_undefined
:
9627 READ_ULEB (reg
, start
, block_end
);
9628 if (reg
>= fc
->ncols
)
9629 reg_prefix
= bad_reg
;
9630 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9631 printf (" DW_CFA_undefined: %s%s\n",
9632 reg_prefix
, regname (reg
, 0));
9633 if (*reg_prefix
== '\0')
9635 fc
->col_type
[reg
] = DW_CFA_undefined
;
9636 fc
->col_offset
[reg
] = 0;
9640 case DW_CFA_same_value
:
9641 READ_ULEB (reg
, start
, block_end
);
9642 if (reg
>= fc
->ncols
)
9643 reg_prefix
= bad_reg
;
9644 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9645 printf (" DW_CFA_same_value: %s%s\n",
9646 reg_prefix
, regname (reg
, 0));
9647 if (*reg_prefix
== '\0')
9649 fc
->col_type
[reg
] = DW_CFA_same_value
;
9650 fc
->col_offset
[reg
] = 0;
9654 case DW_CFA_register
:
9655 READ_ULEB (reg
, start
, block_end
);
9656 READ_ULEB (roffs
, start
, block_end
);
9657 if (reg
>= fc
->ncols
)
9658 reg_prefix
= bad_reg
;
9659 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9661 printf (" DW_CFA_register: %s%s in ",
9662 reg_prefix
, regname (reg
, 0));
9663 puts (regname (roffs
, 0));
9665 if (*reg_prefix
== '\0')
9667 fc
->col_type
[reg
] = DW_CFA_register
;
9668 fc
->col_offset
[reg
] = roffs
;
9672 case DW_CFA_remember_state
:
9673 if (! do_debug_frames_interp
)
9674 printf (" DW_CFA_remember_state\n");
9675 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9676 rs
->cfa_offset
= fc
->cfa_offset
;
9677 rs
->cfa_reg
= fc
->cfa_reg
;
9679 rs
->cfa_exp
= fc
->cfa_exp
;
9680 rs
->ncols
= fc
->ncols
;
9681 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9682 sizeof (* rs
->col_type
));
9683 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9684 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9685 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9686 rs
->next
= remembered_state
;
9687 remembered_state
= rs
;
9690 case DW_CFA_restore_state
:
9691 if (! do_debug_frames_interp
)
9692 printf (" DW_CFA_restore_state\n");
9693 rs
= remembered_state
;
9696 remembered_state
= rs
->next
;
9697 fc
->cfa_offset
= rs
->cfa_offset
;
9698 fc
->cfa_reg
= rs
->cfa_reg
;
9700 fc
->cfa_exp
= rs
->cfa_exp
;
9701 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9703 warn (_("Invalid column number in saved frame state\n"));
9707 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9708 memcpy (fc
->col_offset
, rs
->col_offset
,
9709 rs
->ncols
* sizeof (* rs
->col_offset
));
9710 free (rs
->col_type
);
9711 free (rs
->col_offset
);
9714 else if (do_debug_frames_interp
)
9715 printf ("Mismatched DW_CFA_restore_state\n");
9718 case DW_CFA_def_cfa
:
9719 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9720 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9722 if (! do_debug_frames_interp
)
9723 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9724 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9727 case DW_CFA_def_cfa_register
:
9728 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9730 if (! do_debug_frames_interp
)
9731 printf (" DW_CFA_def_cfa_register: %s\n",
9732 regname (fc
->cfa_reg
, 0));
9735 case DW_CFA_def_cfa_offset
:
9736 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9737 if (! do_debug_frames_interp
)
9738 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9742 if (! do_debug_frames_interp
)
9743 printf (" DW_CFA_nop\n");
9746 case DW_CFA_def_cfa_expression
:
9747 READ_ULEB (ul
, start
, block_end
);
9748 if (ul
> (size_t) (block_end
- start
))
9750 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9753 if (! do_debug_frames_interp
)
9755 printf (" DW_CFA_def_cfa_expression (");
9756 decode_location_expression (start
, eh_addr_size
, 0, -1,
9764 case DW_CFA_expression
:
9765 READ_ULEB (reg
, start
, block_end
);
9766 READ_ULEB (ul
, start
, block_end
);
9767 if (reg
>= fc
->ncols
)
9768 reg_prefix
= bad_reg
;
9769 /* PR 17512: file: 069-133014-0.006. */
9770 /* PR 17512: file: 98c02eb4. */
9771 if (ul
> (size_t) (block_end
- start
))
9773 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9776 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9778 printf (" DW_CFA_expression: %s%s (",
9779 reg_prefix
, regname (reg
, 0));
9780 decode_location_expression (start
, eh_addr_size
, 0, -1,
9784 if (*reg_prefix
== '\0')
9785 fc
->col_type
[reg
] = DW_CFA_expression
;
9789 case DW_CFA_val_expression
:
9790 READ_ULEB (reg
, start
, block_end
);
9791 READ_ULEB (ul
, start
, block_end
);
9792 if (reg
>= fc
->ncols
)
9793 reg_prefix
= bad_reg
;
9794 if (ul
> (size_t) (block_end
- start
))
9796 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9799 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9801 printf (" DW_CFA_val_expression: %s%s (",
9802 reg_prefix
, regname (reg
, 0));
9803 decode_location_expression (start
, eh_addr_size
, 0, -1,
9807 if (*reg_prefix
== '\0')
9808 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9812 case DW_CFA_offset_extended_sf
:
9813 READ_ULEB (reg
, start
, block_end
);
9814 READ_SLEB (l
, start
, block_end
);
9815 if (reg
>= fc
->ncols
)
9816 reg_prefix
= bad_reg
;
9817 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9818 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+" PRId64
"\n",
9819 reg_prefix
, regname (reg
, 0),
9820 l
* fc
->data_factor
);
9821 if (*reg_prefix
== '\0')
9823 fc
->col_type
[reg
] = DW_CFA_offset
;
9824 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9828 case DW_CFA_val_offset_sf
:
9829 READ_ULEB (reg
, start
, block_end
);
9830 READ_SLEB (l
, start
, block_end
);
9831 if (reg
>= fc
->ncols
)
9832 reg_prefix
= bad_reg
;
9833 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9834 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+" PRId64
"\n",
9835 reg_prefix
, regname (reg
, 0),
9836 l
* fc
->data_factor
);
9837 if (*reg_prefix
== '\0')
9839 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9840 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9844 case DW_CFA_def_cfa_sf
:
9845 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9846 READ_SLEB (l
, start
, block_end
);
9847 l
*= fc
->data_factor
;
9850 if (! do_debug_frames_interp
)
9851 printf (" DW_CFA_def_cfa_sf: %s ofs %" PRId64
"\n",
9852 regname (fc
->cfa_reg
, 0), l
);
9855 case DW_CFA_def_cfa_offset_sf
:
9856 READ_SLEB (l
, start
, block_end
);
9857 l
*= fc
->data_factor
;
9859 if (! do_debug_frames_interp
)
9860 printf (" DW_CFA_def_cfa_offset_sf: %" PRId64
"\n", l
);
9863 case DW_CFA_MIPS_advance_loc8
:
9864 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9865 if (do_debug_frames_interp
)
9866 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9869 printf (" DW_CFA_MIPS_advance_loc8: %" PRId64
" to ",
9870 ofs
* fc
->code_factor
);
9871 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9875 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9878 case DW_CFA_GNU_window_save
:
9879 if (! do_debug_frames_interp
)
9880 printf (" %s\n", DW_CFA_GNU_window_save_name
[is_aarch64
]);
9883 case DW_CFA_GNU_args_size
:
9884 READ_ULEB (ul
, start
, block_end
);
9885 if (! do_debug_frames_interp
)
9886 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9889 case DW_CFA_GNU_negative_offset_extended
:
9890 READ_ULEB (reg
, start
, block_end
);
9891 READ_SLEB (l
, start
, block_end
);
9893 if (reg
>= fc
->ncols
)
9894 reg_prefix
= bad_reg
;
9895 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9896 printf (" DW_CFA_GNU_negative_offset_extended: %s%s "
9897 "at cfa%+" PRId64
"\n",
9898 reg_prefix
, regname (reg
, 0),
9899 l
* fc
->data_factor
);
9900 if (*reg_prefix
== '\0')
9902 fc
->col_type
[reg
] = DW_CFA_offset
;
9903 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9908 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9909 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9911 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9916 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9917 if (do_debug_frames_interp
&& ! all_nops
)
9918 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9920 if (fde_fc
.col_type
!= NULL
)
9922 free (fde_fc
.col_type
);
9923 fde_fc
.col_type
= NULL
;
9925 if (fde_fc
.col_offset
!= NULL
)
9927 free (fde_fc
.col_offset
);
9928 fde_fc
.col_offset
= NULL
;
9932 eh_addr_size
= saved_eh_addr_size
;
9937 while (remembered_state
!= NULL
)
9939 rs
= remembered_state
;
9940 remembered_state
= rs
->next
;
9941 free (rs
->col_type
);
9942 free (rs
->col_offset
);
9943 rs
->next
= NULL
; /* Paranoia. */
9947 while (chunks
!= NULL
)
9951 free (rs
->col_type
);
9952 free (rs
->col_offset
);
9953 rs
->next
= NULL
; /* Paranoia. */
9957 while (forward_refs
!= NULL
)
9960 forward_refs
= rs
->next
;
9961 free (rs
->col_type
);
9962 free (rs
->col_offset
);
9963 rs
->next
= NULL
; /* Paranoia. */
9973 display_debug_names (struct dwarf_section
*section
, void *file
)
9975 unsigned char *hdrptr
= section
->start
;
9976 uint64_t unit_length
;
9977 unsigned char *unit_start
;
9978 const unsigned char *const section_end
= section
->start
+ section
->size
;
9979 unsigned char *unit_end
;
9981 introduce (section
, false);
9983 load_debug_section_with_follow (str
, file
);
9985 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9987 unsigned int offset_size
;
9988 uint16_t dwarf_version
, padding
;
9989 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9990 uint64_t bucket_count
, name_count
, abbrev_table_size
;
9991 uint32_t augmentation_string_size
;
9993 bool augmentation_printable
;
9994 const char *augmentation_string
;
9997 unit_start
= hdrptr
;
9999 /* Get and check the length of the block. */
10000 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
10002 if (unit_length
== 0xffffffff)
10004 /* This section is 64-bit DWARF. */
10005 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
10011 if (unit_length
> (size_t) (section_end
- hdrptr
)
10012 || unit_length
< 2 + 2 + 4 * 7)
10015 warn (_("Debug info is corrupted, %s header at %#tx"
10016 " has length %#" PRIx64
"\n"),
10017 section
->name
, unit_start
- section
->start
, unit_length
);
10020 unit_end
= hdrptr
+ unit_length
;
10022 /* Get and check the version number. */
10023 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
10024 printf (_("Version %d\n"), (int) dwarf_version
);
10026 /* Prior versions did not exist, and future versions may not be
10027 backwards compatible. */
10028 if (dwarf_version
!= 5)
10030 warn (_("Only DWARF version 5 .debug_names "
10031 "is currently supported.\n"));
10035 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
10037 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
10040 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
10041 if (comp_unit_count
== 0)
10042 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
10044 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
10045 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
10046 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
10047 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
10048 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
10050 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
10051 if (augmentation_string_size
% 4 != 0)
10053 warn (_("Augmentation string length %u must be rounded up "
10054 "to a multiple of 4 in .debug_names.\n"),
10055 augmentation_string_size
);
10056 augmentation_string_size
+= (-augmentation_string_size
) & 3;
10058 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
10061 printf (_("Augmentation string:"));
10063 augmentation_printable
= true;
10064 augmentation_string
= (const char *) hdrptr
;
10066 for (i
= 0; i
< augmentation_string_size
; i
++)
10070 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
10071 printf (" %02x", uc
);
10073 if (uc
!= 0 && !ISPRINT (uc
))
10074 augmentation_printable
= false;
10077 if (augmentation_printable
)
10081 i
< augmentation_string_size
&& augmentation_string
[i
];
10083 putchar (augmentation_string
[i
]);
10088 printf (_("CU table:\n"));
10089 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
10090 || total
> (size_t) (unit_end
- hdrptr
))
10092 for (i
= 0; i
< comp_unit_count
; i
++)
10094 uint64_t cu_offset
;
10096 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
10097 printf ("[%3u] 0x%" PRIx64
"\n", i
, cu_offset
);
10101 printf (_("TU table:\n"));
10102 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
10103 || total
> (size_t) (unit_end
- hdrptr
))
10105 for (i
= 0; i
< local_type_unit_count
; i
++)
10107 uint64_t tu_offset
;
10109 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
10110 printf ("[%3u] 0x%" PRIx64
"\n", i
, tu_offset
);
10114 printf (_("Foreign TU table:\n"));
10115 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
10116 || total
> (size_t) (unit_end
- hdrptr
))
10118 for (i
= 0; i
< foreign_type_unit_count
; i
++)
10120 uint64_t signature
;
10122 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
10123 printf (_("[%3u] "), i
);
10124 print_hex (signature
, 8);
10129 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
10130 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
10131 + abbrev_table_size
);
10132 if (xtra
> (size_t) (unit_end
- hdrptr
))
10134 warn (_("Entry pool offset (%#" PRIx64
") exceeds unit size %#tx "
10135 "for unit %#tx in the debug_names\n"),
10136 xtra
, unit_end
- unit_start
, unit_start
- section
->start
);
10139 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
10140 hdrptr
+= bucket_count
* sizeof (uint32_t);
10141 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
10142 hdrptr
+= name_count
* sizeof (uint32_t);
10143 unsigned char *const name_table_string_offsets
= hdrptr
;
10144 hdrptr
+= name_count
* offset_size
;
10145 unsigned char *const name_table_entry_offsets
= hdrptr
;
10146 hdrptr
+= name_count
* offset_size
;
10147 unsigned char *const abbrev_table
= hdrptr
;
10148 hdrptr
+= abbrev_table_size
;
10149 const unsigned char *const abbrev_table_end
= hdrptr
;
10150 unsigned char *const entry_pool
= hdrptr
;
10152 size_t buckets_filled
= 0;
10154 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
10156 const uint32_t bucket
= hash_table_buckets
[bucketi
];
10161 printf (ngettext ("Used %zu of %lu bucket.\n",
10162 "Used %zu of %lu buckets.\n",
10163 (unsigned long) bucket_count
),
10164 buckets_filled
, (unsigned long) bucket_count
);
10166 if (bucket_count
!= 0)
10168 uint32_t hash_prev
= 0;
10169 size_t hash_clash_count
= 0;
10170 size_t longest_clash
= 0;
10171 size_t this_length
= 0;
10173 for (hashi
= 0; hashi
< name_count
; hashi
++)
10175 const uint32_t hash_this
= hash_table_hashes
[hashi
];
10179 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
10181 ++hash_clash_count
;
10183 longest_clash
= MAX (longest_clash
, this_length
);
10188 hash_prev
= hash_this
;
10190 printf (_("Out of %" PRIu64
" items there are %zu bucket clashes"
10191 " (longest of %zu entries).\n"),
10192 name_count
, hash_clash_count
, longest_clash
);
10194 if (name_count
!= buckets_filled
+ hash_clash_count
)
10195 warn (_("The name_count (%" PRIu64
")"
10196 " is not the same as the used bucket_count"
10197 " (%zu) + the hash clash count (%zu)"),
10198 name_count
, buckets_filled
, hash_clash_count
);
10201 struct abbrev_lookup_entry
10203 uint64_t abbrev_tag
;
10204 unsigned char *abbrev_lookup_ptr
;
10206 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
10207 size_t abbrev_lookup_used
= 0;
10208 size_t abbrev_lookup_allocated
= 0;
10210 unsigned char *abbrevptr
= abbrev_table
;
10213 uint64_t abbrev_tag
;
10215 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
10216 if (abbrev_tag
== 0)
10218 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
10220 abbrev_lookup_allocated
= MAX (0x100,
10221 abbrev_lookup_allocated
* 2);
10222 abbrev_lookup
= xrealloc (abbrev_lookup
,
10223 (abbrev_lookup_allocated
10224 * sizeof (*abbrev_lookup
)));
10226 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
10227 struct abbrev_lookup_entry
*entry
;
10228 for (entry
= abbrev_lookup
;
10229 entry
< abbrev_lookup
+ abbrev_lookup_used
;
10231 if (entry
->abbrev_tag
== abbrev_tag
)
10233 warn (_("Duplicate abbreviation tag %" PRIu64
10234 " in unit %#tx in the debug_names section\n"),
10235 abbrev_tag
, unit_start
- section
->start
);
10238 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
10239 entry
->abbrev_tag
= abbrev_tag
;
10240 entry
->abbrev_lookup_ptr
= abbrevptr
;
10242 /* Skip DWARF tag. */
10243 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
10246 uint64_t xindex
, form
;
10248 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
10249 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
10250 if (xindex
== 0 && form
== 0)
10255 printf (_("\nSymbol table:\n"));
10257 for (namei
= 0; namei
< name_count
; ++namei
)
10259 uint64_t string_offset
, entry_offset
;
10262 p
= name_table_string_offsets
+ namei
* offset_size
;
10263 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
10264 p
= name_table_entry_offsets
+ namei
* offset_size
;
10265 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
10267 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
10268 fetch_indirect_string (string_offset
));
10270 unsigned char *entryptr
= entry_pool
+ entry_offset
;
10272 /* We need to scan first whether there is a single or multiple
10273 entries. TAGNO is -2 for the first entry, it is -1 for the
10274 initial tag read of the second entry, then it becomes 0 for the
10275 first entry for real printing etc. */
10277 /* Initialize it due to a false compiler warning. */
10278 uint64_t second_abbrev_tag
= -1;
10281 uint64_t abbrev_tag
;
10282 uint64_t dwarf_tag
;
10283 const struct abbrev_lookup_entry
*entry
;
10285 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
10288 second_abbrev_tag
= abbrev_tag
;
10290 entryptr
= entry_pool
+ entry_offset
;
10293 if (abbrev_tag
== 0)
10296 printf ("%s<%" PRIu64
">",
10297 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
10300 for (entry
= abbrev_lookup
;
10301 entry
< abbrev_lookup
+ abbrev_lookup_used
;
10303 if (entry
->abbrev_tag
== abbrev_tag
)
10305 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
10307 warn (_("Undefined abbreviation tag %" PRId64
10308 " in unit %#tx in the debug_names section\n"),
10310 unit_start
- section
->start
);
10313 abbrevptr
= entry
->abbrev_lookup_ptr
;
10314 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
10316 printf (" %s", get_TAG_name (dwarf_tag
));
10319 uint64_t xindex
, form
;
10321 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
10322 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
10323 if (xindex
== 0 && form
== 0)
10327 printf (" %s", get_IDX_name (xindex
));
10328 entryptr
= read_and_display_attr_value (0, form
, 0,
10329 unit_start
, entryptr
, unit_end
,
10331 dwarf_version
, NULL
,
10332 (tagno
< 0), section
,
10338 printf (_(" <no entries>"));
10342 free (abbrev_lookup
);
10349 display_debug_links (struct dwarf_section
* section
,
10350 void * file ATTRIBUTE_UNUSED
)
10352 const unsigned char * filename
;
10353 unsigned int filelen
;
10355 introduce (section
, false);
10357 /* The .gnu_debuglink section is formatted as:
10358 (c-string) Filename.
10359 (padding) If needed to reach a 4 byte boundary.
10360 (uint32_t) CRC32 value.
10362 The .gun_debugaltlink section is formatted as:
10363 (c-string) Filename.
10364 (binary) Build-ID. */
10366 filename
= section
->start
;
10367 filelen
= strnlen ((const char *) filename
, section
->size
);
10368 if (filelen
== section
->size
)
10370 warn (_("The debuglink filename is corrupt/missing\n"));
10374 printf (_(" Separate debug info file: %s\n"), filename
);
10376 if (startswith (section
->name
, ".gnu_debuglink"))
10378 unsigned int crc32
;
10379 unsigned int crc_offset
;
10381 crc_offset
= filelen
+ 1;
10382 crc_offset
= (crc_offset
+ 3) & ~3;
10383 if (crc_offset
+ 4 > section
->size
)
10385 warn (_("CRC offset missing/truncated\n"));
10389 crc32
= byte_get (filename
+ crc_offset
, 4);
10391 printf (_(" CRC value: %#x\n"), crc32
);
10393 if (crc_offset
+ 4 < section
->size
)
10395 warn (_("There are %#" PRIx64
10396 " extraneous bytes at the end of the section\n"),
10397 section
->size
- (crc_offset
+ 4));
10401 else /* startswith (section->name, ".gnu_debugaltlink") */
10403 const unsigned char *build_id
= section
->start
+ filelen
+ 1;
10404 size_t build_id_len
= section
->size
- (filelen
+ 1);
10407 /* FIXME: Should we support smaller build-id notes ? */
10408 if (build_id_len
< 0x14)
10410 warn (_("Build-ID is too short (%#zx bytes)\n"), build_id_len
);
10414 printed
= printf (_(" Build-ID (%#zx bytes):"), build_id_len
);
10415 display_data (printed
, build_id
, build_id_len
);
10424 display_gdb_index (struct dwarf_section
*section
,
10425 void *file ATTRIBUTE_UNUSED
)
10427 unsigned char *start
= section
->start
;
10429 uint32_t cu_list_offset
, tu_list_offset
;
10430 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10431 unsigned int cu_list_elements
, tu_list_elements
;
10432 unsigned int address_table_elements
, symbol_table_slots
;
10433 unsigned char *cu_list
, *tu_list
;
10434 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10437 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10439 introduce (section
, false);
10441 if (section
->size
< 6 * sizeof (uint32_t))
10443 warn (_("Truncated header in the %s section.\n"), section
->name
);
10447 version
= byte_get_little_endian (start
, 4);
10448 printf (_("Version %lu\n"), (unsigned long) version
);
10450 /* Prior versions are obsolete, and future versions may not be
10451 backwards compatible. */
10452 if (version
< 3 || version
> 8)
10454 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10458 warn (_("The address table data in version 3 may be wrong.\n"));
10460 warn (_("Version 4 does not support case insensitive lookups.\n"));
10462 warn (_("Version 5 does not include inlined functions.\n"));
10464 warn (_("Version 6 does not include symbol attributes.\n"));
10465 /* Version 7 indices generated by Gold have bad type unit references,
10466 PR binutils/15021. But we don't know if the index was generated by
10467 Gold or not, so to avoid worrying users with gdb-generated indices
10468 we say nothing for version 7 here. */
10470 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10471 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10472 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10473 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10474 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10476 if (cu_list_offset
> section
->size
10477 || tu_list_offset
> section
->size
10478 || address_table_offset
> section
->size
10479 || symbol_table_offset
> section
->size
10480 || constant_pool_offset
> section
->size
10481 || tu_list_offset
< cu_list_offset
10482 || address_table_offset
< tu_list_offset
10483 || symbol_table_offset
< address_table_offset
10484 || constant_pool_offset
< symbol_table_offset
)
10486 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10490 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 16;
10491 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 24;
10492 address_table_elements
= (symbol_table_offset
- address_table_offset
) / 20;
10493 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10495 cu_list
= start
+ cu_list_offset
;
10496 tu_list
= start
+ tu_list_offset
;
10497 address_table
= start
+ address_table_offset
;
10498 symbol_table
= start
+ symbol_table_offset
;
10499 constant_pool
= start
+ constant_pool_offset
;
10501 printf (_("\nCU table:\n"));
10502 for (i
= 0; i
< cu_list_elements
; i
++)
10504 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 16, 8);
10505 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 16 + 8, 8);
10507 printf ("[%3u] 0x%" PRIx64
" - 0x%" PRIx64
"\n",
10508 i
, cu_offset
, cu_offset
+ cu_length
- 1);
10511 printf (_("\nTU table:\n"));
10512 for (i
= 0; i
< tu_list_elements
; i
++)
10514 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 24, 8);
10515 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 24 + 8, 8);
10516 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 24 + 16, 8);
10518 printf ("[%3u] 0x%" PRIx64
" 0x%" PRIx64
" ",
10519 i
, tu_offset
, type_offset
);
10520 print_hex (signature
, 8);
10524 printf (_("\nAddress table:\n"));
10525 for (i
= 0; i
< address_table_elements
; i
++)
10527 uint64_t low
= byte_get_little_endian (address_table
+ i
* 20, 8);
10528 uint64_t high
= byte_get_little_endian (address_table
+ i
* 20 + 8, 8);
10529 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 20 + 16, 4);
10531 print_hex (low
, 8);
10532 print_hex (high
, 8);
10533 printf ("%" PRIu32
"\n", cu_index
);
10536 printf (_("\nSymbol table:\n"));
10537 for (i
= 0; i
< symbol_table_slots
; ++i
)
10539 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10540 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10541 uint32_t num_cus
, cu
;
10543 if (name_offset
!= 0
10544 || cu_vector_offset
!= 0)
10548 /* PR 17531: file: 5b7b07ad. */
10549 if (name_offset
>= section
->size
- constant_pool_offset
)
10551 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10552 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10556 printf ("[%3u] %.*s:", i
,
10557 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10558 constant_pool
+ name_offset
);
10560 if (section
->size
- constant_pool_offset
< 4
10561 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10563 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10564 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10565 cu_vector_offset
, i
);
10569 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10571 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10572 + cu_vector_offset
+ 4))
10574 printf ("<invalid number of CUs: %d>\n", num_cus
);
10575 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10583 for (j
= 0; j
< num_cus
; ++j
)
10586 gdb_index_symbol_kind kind
;
10588 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10589 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10590 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10591 cu
= GDB_INDEX_CU_VALUE (cu
);
10592 /* Convert to TU number if it's for a type unit. */
10593 if (cu
>= cu_list_elements
)
10594 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10595 (unsigned long) cu
- cu_list_elements
);
10597 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10599 printf (" [%s, %s]",
10600 is_static
? _("static") : _("global"),
10601 get_gdb_index_symbol_kind_name (kind
));
10613 /* Pre-allocate enough space for the CU/TU sets needed. */
10616 prealloc_cu_tu_list (unsigned int nshndx
)
10618 if (shndx_pool
== NULL
)
10620 shndx_pool_size
= nshndx
;
10621 shndx_pool_used
= 0;
10622 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10623 sizeof (unsigned int));
10627 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10628 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10629 sizeof (unsigned int));
10634 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10636 if (shndx_pool_used
>= shndx_pool_size
)
10638 error (_("Internal error: out of space in the shndx pool.\n"));
10641 shndx_pool
[shndx_pool_used
++] = shndx
;
10645 end_cu_tu_entry (void)
10647 if (shndx_pool_used
>= shndx_pool_size
)
10649 error (_("Internal error: out of space in the shndx pool.\n"));
10652 shndx_pool
[shndx_pool_used
++] = 0;
10655 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10657 static const char *
10658 get_DW_SECT_short_name (unsigned int dw_sect
)
10660 static char buf
[16];
10666 case DW_SECT_TYPES
:
10668 case DW_SECT_ABBREV
:
10674 case DW_SECT_STR_OFFSETS
:
10676 case DW_SECT_MACINFO
:
10678 case DW_SECT_MACRO
:
10684 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10688 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10689 These sections are extensions for Fission.
10690 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10693 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10695 unsigned char *phdr
= section
->start
;
10696 unsigned char *limit
= phdr
+ section
->size
;
10697 unsigned char *phash
;
10698 unsigned char *pindex
;
10699 unsigned char *ppool
;
10700 unsigned int version
;
10701 unsigned int ncols
= 0;
10702 unsigned int nused
;
10703 unsigned int nslots
;
10706 uint64_t signature
;
10709 /* PR 17512: file: 002-168123-0.004. */
10712 warn (_("Section %s is empty\n"), section
->name
);
10715 /* PR 17512: file: 002-376-0.004. */
10716 if (section
->size
< 24)
10718 warn (_("Section %s is too small to contain a CU/TU header\n"),
10724 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10726 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10727 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10728 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10730 pindex
= phash
+ (size_t) nslots
* 8;
10731 ppool
= pindex
+ (size_t) nslots
* 4;
10735 introduce (section
, false);
10737 printf (_(" Version: %u\n"), version
);
10739 printf (_(" Number of columns: %u\n"), ncols
);
10740 printf (_(" Number of used entries: %u\n"), nused
);
10741 printf (_(" Number of slots: %u\n\n"), nslots
);
10744 /* PR 17531: file: 45d69832. */
10745 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10746 || total
> (size_t) (limit
- phash
))
10748 warn (ngettext ("Section %s is too small for %u slot\n",
10749 "Section %s is too small for %u slots\n",
10751 section
->name
, nslots
);
10758 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10759 for (i
= 0; i
< nslots
; i
++)
10761 unsigned char *shndx_list
;
10762 unsigned int shndx
;
10764 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10765 if (signature
!= 0)
10767 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10768 shndx_list
= ppool
+ j
* 4;
10769 /* PR 17531: file: 705e010d. */
10770 if (shndx_list
< ppool
)
10772 warn (_("Section index pool located before start of section\n"));
10777 printf (_(" [%3d] Signature: 0x%" PRIx64
" Sections: "),
10781 if (shndx_list
>= limit
)
10783 warn (_("Section %s too small for shndx pool\n"),
10787 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10791 printf (" %d", shndx
);
10793 add_shndx_to_cu_tu_entry (shndx
);
10799 end_cu_tu_entry ();
10805 else if (version
== 2)
10808 unsigned int dw_sect
;
10809 unsigned char *ph
= phash
;
10810 unsigned char *pi
= pindex
;
10811 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10812 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10814 struct cu_tu_set
*this_set
= NULL
;
10816 unsigned char *prow
;
10819 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10821 /* PR 17531: file: 0dd159bf.
10822 Check for integer overflow (can occur when size_t is 32-bit)
10823 with overlarge ncols or nused values. */
10825 || _mul_overflow ((size_t) ncols
, 4, &temp
)
10826 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
10827 || total
> (size_t) (limit
- ppool
))
10829 warn (_("Section %s too small for offset and size tables\n"),
10836 printf (_(" Offset table\n"));
10837 printf (" slot %-16s ",
10838 is_tu_index
? _("signature") : _("dwo_id"));
10845 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10846 this_set
= tu_sets
;
10851 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10852 this_set
= cu_sets
;
10858 for (j
= 0; j
< ncols
; j
++)
10860 unsigned char *p
= ppool
+ j
* 4;
10861 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10862 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10867 for (i
= 0; i
< nslots
; i
++)
10869 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10871 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10874 /* PR 17531: file: a05f6ab3. */
10877 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10884 size_t num_copy
= sizeof (uint64_t);
10886 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10889 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10891 printf (" [%3d] 0x%" PRIx64
, i
, signature
);
10892 for (j
= 0; j
< ncols
; j
++)
10894 unsigned char *p
= prow
+ j
* 4;
10895 SAFE_BYTE_GET (val
, p
, 4, limit
);
10897 printf (" %8d", val
);
10901 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10903 /* PR 17531: file: 10796eb3. */
10904 if (dw_sect
>= DW_SECT_MAX
)
10905 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10907 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10923 printf (_(" Size table\n"));
10924 printf (" slot %-16s ",
10925 is_tu_index
? _("signature") : _("dwo_id"));
10928 for (j
= 0; j
< ncols
; j
++)
10930 unsigned char *p
= ppool
+ j
* 4;
10931 SAFE_BYTE_GET (val
, p
, 4, limit
);
10933 printf (" %8s", get_DW_SECT_short_name (val
));
10939 for (i
= 0; i
< nslots
; i
++)
10941 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10943 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10946 prow
= psizes
+ (row
- 1) * ncols
* 4;
10949 printf (" [%3d] 0x%" PRIx64
, i
, signature
);
10951 for (j
= 0; j
< ncols
; j
++)
10953 unsigned char *p
= prow
+ j
* 4;
10955 /* PR 28645: Check for overflow. Since we do not know how
10956 many populated rows there will be, we cannot just
10957 perform a single check at the start of this function. */
10958 if (p
> (limit
- 4))
10962 warn (_("Too many rows/columns in DWARF index section %s\n"),
10967 SAFE_BYTE_GET (val
, p
, 4, limit
);
10970 printf (" %8d", val
);
10974 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10975 if (dw_sect
>= DW_SECT_MAX
)
10976 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10978 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10990 else if (do_display
)
10991 printf (_(" Unsupported version (%d)\n"), version
);
10999 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
11001 /* Load the CU and TU indexes if present. This will build a list of
11002 section sets that we can use to associate a .debug_info.dwo section
11003 with its associated .debug_abbrev.dwo section in a .dwp file. */
11006 load_cu_tu_indexes (void *file
)
11008 /* If we have already loaded (or tried to load) the CU and TU indexes
11009 then do not bother to repeat the task. */
11010 if (cu_tu_indexes_read
== -1)
11012 cu_tu_indexes_read
= true;
11014 if (load_debug_section_with_follow (dwp_cu_index
, file
))
11015 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
11016 cu_tu_indexes_read
= false;
11018 if (load_debug_section_with_follow (dwp_tu_index
, file
))
11019 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
11020 cu_tu_indexes_read
= false;
11023 return (bool) cu_tu_indexes_read
;
11026 /* Find the set of sections that includes section SHNDX. */
11029 find_cu_tu_set (void *file
, unsigned int shndx
)
11033 if (! load_cu_tu_indexes (file
))
11036 /* Find SHNDX in the shndx pool. */
11037 for (i
= 0; i
< shndx_pool_used
; i
++)
11038 if (shndx_pool
[i
] == shndx
)
11041 if (i
>= shndx_pool_used
)
11044 /* Now backup to find the first entry in the set. */
11045 while (i
> 0 && shndx_pool
[i
- 1] != 0)
11048 return shndx_pool
+ i
;
11051 /* Display a .debug_cu_index or .debug_tu_index section. */
11054 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
11056 return process_cu_tu_index (section
, 1);
11060 display_debug_not_supported (struct dwarf_section
*section
,
11061 void *file ATTRIBUTE_UNUSED
)
11063 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11069 /* Like malloc, but takes two parameters like calloc.
11070 Verifies that the first parameter is not too large.
11071 Note: does *not* initialise the allocated memory to zero. */
11074 cmalloc (size_t nmemb
, size_t size
)
11076 /* Check for overflow. */
11077 if (nmemb
>= ~(size_t) 0 / size
)
11080 return xmalloc (nmemb
* size
);
11083 /* Like xmalloc, but takes two parameters like calloc.
11084 Verifies that the first parameter is not too large.
11085 Note: does *not* initialise the allocated memory to zero. */
11088 xcmalloc (size_t nmemb
, size_t size
)
11090 /* Check for overflow. */
11091 if (nmemb
>= ~(size_t) 0 / size
)
11094 _("Attempt to allocate an array with an excessive number of elements: %#zx\n"),
11099 return xmalloc (nmemb
* size
);
11102 /* Like xrealloc, but takes three parameters.
11103 Verifies that the second parameter is not too large.
11104 Note: does *not* initialise any new memory to zero. */
11107 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
11109 /* Check for overflow. */
11110 if (nmemb
>= ~(size_t) 0 / size
)
11112 error (_("Attempt to re-allocate an array with an excessive number of elements: %#zx\n"),
11117 return xrealloc (ptr
, nmemb
* size
);
11120 /* Like xcalloc, but verifies that the first parameter is not too large. */
11123 xcalloc2 (size_t nmemb
, size_t size
)
11125 /* Check for overflow. */
11126 if (nmemb
>= ~(size_t) 0 / size
)
11128 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: %#zx\n"),
11133 return xcalloc (nmemb
, size
);
11136 static unsigned long
11137 calc_gnu_debuglink_crc32 (unsigned long crc
,
11138 const unsigned char *buf
,
11141 static const unsigned long crc32_table
[256] =
11143 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
11144 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
11145 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
11146 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
11147 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
11148 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
11149 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
11150 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
11151 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
11152 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
11153 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
11154 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
11155 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
11156 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
11157 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
11158 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
11159 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
11160 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
11161 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
11162 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
11163 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
11164 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
11165 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
11166 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
11167 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
11168 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
11169 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
11170 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
11171 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
11172 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
11173 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
11174 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
11175 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
11176 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
11177 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
11178 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
11179 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
11180 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
11181 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
11182 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
11183 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
11184 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
11185 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
11186 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
11187 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
11188 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
11189 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
11190 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
11191 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
11192 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
11193 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
11196 const unsigned char *end
;
11198 crc
= ~crc
& 0xffffffff;
11199 for (end
= buf
+ len
; buf
< end
; ++ buf
)
11200 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
11201 return ~crc
& 0xffffffff;
11204 typedef bool (*check_func_type
) (const char *, void *);
11205 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
11208 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
11210 static unsigned char buffer
[8 * 1024];
11213 unsigned long crc
= 0;
11216 sep_data
= open_debug_file (pathname
);
11217 if (sep_data
== NULL
)
11220 /* Yes - we are opening the file twice... */
11221 f
= fopen (pathname
, "rb");
11224 /* Paranoia: This should never happen. */
11225 close_debug_file (sep_data
);
11226 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
11230 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
11231 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
11235 if (crc
!= * (unsigned long *) crc_pointer
)
11237 close_debug_file (sep_data
);
11238 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
11246 static const char *
11247 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
11250 unsigned int crc_offset
;
11251 unsigned long * crc32
= (unsigned long *) data
;
11253 /* The name is first.
11254 The CRC value is stored after the filename, aligned up to 4 bytes. */
11255 name
= (const char *) section
->start
;
11257 crc_offset
= strnlen (name
, section
->size
) + 1;
11258 if (crc_offset
== 1)
11260 crc_offset
= (crc_offset
+ 3) & ~3;
11261 if (crc_offset
+ 4 > section
->size
)
11264 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
11269 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
11271 void * sep_data
= open_debug_file (filename
);
11273 if (sep_data
== NULL
)
11276 /* FIXME: We should now extract the build-id in the separate file
11282 typedef struct build_id_data
11285 const unsigned char *data
;
11288 static const char *
11289 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
11294 Build_id_data
*build_id_data
;
11296 /* The name is first.
11297 The build-id follows immediately, with no padding, up to the section's end. */
11299 name
= (const char *) section
->start
;
11300 namelen
= strnlen (name
, section
->size
) + 1;
11303 if (namelen
>= section
->size
)
11306 id_len
= section
->size
- namelen
;
11310 build_id_data
= (Build_id_data
*) data
;
11311 build_id_data
->len
= id_len
;
11312 build_id_data
->data
= section
->start
+ namelen
;
11318 add_separate_debug_file (const char * filename
, void * handle
)
11320 separate_info
* i
= xmalloc (sizeof * i
);
11322 i
->filename
= filename
;
11323 i
->handle
= handle
;
11324 i
->next
= first_separate_info
;
11325 first_separate_info
= i
;
11328 #if HAVE_LIBDEBUGINFOD
11329 /* Query debuginfod servers for the target debuglink or debugaltlink
11330 file. If successful, store the path of the file in filename and
11331 return TRUE, otherwise return FALSE. */
11334 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
11338 size_t build_id_len
;
11339 unsigned char * build_id
;
11341 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
11343 /* Get the build-id of file. */
11344 build_id
= get_build_id (file
);
11347 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
11349 /* Get the build-id of the debugaltlink file. */
11350 unsigned int filelen
;
11352 filelen
= strnlen ((const char *)section
->start
, section
->size
);
11353 if (filelen
== section
->size
)
11354 /* Corrupt debugaltlink. */
11357 build_id
= section
->start
+ filelen
+ 1;
11358 build_id_len
= section
->size
- (filelen
+ 1);
11360 if (build_id_len
== 0)
11369 debuginfod_client
* client
;
11371 client
= debuginfod_begin ();
11372 if (client
== NULL
)
11375 /* Query debuginfod servers for the target file. If found its path
11376 will be stored in filename. */
11377 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
11378 debuginfod_end (client
);
11380 /* Only free build_id if we allocated space for a hex string
11381 in get_build_id (). */
11382 if (build_id_len
== 0)
11387 /* File successfully retrieved. Close fd since we want to
11388 use open_debug_file () on filename instead. */
11396 #endif /* HAVE_LIBDEBUGINFOD */
11399 load_separate_debug_info (const char * main_filename
,
11400 struct dwarf_section
* xlink
,
11401 parse_func_type parse_func
,
11402 check_func_type check_func
,
11404 void * file ATTRIBUTE_UNUSED
)
11406 const char * separate_filename
;
11407 char * debug_filename
;
11409 size_t canon_dirlen
;
11411 char * canon_filename
;
11412 char * canon_debug_filename
;
11415 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11417 warn (_("Corrupt debuglink section: %s\n"),
11418 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11422 /* Attempt to locate the separate file.
11423 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11425 canon_filename
= lrealpath (main_filename
);
11426 canon_dir
= xstrdup (canon_filename
);
11428 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11429 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11431 canon_dir
[canon_dirlen
] = '\0';
11434 #define DEBUGDIR "/lib/debug"
11436 #ifndef EXTRA_DEBUG_ROOT1
11437 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11439 #ifndef EXTRA_DEBUG_ROOT2
11440 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11443 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11445 + strlen (".debug/")
11446 #ifdef EXTRA_DEBUG_ROOT1
11447 + strlen (EXTRA_DEBUG_ROOT1
)
11449 #ifdef EXTRA_DEBUG_ROOT2
11450 + strlen (EXTRA_DEBUG_ROOT2
)
11452 + strlen (separate_filename
)
11454 if (debug_filename
== NULL
)
11456 warn (_("Out of memory"));
11458 free (canon_filename
);
11462 /* First try in the current directory. */
11463 sprintf (debug_filename
, "%s", separate_filename
);
11464 if (check_func (debug_filename
, func_data
))
11467 /* Then try in a subdirectory called .debug. */
11468 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11469 if (check_func (debug_filename
, func_data
))
11472 /* Then try in the same directory as the original file. */
11473 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11474 if (check_func (debug_filename
, func_data
))
11477 /* And the .debug subdirectory of that directory. */
11478 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11479 if (check_func (debug_filename
, func_data
))
11482 #ifdef EXTRA_DEBUG_ROOT1
11483 /* Try the first extra debug file root. */
11484 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11485 if (check_func (debug_filename
, func_data
))
11488 /* Try the first extra debug file root. */
11489 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11490 if (check_func (debug_filename
, func_data
))
11494 #ifdef EXTRA_DEBUG_ROOT2
11495 /* Try the second extra debug file root. */
11496 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11497 if (check_func (debug_filename
, func_data
))
11501 /* Then try in the global debug_filename directory. */
11502 strcpy (debug_filename
, DEBUGDIR
);
11503 dirlen
= strlen (DEBUGDIR
) - 1;
11504 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11505 strcat (debug_filename
, "/");
11506 strcat (debug_filename
, (const char *) separate_filename
);
11508 if (check_func (debug_filename
, func_data
))
11511 #if HAVE_LIBDEBUGINFOD
11513 char * tmp_filename
;
11516 && debuginfod_fetch_separate_debug_info (xlink
,
11520 /* File successfully downloaded from server, replace
11521 debug_filename with the file's path. */
11522 free (debug_filename
);
11523 debug_filename
= tmp_filename
;
11529 if (do_debug_links
)
11531 /* Failed to find the file. */
11532 warn (_("could not find separate debug file '%s'\n"),
11533 separate_filename
);
11534 warn (_("tried: %s\n"), debug_filename
);
11536 #ifdef EXTRA_DEBUG_ROOT2
11537 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11538 separate_filename
);
11539 warn (_("tried: %s\n"), debug_filename
);
11542 #ifdef EXTRA_DEBUG_ROOT1
11543 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11544 canon_dir
, separate_filename
);
11545 warn (_("tried: %s\n"), debug_filename
);
11547 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11548 separate_filename
);
11549 warn (_("tried: %s\n"), debug_filename
);
11552 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11553 separate_filename
);
11554 warn (_("tried: %s\n"), debug_filename
);
11556 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11557 warn (_("tried: %s\n"), debug_filename
);
11559 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11560 warn (_("tried: %s\n"), debug_filename
);
11562 sprintf (debug_filename
, "%s", separate_filename
);
11563 warn (_("tried: %s\n"), debug_filename
);
11565 #if HAVE_LIBDEBUGINFOD
11566 if (use_debuginfod
)
11568 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11573 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11579 free (debug_filename
);
11580 free (canon_filename
);
11586 canon_debug_filename
= lrealpath (debug_filename
);
11587 self
= strcmp (canon_debug_filename
, canon_filename
) == 0;
11588 free (canon_filename
);
11589 free (canon_debug_filename
);
11592 free (debug_filename
);
11596 void * debug_handle
;
11598 /* Now open the file.... */
11599 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11601 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11602 free (debug_filename
);
11606 /* FIXME: We do not check to see if there are any other separate debug info
11607 files that would also match. */
11609 if (do_debug_links
)
11610 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11611 add_separate_debug_file (debug_filename
, debug_handle
);
11613 /* Do not free debug_filename - it might be referenced inside
11614 the structure returned by open_debug_file(). */
11615 return debug_handle
;
11618 /* Attempt to load a separate dwarf object file. */
11621 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11623 char * separate_filename
;
11624 void * separate_handle
;
11626 if (IS_ABSOLUTE_PATH (name
))
11627 separate_filename
= strdup (name
);
11629 /* FIXME: Skip adding / if dwo_dir ends in /. */
11630 separate_filename
= concat (dir
, "/", name
, NULL
);
11631 if (separate_filename
== NULL
)
11633 warn (_("Out of memory allocating dwo filename\n"));
11637 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11639 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11640 free (separate_filename
);
11644 /* FIXME: We should check the dwo_id. */
11646 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11648 add_separate_debug_file (separate_filename
, separate_handle
);
11649 /* Note - separate_filename will be freed in free_debug_memory(). */
11650 return separate_handle
;
11654 try_build_id_prefix (const char * prefix
, char * filename
, const unsigned char * data
, unsigned long id_len
)
11656 char * f
= filename
;
11658 f
+= sprintf (f
, "%s.build-id/%02x/", prefix
, (unsigned) *data
++);
11661 f
+= sprintf (f
, "%02x", (unsigned) *data
++);
11662 strcpy (f
, ".debug");
11664 return open_debug_file (filename
);
11667 /* Try to load a debug file based upon the build-id held in the .note.gnu.build-id section. */
11670 load_build_id_debug_file (const char * main_filename ATTRIBUTE_UNUSED
, void * main_file
)
11672 if (! load_debug_section (note_gnu_build_id
, main_file
))
11673 return; /* No .note.gnu.build-id section. */
11675 struct dwarf_section
* section
= & debug_displays
[note_gnu_build_id
].section
;
11676 if (section
== NULL
)
11678 warn (_("Unable to load the .note.gnu.build-id section\n"));
11682 if (section
->start
== NULL
|| section
->size
< 0x18)
11684 warn (_(".note.gnu.build-id section is corrupt/empty\n"));
11688 /* In theory we should extract the contents of the section into
11689 a note structure and then check the fields. For now though
11690 just use hard coded offsets instead:
11692 Field Bytes Contents
11695 Type 8..11 3 (NT_GNU_BUILD_ID)
11699 /* FIXME: Check the name size, name and type fields. */
11701 unsigned long build_id_size
;
11702 build_id_size
= byte_get (section
->start
+ 4, 4);
11703 if (build_id_size
< 8)
11705 warn (_(".note.gnu.build-id data size is too small\n"));
11709 if (build_id_size
> (section
->size
- 16))
11711 warn (_(".note.gnu.build-id data size is too bug\n"));
11716 filename
= xmalloc (strlen (".build-id/")
11717 + build_id_size
* 2 + 2
11718 + strlen (".debug")
11719 /* The next string should be the same as the longest
11720 name found in the prefixes[] array below. */
11721 + strlen ("/usrlib64/debug/usr")
11725 static const char * prefixes
[] =
11730 "/usr/lib/debug/usr/",
11731 "/usr/lib64/debug/",
11732 "/usr/lib64/debug/usr"
11734 long unsigned int i
;
11736 for (i
= 0; i
< ARRAY_SIZE (prefixes
); i
++)
11738 handle
= try_build_id_prefix (prefixes
[i
], filename
,
11739 section
->start
+ 16, build_id_size
);
11740 if (handle
!= NULL
)
11743 /* FIXME: TYhe BFD library also tries a global debugfile directory prefix. */
11744 if (handle
== NULL
)
11746 /* Failed to find a debug file associated with the build-id.
11747 This is not an error however, rather it just means that
11748 the debug info has probably not been loaded on the system,
11749 or that another method is being used to link to the debug
11755 add_separate_debug_file (filename
, handle
);
11758 /* Try to load a debug file pointed to by the .debug_sup section. */
11761 load_debug_sup_file (const char * main_filename
, void * file
)
11763 if (! load_debug_section (debug_sup
, file
))
11764 return; /* No .debug_sup section. */
11766 struct dwarf_section
* section
;
11767 section
= & debug_displays
[debug_sup
].section
;
11768 assert (section
!= NULL
);
11770 if (section
->start
== NULL
|| section
->size
< 5)
11772 warn (_(".debug_sup section is corrupt/empty\n"));
11776 if (section
->start
[2] != 0)
11777 return; /* This is a supplementary file. */
11779 const char * filename
= (const char *) section
->start
+ 3;
11780 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11782 warn (_("filename in .debug_sup section is corrupt\n"));
11786 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11791 new_len
= asprintf (& new_name
, "%.*s/%s",
11792 (int) (strrchr (main_filename
, '/') - main_filename
),
11797 warn (_("unable to construct path for supplementary debug file"));
11802 filename
= new_name
;
11806 /* PR 27796: Make sure that we pass a filename that can be free'd to
11807 add_separate_debug_file(). */
11808 filename
= strdup (filename
);
11809 if (filename
== NULL
)
11811 warn (_("out of memory constructing filename for .debug_sup link\n"));
11816 void * handle
= open_debug_file (filename
);
11817 if (handle
== NULL
)
11819 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11820 free ((void *) filename
);
11824 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11826 /* FIXME: Compare the checksums, if present. */
11827 add_separate_debug_file (filename
, handle
);
11830 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11831 Recursively check the loaded files for more of these sections.
11832 Also follow any links in .debug_sup sections.
11833 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11836 check_for_and_load_links (void * file
, const char * filename
)
11838 void * handle
= NULL
;
11840 if (load_debug_section (gnu_debugaltlink
, file
))
11842 Build_id_data build_id_data
;
11844 handle
= load_separate_debug_info (filename
,
11845 & debug_displays
[gnu_debugaltlink
].section
,
11846 parse_gnu_debugaltlink
,
11847 check_gnu_debugaltlink
,
11852 assert (handle
== first_separate_info
->handle
);
11853 check_for_and_load_links (first_separate_info
->handle
,
11854 first_separate_info
->filename
);
11858 if (load_debug_section (gnu_debuglink
, file
))
11860 unsigned long crc32
;
11862 handle
= load_separate_debug_info (filename
,
11863 & debug_displays
[gnu_debuglink
].section
,
11864 parse_gnu_debuglink
,
11865 check_gnu_debuglink
,
11870 assert (handle
== first_separate_info
->handle
);
11871 check_for_and_load_links (first_separate_info
->handle
,
11872 first_separate_info
->filename
);
11876 load_debug_sup_file (filename
, file
);
11878 load_build_id_debug_file (filename
, file
);
11881 /* Load the separate debug info file(s) attached to FILE, if any exist.
11882 Returns TRUE if any were found, FALSE otherwise.
11883 If TRUE is returned then the linked list starting at first_separate_info
11884 will be populated with open file handles. */
11887 load_separate_debug_files (void * file
, const char * filename
)
11889 /* Skip this operation if we are not interested in debug links. */
11890 if (! do_follow_links
&& ! do_debug_links
)
11893 /* See if there are any dwo links. */
11894 if (load_debug_section (str
, file
)
11895 && load_debug_section (abbrev
, file
)
11896 && load_debug_section (info
, file
))
11898 /* Load the .debug_addr section, if it exists. */
11899 load_debug_section (debug_addr
, file
);
11900 /* Load the .debug_str_offsets section, if it exists. */
11901 load_debug_section (str_index
, file
);
11902 /* Load the .debug_loclists section, if it exists. */
11903 load_debug_section (loclists
, file
);
11904 /* Load the .debug_rnglists section, if it exists. */
11905 load_debug_section (rnglists
, file
);
11909 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11912 bool introduced
= false;
11914 const char *dir
= NULL
;
11915 const char *id
= NULL
;
11916 const char *name
= NULL
;
11918 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11920 /* Accumulate NAME, DIR and ID fields. */
11921 switch (dwinfo
->type
)
11925 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11926 name
= dwinfo
->value
;
11930 /* There can be multiple DW_AT_comp_dir entries in a CU,
11931 so do not complain. */
11932 dir
= dwinfo
->value
;
11937 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11938 id
= dwinfo
->value
;
11942 error (_("Unexpected DWO INFO type"));
11946 /* If we have reached the end of our list, or we are changing
11947 CUs, then display the information that we have accumulated
11950 && (dwinfo
->next
== NULL
11951 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11953 if (do_debug_links
)
11957 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11958 debug_displays
[info
].section
.uncompressed_name
);
11962 printf (_(" Name: %s\n"), name
);
11963 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11965 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11966 else if (debug_information
[0].dwarf_version
!= 5)
11967 printf (_(" ID: <not specified>\n"));
11971 if (do_follow_links
)
11972 load_dwo_file (filename
, name
, dir
, id
);
11974 name
= dir
= id
= NULL
;
11980 if (! do_follow_links
)
11981 /* The other debug links will be displayed by display_debug_links()
11982 so we do not need to do any further processing here. */
11985 /* FIXME: We do not check for the presence of both link sections in the same file. */
11986 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11987 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11989 check_for_and_load_links (file
, filename
);
11990 if (first_separate_info
!= NULL
)
11993 do_follow_links
= 0;
11998 free_debug_memory (void)
12002 free_all_abbrevs ();
12006 shndx_pool_size
= 0;
12007 shndx_pool_used
= 0;
12015 memset (level_type_signed
, 0, sizeof level_type_signed
);
12016 cu_tu_indexes_read
= -1;
12018 for (i
= 0; i
< max
; i
++)
12019 free_debug_section ((enum dwarf_section_display_enum
) i
);
12021 if (debug_information
!= NULL
)
12023 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
12025 if (debug_information
[i
].max_loc_offsets
)
12027 free (debug_information
[i
].loc_offsets
);
12028 free (debug_information
[i
].have_frame_base
);
12030 if (debug_information
[i
].max_range_lists
)
12031 free (debug_information
[i
].range_lists
);
12033 free (debug_information
);
12034 debug_information
= NULL
;
12035 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
12039 separate_info
* next
;
12041 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
12043 close_debug_file (d
->handle
);
12044 free ((void *) d
->filename
);
12048 first_separate_info
= NULL
;
12056 const char *option
;
12059 } debug_dump_long_opts
;
12061 static const debug_dump_long_opts debug_option_table
[] =
12063 { 'A', "addr", &do_debug_addr
, 1 },
12064 { 'a', "abbrev", &do_debug_abbrevs
, 1 },
12065 { 'c', "cu_index", &do_debug_cu_index
, 1 },
12066 #ifdef HAVE_LIBDEBUGINFOD
12067 { 'D', "use-debuginfod", &use_debuginfod
, 1 },
12068 { 'E', "do-not-use-debuginfod", &use_debuginfod
, 0 },
12070 { 'F', "frames-interp", &do_debug_frames_interp
, 1 },
12071 { 'f', "frames", &do_debug_frames
, 1 },
12072 { 'g', "gdb_index", &do_gdb_index
, 1 },
12073 { 'i', "info", &do_debug_info
, 1 },
12074 { 'K', "follow-links", &do_follow_links
, 1 },
12075 { 'k', "links", &do_debug_links
, 1 },
12076 { 'L', "decodedline", &do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
12077 { 'l', "rawline", &do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
12078 /* For compatibility with earlier versions of readelf. */
12079 { 'l', "line", &do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
12080 { 'm', "macro", &do_debug_macinfo
, 1 },
12081 { 'N', "no-follow-links", &do_follow_links
, 0 },
12082 { 'O', "str-offsets", &do_debug_str_offsets
, 1 },
12083 { 'o', "loc", &do_debug_loc
, 1 },
12084 { 'p', "pubnames", &do_debug_pubnames
, 1 },
12085 { 'R', "Ranges", &do_debug_ranges
, 1 },
12086 { 'r', "aranges", &do_debug_aranges
, 1 },
12087 /* For compatibility with earlier versions of readelf. */
12088 { 'r', "ranges", &do_debug_aranges
, 1 },
12089 { 's', "str", &do_debug_str
, 1 },
12090 { 'T', "trace_aranges", &do_trace_aranges
, 1 },
12091 { 't', "pubtypes", &do_debug_pubtypes
, 1 },
12092 { 'U', "trace_info", &do_trace_info
, 1 },
12093 { 'u', "trace_abbrev", &do_trace_abbrevs
, 1 },
12094 { 0, NULL
, NULL
, 0 }
12097 /* Enable display of specific DWARF sections as determined by the comma
12098 separated strings in NAMES. Returns non-zero if any displaying was
12102 dwarf_select_sections_by_names (const char *names
)
12110 const debug_dump_long_opts
*entry
;
12112 for (entry
= debug_option_table
; entry
->option
; entry
++)
12114 size_t len
= strlen (entry
->option
);
12116 if (strncmp (p
, entry
->option
, len
) == 0
12117 && (p
[len
] == ',' || p
[len
] == '\0'))
12119 if (entry
->val
== 0)
12120 * entry
->variable
= 0;
12122 * entry
->variable
= entry
->val
;
12123 result
|= entry
->val
;
12130 if (entry
->option
== NULL
)
12132 warn (_("Unrecognized debug option '%s'\n"), p
);
12133 p
= strchr (p
, ',');
12142 /* The --debug-dump=frames-interp option also enables the
12143 --debug-dump=frames option. */
12144 if (do_debug_frames_interp
)
12145 do_debug_frames
= 1;
12150 /* Enable display of specific DWARF sections as determined by the characters
12151 in LETTERS. Returns non-zero if any displaying was enabled. */
12154 dwarf_select_sections_by_letters (const char *letters
)
12160 const debug_dump_long_opts
*entry
;
12162 for (entry
= debug_option_table
; entry
->letter
; entry
++)
12164 if (entry
->letter
== * letters
)
12166 if (entry
->val
== 0)
12167 * entry
->variable
= 0;
12169 * entry
->variable
|= entry
->val
;
12170 result
|= entry
->val
;
12175 if (entry
->letter
== 0)
12176 warn (_("Unrecognized debug letter option '%c'\n"), * letters
);
12181 /* The --debug-dump=frames-interp option also enables the
12182 --debug-dump=frames option. */
12183 if (do_debug_frames_interp
)
12184 do_debug_frames
= 1;
12190 dwarf_select_sections_all (void)
12193 do_debug_abbrevs
= 1;
12194 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
12195 do_debug_pubnames
= 1;
12196 do_debug_pubtypes
= 1;
12197 do_debug_aranges
= 1;
12198 do_debug_ranges
= 1;
12199 do_debug_frames
= 1;
12200 do_debug_macinfo
= 1;
12205 do_trace_abbrevs
= 1;
12206 do_trace_aranges
= 1;
12208 do_debug_cu_index
= 1;
12209 do_follow_links
= 1;
12210 do_debug_links
= 1;
12211 do_debug_str_offsets
= 1;
12214 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
12215 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
12217 /* N.B. The order here must match the order in section_display_enum. */
12219 struct dwarf_section_display debug_displays
[] =
12221 { { ".debug_abbrev", ".zdebug_abbrev", ".dwabrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
12222 { { ".debug_aranges", ".zdebug_aranges", ".dwarnge", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
12223 { { ".debug_frame", ".zdebug_frame", ".dwframe", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
12224 { { ".debug_info", ".zdebug_info", ".dwinfo", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
12225 { { ".debug_line", ".zdebug_line", ".dwline", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
12226 { { ".debug_pubnames", ".zdebug_pubnames", ".dwpbnms", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
12227 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
12228 { { ".eh_frame", "", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
12229 { { ".debug_macinfo", ".zdebug_macinfo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
12230 { { ".debug_macro", ".zdebug_macro", ".dwmac", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
12231 { { ".debug_str", ".zdebug_str", ".dwstr", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12232 { { ".debug_line_str", ".zdebug_line_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12233 { { ".debug_loc", ".zdebug_loc", ".dwloc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12234 { { ".debug_loclists", ".zdebug_loclists", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12235 { { ".debug_loclists.dwo", ".zdebug_loclists.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12236 { { ".debug_pubtypes", ".zdebug_pubtypes", ".dwpbtyp", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
12237 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
12238 { { ".debug_ranges", ".zdebug_ranges", ".dwrnges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12239 { { ".debug_rnglists", ".zdebug_rnglists", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12240 { { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12241 { { ".debug_static_func", ".zdebug_static_func", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12242 { { ".debug_static_vars", ".zdebug_static_vars", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12243 { { ".debug_types", ".zdebug_types", "", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
12244 { { ".debug_weaknames", ".zdebug_weaknames", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12245 { { ".gdb_index", "", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
12246 { { ".debug_names", "", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
12247 { { ".trace_info", "", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
12248 { { ".trace_abbrev", "", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
12249 { { ".trace_aranges", "", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
12250 { { ".debug_info.dwo", ".zdebug_info.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
12251 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", "", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
12252 { { ".debug_types.dwo", ".zdebug_types.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
12253 { { ".debug_line.dwo", ".zdebug_line.dwo", "", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
12254 { { ".debug_loc.dwo", ".zdebug_loc.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12255 { { ".debug_macro.dwo", ".zdebug_macro.dwo", "", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
12256 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
12257 { { ".debug_str.dwo", ".zdebug_str.dwo", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
12258 { { ".debug_str_offsets", ".zdebug_str_offsets", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
12259 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
12260 { { ".debug_addr", ".zdebug_addr", "", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
12261 { { ".debug_cu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
12262 { { ".debug_tu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
12263 { { ".gnu_debuglink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
12264 { { ".gnu_debugaltlink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
12265 { { ".debug_sup", "", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
12266 /* Separate debug info files can containt their own .debug_str section,
12267 and this might be in *addition* to a .debug_str section already present
12268 in the main file. Hence we need to have two entries for .debug_str. */
12269 { { ".debug_str", ".zdebug_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12270 { { ".note.gnu.build-id", "", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12273 /* A static assertion. */
12274 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];