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 %#" 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: <%#" 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: <%#" 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: <%#" 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_ns (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: <%#" 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: <%#" 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 (" <%#" 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 (" <%#" PRIx64
">", cu_offset
+ uvalue
);
1630 case DW_OP_GNU_convert
:
1631 READ_ULEB (uvalue
, data
, end
);
1632 printf ("%s <%#" 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 <%#" 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: <%#" PRIx64
">",
1647 cu_offset
+ uvalue
);
1650 READ_ULEB (uvalue
, data
, end
);
1651 printf ("DW_OP_addrx <%#" PRIx64
">", uvalue
);
1653 case DW_OP_GNU_addr_index
:
1654 READ_ULEB (uvalue
, data
, end
);
1655 printf ("DW_OP_GNU_addr_index <%#" PRIx64
">", uvalue
);
1657 case DW_OP_GNU_const_index
:
1658 READ_ULEB (uvalue
, data
, end
);
1659 printf ("DW_OP_GNU_const_index <%#" 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: <%#" 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 %#x)"), op
);
1721 printf (_("(Unknown location op %#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<%#" PRIx64
">", delimiter
, uvalue
);
2514 case DW_FORM_GNU_ref_alt
:
2518 /* We have already printed the form name. */
2519 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
);
2521 printf ("%c<alt %#" PRIx64
">", delimiter
, uvalue
);
2523 /* FIXME: Follow the reference... */
2529 case DW_FORM_ref_sup4
:
2530 case DW_FORM_ref_udata
:
2532 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
+ cu_offset
);
2537 case DW_FORM_sec_offset
:
2539 printf ("%c%#" 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 ("%c%#" PRIx64
, delimiter
, utmp
);
2573 case DW_FORM_data16
:
2577 printf (" %#" PRIx64
, uvalue
);
2579 printf (" %#" 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: %#" PRIx64
"): %s"),
2634 delimiter
, uvalue
, fetch_indirect_string (uvalue
));
2636 printf (_("%c(indirect string, offset: %#" 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: %#" PRIx64
"): %s"),
2647 delimiter
, uvalue
, fetch_indirect_line_string (uvalue
));
2649 printf (_("%c(indirect line string, offset: %#" 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: %#" PRIx64
"): %s"),
2671 delimiter
, uvalue
, strng
);
2673 printf (_("%c(indexed string: %#" 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: %#" PRIx64
") %s"),
2684 delimiter
, uvalue
, fetch_alt_indirect_string (uvalue
));
2686 printf (_("%c(alt indirect string, offset: %#" 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: %#" 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: %#" PRIx64
"): %#" PRIx64
),
2780 delimiter
, uvalue
, idx
);
2784 case DW_FORM_strp_sup
:
2786 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
+ cu_offset
);
2790 warn (_("Unrecognized form: %#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 /* Free memory allocated for one unit in debug_information. */
3515 free_debug_information (debug_info
*ent
)
3517 if (ent
->max_loc_offsets
)
3519 free (ent
->loc_offsets
);
3520 free (ent
->loc_views
);
3521 free (ent
->have_frame_base
);
3523 if (ent
->max_range_lists
)
3524 free (ent
->range_lists
);
3527 /* Process the contents of a .debug_info section.
3528 If do_loc is TRUE then we are scanning for location lists and dwo tags
3529 and we do not want to display anything to the user.
3530 If do_types is TRUE, we are processing a .debug_types section instead of
3531 a .debug_info section.
3532 The information displayed is restricted by the values in DWARF_START_DIE
3533 and DWARF_CUTOFF_LEVEL.
3534 Returns TRUE upon success. Otherwise an error or warning message is
3535 printed and FALSE is returned. */
3538 process_debug_info (struct dwarf_section
* section
,
3540 enum dwarf_section_display_enum abbrev_sec
,
3544 unsigned char *start
= section
->start
;
3545 unsigned char *end
= start
+ section
->size
;
3546 unsigned char *section_begin
;
3548 unsigned int num_units
= 0;
3550 /* First scan the section to get the number of comp units.
3551 Length sanity checks are done here. */
3552 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3557 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3558 will be the length. For a 64-bit DWARF section, it'll be
3559 the escape code 0xffffffff followed by an 8 byte length. */
3560 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3562 if (length
== 0xffffffff)
3563 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3564 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3566 warn (_("Reserved length value (%#" PRIx64
") found in section %s\n"),
3567 length
, section
->name
);
3571 /* Negative values are illegal, they may even cause infinite
3572 looping. This can happen if we can't accurately apply
3573 relocations to an object file, or if the file is corrupt. */
3574 if (length
> (size_t) (end
- section_begin
))
3576 warn (_("Corrupt unit length (got %#" PRIx64
3577 " expected at most %#tx) in section %s\n"),
3578 length
, end
- section_begin
, section
->name
);
3581 section_begin
+= length
;
3586 error (_("No comp units in %s section ?\n"), section
->name
);
3590 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
3591 && num_debug_info_entries
== 0
3595 /* Then allocate an array to hold the information. */
3596 debug_information
= (debug_info
*) cmalloc (num_units
,
3597 sizeof (* debug_information
));
3598 if (debug_information
== NULL
)
3600 error (_("Not enough memory for a debug info array of %u entries\n"),
3602 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3606 /* PR 17531: file: 92ca3797.
3607 We cannot rely upon the debug_information array being initialised
3608 before it is used. A corrupt file could easily contain references
3609 to a unit for which information has not been made available. So
3610 we ensure that the array is zeroed here. */
3611 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3613 alloc_num_debug_info_entries
= num_units
;
3618 load_debug_section_with_follow (str
, file
);
3619 load_debug_section_with_follow (line_str
, file
);
3620 load_debug_section_with_follow (str_dwo
, file
);
3621 load_debug_section_with_follow (str_index
, file
);
3622 load_debug_section_with_follow (str_index_dwo
, file
);
3623 load_debug_section_with_follow (debug_addr
, file
);
3626 load_debug_section_with_follow (abbrev_sec
, file
);
3627 load_debug_section_with_follow (loclists
, file
);
3628 load_debug_section_with_follow (rnglists
, file
);
3629 load_debug_section_with_follow (loclists_dwo
, file
);
3630 load_debug_section_with_follow (rnglists_dwo
, file
);
3632 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3634 warn (_("Unable to locate %s section!\n"),
3635 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3639 if (!do_loc
&& dwarf_start_die
== 0)
3640 introduce (section
, false);
3642 free_all_abbrevs ();
3644 /* In order to be able to resolve DW_FORM_ref_addr forms we need
3645 to load *all* of the abbrevs for all CUs in this .debug_info
3646 section. This does effectively mean that we (partially) read
3647 every CU header twice. */
3648 for (section_begin
= start
; start
< end
;)
3650 DWARF2_Internal_CompUnit compunit
;
3651 unsigned char *hdrptr
;
3652 uint64_t abbrev_base
;
3655 unsigned int offset_size
;
3656 struct cu_tu_set
*this_set
;
3657 unsigned char *end_cu
;
3660 cu_offset
= start
- section_begin
;
3662 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3664 if (compunit
.cu_length
== 0xffffffff)
3666 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3671 end_cu
= hdrptr
+ compunit
.cu_length
;
3673 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3675 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3677 if (compunit
.cu_version
< 5)
3679 compunit
.cu_unit_type
= DW_UT_compile
;
3680 /* Initialize it due to a false compiler warning. */
3681 compunit
.cu_pointer_size
= -1;
3685 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3686 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3688 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3691 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3694 if (compunit
.cu_unit_type
== DW_UT_split_compile
3695 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3698 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3701 if (this_set
== NULL
)
3704 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3708 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3709 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3713 abbrev_list
*free_list
;
3714 list
= find_and_process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3715 abbrev_base
, abbrev_size
,
3716 compunit
.cu_abbrev_offset
,
3719 if (list
!= NULL
&& list
->first_abbrev
!= NULL
)
3720 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
,
3722 else if (free_list
!= NULL
)
3723 free_abbrev_list (free_list
);
3726 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3728 DWARF2_Internal_CompUnit compunit
;
3729 unsigned char *hdrptr
;
3730 unsigned char *tags
;
3731 int level
, last_level
, saved_level
;
3733 unsigned int offset_size
;
3734 uint64_t signature
= 0;
3735 uint64_t type_offset
= 0;
3736 struct cu_tu_set
*this_set
;
3737 uint64_t abbrev_base
;
3739 unsigned char *end_cu
;
3742 cu_offset
= start
- section_begin
;
3744 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3746 if (compunit
.cu_length
== 0xffffffff)
3748 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3753 end_cu
= hdrptr
+ compunit
.cu_length
;
3755 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3757 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3759 if (compunit
.cu_version
< 5)
3761 compunit
.cu_unit_type
= DW_UT_compile
;
3762 /* Initialize it due to a false compiler warning. */
3763 compunit
.cu_pointer_size
= -1;
3767 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3768 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3770 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3773 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3775 if (this_set
== NULL
)
3778 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3782 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3783 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3786 if (compunit
.cu_version
< 5)
3787 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3789 bool do_dwo_id
= false;
3790 uint64_t dwo_id
= 0;
3791 if (compunit
.cu_unit_type
== DW_UT_split_compile
3792 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3794 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3798 /* PR 17512: file: 001-108546-0.001:0.1. */
3799 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3801 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3802 compunit
.cu_pointer_size
, offset_size
);
3803 compunit
.cu_pointer_size
= offset_size
;
3808 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
3809 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
3812 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
3818 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
3819 && num_debug_info_entries
== 0
3820 && alloc_num_debug_info_entries
> unit
3823 free_debug_information (&debug_information
[unit
]);
3824 memset (&debug_information
[unit
], 0, sizeof (*debug_information
));
3825 debug_information
[unit
].pointer_size
= compunit
.cu_pointer_size
;
3826 debug_information
[unit
].offset_size
= offset_size
;
3827 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3828 debug_information
[unit
].cu_offset
= cu_offset
;
3829 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3830 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3833 if (!do_loc
&& dwarf_start_die
== 0)
3835 printf (_(" Compilation Unit @ offset %#" PRIx64
":\n"),
3837 printf (_(" Length: %#" PRIx64
" (%s)\n"),
3839 offset_size
== 8 ? "64-bit" : "32-bit");
3840 printf (_(" Version: %d\n"), compunit
.cu_version
);
3841 if (compunit
.cu_version
>= 5)
3843 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
3845 printf (_(" Unit Type: %s (%x)\n"),
3846 name
? name
: "???",
3847 compunit
.cu_unit_type
);
3849 printf (_(" Abbrev Offset: %#" PRIx64
"\n"),
3850 compunit
.cu_abbrev_offset
);
3851 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3854 printf (_(" Signature: %#" PRIx64
"\n"), signature
);
3855 printf (_(" Type Offset: %#" PRIx64
"\n"), type_offset
);
3858 printf (_(" DWO ID: %#" PRIx64
"\n"), dwo_id
);
3859 if (this_set
!= NULL
)
3861 uint64_t *offsets
= this_set
->section_offsets
;
3862 size_t *sizes
= this_set
->section_sizes
;
3864 printf (_(" Section contributions:\n"));
3865 printf (_(" .debug_abbrev.dwo: %#" PRIx64
" %#zx\n"),
3866 offsets
[DW_SECT_ABBREV
], sizes
[DW_SECT_ABBREV
]);
3867 printf (_(" .debug_line.dwo: %#" PRIx64
" %#zx\n"),
3868 offsets
[DW_SECT_LINE
], sizes
[DW_SECT_LINE
]);
3869 printf (_(" .debug_loc.dwo: %#" PRIx64
" %#zx\n"),
3870 offsets
[DW_SECT_LOC
], sizes
[DW_SECT_LOC
]);
3871 printf (_(" .debug_str_offsets.dwo: %#" PRIx64
" %#zx\n"),
3872 offsets
[DW_SECT_STR_OFFSETS
], sizes
[DW_SECT_STR_OFFSETS
]);
3879 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3881 warn (_("CU at offset %#" PRIx64
" contains corrupt or "
3882 "unsupported version number: %d.\n"),
3883 cu_offset
, compunit
.cu_version
);
3887 if (compunit
.cu_unit_type
!= DW_UT_compile
3888 && compunit
.cu_unit_type
!= DW_UT_partial
3889 && compunit
.cu_unit_type
!= DW_UT_type
3890 && compunit
.cu_unit_type
!= DW_UT_split_compile
3891 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3893 warn (_("CU at offset %#" PRIx64
" contains corrupt or "
3894 "unsupported unit type: %d.\n"),
3895 cu_offset
, compunit
.cu_unit_type
);
3899 /* Process the abbrevs used by this compilation unit. */
3901 list
= find_and_process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3902 abbrev_base
, abbrev_size
,
3903 compunit
.cu_abbrev_offset
, NULL
);
3907 while (tags
< start
)
3909 unsigned long abbrev_number
;
3910 unsigned long die_offset
;
3911 abbrev_entry
*entry
;
3913 int do_printing
= 1;
3915 die_offset
= tags
- section_begin
;
3917 READ_ULEB (abbrev_number
, tags
, start
);
3919 /* A null DIE marks the end of a list of siblings or it may also be
3920 a section padding. */
3921 if (abbrev_number
== 0)
3923 /* Check if it can be a section padding for the last CU. */
3924 if (level
== 0 && start
== end
)
3928 for (chk
= tags
; chk
< start
; chk
++)
3935 if (!do_loc
&& die_offset
>= dwarf_start_die
3936 && (dwarf_cutoff_level
== -1
3937 || level
< dwarf_cutoff_level
))
3938 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3944 static unsigned num_bogus_warns
= 0;
3946 if (num_bogus_warns
< 3)
3948 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3949 die_offset
, section
->name
);
3951 if (num_bogus_warns
== 3)
3952 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3955 if (dwarf_start_die
!= 0 && level
< saved_level
)
3962 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3966 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3967 saved_level
= level
;
3968 do_printing
= (dwarf_cutoff_level
== -1
3969 || level
< dwarf_cutoff_level
);
3971 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3972 level
, die_offset
, abbrev_number
);
3973 else if (dwarf_cutoff_level
== -1
3974 || last_level
< dwarf_cutoff_level
)
3975 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3980 /* Scan through the abbreviation list until we reach the
3984 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3985 if (entry
->number
== abbrev_number
)
3990 if (!do_loc
&& do_printing
)
3995 warn (_("DIE at offset %#lx refers to abbreviation number %lu which does not exist\n"),
3996 die_offset
, abbrev_number
);
4000 if (!do_loc
&& do_printing
)
4001 printf (" (%s)\n", get_TAG_name (entry
->tag
));
4006 need_base_address
= 0;
4008 case DW_TAG_compile_unit
:
4009 case DW_TAG_skeleton_unit
:
4010 need_base_address
= 1;
4011 need_dwo_info
= do_loc
;
4013 case DW_TAG_entry_point
:
4014 case DW_TAG_subprogram
:
4015 need_base_address
= 0;
4016 /* Assuming that there is no DW_AT_frame_base. */
4017 have_frame_base
= 0;
4021 debug_info
*debug_info_p
=
4022 (debug_information
&& unit
< alloc_num_debug_info_entries
)
4023 ? debug_information
+ unit
: NULL
;
4025 assert (!debug_info_p
4026 || (debug_info_p
->num_loc_offsets
4027 == debug_info_p
->num_loc_views
));
4029 for (attr
= entry
->first_attr
;
4030 attr
&& attr
->attribute
;
4033 if (! do_loc
&& do_printing
)
4034 /* Show the offset from where the tag was extracted. */
4035 printf (" <%tx>", tags
- section_begin
);
4036 tags
= read_and_display_attr (attr
->attribute
,
4038 attr
->implicit_const
,
4043 compunit
.cu_pointer_size
,
4045 compunit
.cu_version
,
4047 do_loc
|| ! do_printing
,
4053 /* If a locview attribute appears before a location one,
4054 make sure we don't associate it with an earlier
4057 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
4060 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = -1;
4061 debug_info_p
->num_loc_views
++;
4062 assert (debug_info_p
->num_loc_views
4063 == debug_info_p
->num_loc_offsets
);
4070 warn(_("DIE has locviews without loclist\n"));
4071 debug_info_p
->num_loc_views
--;
4078 if (entry
->children
)
4082 free_abbrev_list (list
);
4085 /* Set num_debug_info_entries here so that it can be used to check if
4086 we need to process .debug_loc and .debug_ranges sections. */
4087 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
4088 && num_debug_info_entries
== 0
4091 if (num_units
> alloc_num_debug_info_entries
)
4092 num_debug_info_entries
= alloc_num_debug_info_entries
;
4094 num_debug_info_entries
= num_units
;
4103 /* Locate and scan the .debug_info section in the file and record the pointer
4104 sizes and offsets for the compilation units in it. Usually an executable
4105 will have just one pointer size, but this is not guaranteed, and so we try
4106 not to make any assumptions. Returns zero upon failure, or the number of
4107 compilation units upon success. */
4110 load_debug_info (void * file
)
4112 /* If we have already tried and failed to load the .debug_info
4113 section then do not bother to repeat the task. */
4114 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4117 /* If we already have the information there is nothing else to do. */
4118 if (num_debug_info_entries
> 0)
4119 return num_debug_info_entries
;
4121 /* If this is a DWARF package file, load the CU and TU indexes. */
4122 (void) load_cu_tu_indexes (file
);
4124 if (load_debug_section_with_follow (info
, file
)
4125 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4126 return num_debug_info_entries
;
4128 if (load_debug_section_with_follow (info_dwo
, file
)
4129 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4130 abbrev_dwo
, true, false))
4131 return num_debug_info_entries
;
4133 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4137 /* Read a DWARF .debug_line section header starting at DATA.
4138 Upon success returns an updated DATA pointer and the LINFO
4139 structure and the END_OF_SEQUENCE pointer will be filled in.
4140 Otherwise returns NULL. */
4142 static unsigned char *
4143 read_debug_line_header (struct dwarf_section
* section
,
4144 unsigned char * data
,
4145 unsigned char * end
,
4146 DWARF2_Internal_LineInfo
* linfo
,
4147 unsigned char ** end_of_sequence
)
4149 unsigned char *hdrptr
;
4151 /* Extract information from the Line Number Program Header.
4152 (section 6.2.4 in the Dwarf3 doc). */
4155 /* Get and check the length of the block. */
4156 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4158 if (linfo
->li_length
== 0xffffffff)
4160 /* This section is 64-bit DWARF 3. */
4161 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4162 linfo
->li_offset_size
= 8;
4165 linfo
->li_offset_size
= 4;
4167 if (linfo
->li_length
> (size_t) (end
- hdrptr
))
4169 /* If the length field has a relocation against it, then we should
4170 not complain if it is inaccurate (and probably negative). This
4171 happens in object files when the .debug_line section is actually
4172 comprised of several different .debug_line.* sections, (some of
4173 which may be removed by linker garbage collection), and a relocation
4174 is used to compute the correct length once that is done. */
4175 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4177 linfo
->li_length
= end
- hdrptr
;
4181 warn (_("The length field (%#" PRIx64
")"
4182 " in the debug_line header is wrong"
4183 " - the section is too small\n"),
4188 end
= hdrptr
+ linfo
->li_length
;
4190 /* Get and check the version number. */
4191 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4193 if (linfo
->li_version
!= 2
4194 && linfo
->li_version
!= 3
4195 && linfo
->li_version
!= 4
4196 && linfo
->li_version
!= 5)
4198 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4199 "is currently supported.\n"));
4203 if (linfo
->li_version
>= 5)
4205 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4207 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4208 if (linfo
->li_segment_size
!= 0)
4210 warn (_("The %s section contains "
4211 "unsupported segment selector size: %d.\n"),
4212 section
->name
, linfo
->li_segment_size
);
4217 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4218 linfo
->li_offset_size
, end
);
4219 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4221 if (linfo
->li_version
>= 4)
4223 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4225 if (linfo
->li_max_ops_per_insn
== 0)
4227 warn (_("Invalid maximum operations per insn.\n"));
4232 linfo
->li_max_ops_per_insn
= 1;
4234 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4235 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4236 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4237 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4239 *end_of_sequence
= end
;
4243 static unsigned char *
4244 display_formatted_table (unsigned char *data
,
4245 unsigned char *start
,
4247 const DWARF2_Internal_LineInfo
*linfo
,
4248 struct dwarf_section
*section
,
4251 unsigned char *format_start
, format_count
, *format
, formati
;
4252 uint64_t data_count
, datai
;
4253 unsigned int namepass
, last_entry
= 0;
4254 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4256 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4257 if (do_checks
&& format_count
> 5)
4258 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4259 table_name
, format_count
);
4261 format_start
= data
;
4262 for (formati
= 0; formati
< format_count
; formati
++)
4264 SKIP_ULEB (data
, end
);
4265 SKIP_ULEB (data
, end
);
4268 warn (_("%s: Corrupt format description entry\n"), table_name
);
4273 READ_ULEB (data_count
, data
, end
);
4274 if (data_count
== 0)
4276 printf (_("\n The %s is empty.\n"), table_name
);
4279 else if (data
>= end
)
4281 warn (_("%s: Corrupt entry count - expected %#" PRIx64
4282 " but none found\n"), table_name
, data_count
);
4286 else if (format_count
== 0)
4288 warn (_("%s: format count is zero, but the table is not empty\n"),
4293 printf (_("\n The %s (offset %#tx, lines %" PRIu64
", columns %u):\n"),
4294 table_name
, data
- start
, data_count
, format_count
);
4296 printf (_(" Entry"));
4297 /* Delay displaying name as the last entry for better screen layout. */
4298 for (namepass
= 0; namepass
< 2; namepass
++)
4300 format
= format_start
;
4301 for (formati
= 0; formati
< format_count
; formati
++)
4303 uint64_t content_type
;
4305 READ_ULEB (content_type
, format
, end
);
4306 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4307 switch (content_type
)
4310 printf (_("\tName"));
4312 case DW_LNCT_directory_index
:
4313 printf (_("\tDir"));
4315 case DW_LNCT_timestamp
:
4316 printf (_("\tTime"));
4319 printf (_("\tSize"));
4322 printf (_("\tMD5\t\t\t"));
4325 printf (_("\t(Unknown format content type %" PRIu64
")"),
4328 SKIP_ULEB (format
, end
);
4333 for (datai
= 0; datai
< data_count
; datai
++)
4335 unsigned char *datapass
= data
;
4337 printf (" %d", last_entry
++);
4338 /* Delay displaying name as the last entry for better screen layout. */
4339 for (namepass
= 0; namepass
< 2; namepass
++)
4341 format
= format_start
;
4343 for (formati
= 0; formati
< format_count
; formati
++)
4345 uint64_t content_type
, form
;
4347 READ_ULEB (content_type
, format
, end
);
4348 READ_ULEB (form
, format
, end
);
4349 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4350 0, 0, linfo
->li_offset_size
,
4351 linfo
->li_version
, NULL
,
4352 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4353 section
, NULL
, '\t', -1);
4357 if (data
>= end
&& (datai
< data_count
- 1))
4359 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4368 display_debug_sup (struct dwarf_section
* section
,
4369 void * file ATTRIBUTE_UNUSED
)
4371 unsigned char * start
= section
->start
;
4372 unsigned char * end
= section
->start
+ section
->size
;
4373 unsigned int version
;
4374 char is_supplementary
;
4375 const unsigned char * sup_filename
;
4376 size_t sup_filename_len
;
4377 unsigned int num_read
;
4379 uint64_t checksum_len
;
4382 introduce (section
, true);
4383 if (section
->size
< 4)
4385 error (_("corrupt .debug_sup section: size is too small\n"));
4389 /* Read the data. */
4390 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4392 warn (_("corrupt .debug_sup section: version < 5"));
4394 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4395 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4396 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4398 sup_filename
= start
;
4399 if (is_supplementary
&& sup_filename
[0] != 0)
4400 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4402 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4403 if (sup_filename_len
== (size_t) (end
- start
))
4405 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4408 start
+= sup_filename_len
+ 1;
4410 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4413 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4417 if (checksum_len
> (size_t) (end
- start
))
4419 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4420 checksum_len
= end
- start
;
4422 else if (checksum_len
< (size_t) (end
- start
))
4424 warn (_("corrupt .debug_sup section: there are %#" PRIx64
4425 " extra, unused bytes at the end of the section\n"),
4426 (end
- start
) - checksum_len
);
4429 printf (_(" Version: %u\n"), version
);
4430 printf (_(" Is Supp: %u\n"), is_supplementary
);
4431 printf (_(" Filename: %s\n"), sup_filename
);
4432 printf (_(" Checksum Len: %" PRIu64
"\n"), checksum_len
);
4433 if (checksum_len
> 0)
4435 printf (_(" Checksum: "));
4436 while (checksum_len
--)
4437 printf ("0x%x ", * start
++ );
4444 display_debug_lines_raw (struct dwarf_section
* section
,
4445 unsigned char * data
,
4446 unsigned char * end
,
4449 unsigned char *start
= section
->start
;
4450 int verbose_view
= 0;
4452 introduce (section
, true);
4456 static DWARF2_Internal_LineInfo saved_linfo
;
4457 DWARF2_Internal_LineInfo linfo
;
4458 unsigned char *standard_opcodes
;
4459 unsigned char *end_of_sequence
;
4462 if (startswith (section
->name
, ".debug_line.")
4463 /* Note: the following does not apply to .debug_line.dwo sections.
4464 These are full debug_line sections. */
4465 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4467 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4468 section containing just the Line Number Statements. They are
4469 created by the assembler and intended to be used alongside gcc's
4470 -ffunction-sections command line option. When the linker's
4471 garbage collection decides to discard a .text.<foo> section it
4472 can then also discard the line number information in .debug_line.<foo>.
4474 Since the section is a fragment it does not have the details
4475 needed to fill out a LineInfo structure, so instead we use the
4476 details from the last full debug_line section that we processed. */
4477 end_of_sequence
= end
;
4478 standard_opcodes
= NULL
;
4479 linfo
= saved_linfo
;
4480 /* PR 17531: file: 0522b371. */
4481 if (linfo
.li_line_range
== 0)
4483 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4486 reset_state_machine (linfo
.li_default_is_stmt
);
4490 unsigned char * hdrptr
;
4492 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4493 & end_of_sequence
)) == NULL
)
4496 printf (_(" Offset: %#tx\n"), data
- start
);
4497 printf (_(" Length: %" PRId64
"\n"), linfo
.li_length
);
4498 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4499 if (linfo
.li_version
>= 5)
4501 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4502 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4504 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4505 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4506 if (linfo
.li_version
>= 4)
4507 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4508 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4509 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4510 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4511 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4513 /* PR 17512: file: 1665-6428-0.004. */
4514 if (linfo
.li_line_range
== 0)
4516 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4517 linfo
.li_line_range
= 1;
4520 reset_state_machine (linfo
.li_default_is_stmt
);
4522 /* Display the contents of the Opcodes table. */
4523 standard_opcodes
= hdrptr
;
4525 /* PR 17512: file: 002-417945-0.004. */
4526 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4528 warn (_("Line Base extends beyond end of section\n"));
4532 printf (_("\n Opcodes:\n"));
4534 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4535 printf (ngettext (" Opcode %d has %d arg\n",
4536 " Opcode %d has %d args\n",
4537 standard_opcodes
[i
- 1]),
4538 i
, standard_opcodes
[i
- 1]);
4540 /* Display the contents of the Directory table. */
4541 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4543 if (linfo
.li_version
>= 5)
4545 load_debug_section_with_follow (line_str
, file
);
4547 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4549 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4555 printf (_("\n The Directory Table is empty.\n"));
4558 unsigned int last_dir_entry
= 0;
4560 printf (_("\n The Directory Table (offset %#tx):\n"),
4563 while (data
< end
&& *data
!= 0)
4565 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4567 data
+= strnlen ((char *) data
, end
- data
);
4572 /* PR 17512: file: 002-132094-0.004. */
4573 if (data
>= end
- 1)
4577 /* Skip the NUL at the end of the table. */
4581 /* Display the contents of the File Name table. */
4582 if (data
>= end
|| *data
== 0)
4583 printf (_("\n The File Name Table is empty.\n"));
4586 printf (_("\n The File Name Table (offset %#tx):\n"),
4588 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4590 while (data
< end
&& *data
!= 0)
4592 unsigned char *name
;
4595 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4597 data
+= strnlen ((char *) data
, end
- data
);
4601 READ_ULEB (val
, data
, end
);
4602 printf ("%" PRIu64
"\t", val
);
4603 READ_ULEB (val
, data
, end
);
4604 printf ("%" PRIu64
"\t", val
);
4605 READ_ULEB (val
, data
, end
);
4606 printf ("%" PRIu64
"\t", val
);
4607 printf ("%.*s\n", (int)(end
- name
), name
);
4611 warn (_("Corrupt file name table entry\n"));
4617 /* Skip the NUL at the end of the table. */
4623 saved_linfo
= linfo
;
4626 /* Now display the statements. */
4627 if (data
>= end_of_sequence
)
4628 printf (_(" No Line Number Statements.\n"));
4631 printf (_(" Line Number Statements:\n"));
4633 while (data
< end_of_sequence
)
4635 unsigned char op_code
;
4639 printf (" [0x%08tx]", data
- start
);
4643 if (op_code
>= linfo
.li_opcode_base
)
4645 op_code
-= linfo
.li_opcode_base
;
4646 uladv
= (op_code
/ linfo
.li_line_range
);
4647 if (linfo
.li_max_ops_per_insn
== 1)
4649 uladv
*= linfo
.li_min_insn_length
;
4650 state_machine_regs
.address
+= uladv
;
4652 state_machine_regs
.view
= 0;
4653 printf (_(" Special opcode %d: "
4654 "advance Address by %" PRIu64
4655 " to %#" PRIx64
"%s"),
4656 op_code
, uladv
, state_machine_regs
.address
,
4657 verbose_view
&& uladv
4658 ? _(" (reset view)") : "");
4663 = ((state_machine_regs
.op_index
+ uladv
)
4664 / linfo
.li_max_ops_per_insn
)
4665 * linfo
.li_min_insn_length
;
4667 state_machine_regs
.address
+= addrdelta
;
4668 state_machine_regs
.op_index
4669 = (state_machine_regs
.op_index
+ uladv
)
4670 % linfo
.li_max_ops_per_insn
;
4672 state_machine_regs
.view
= 0;
4673 printf (_(" Special opcode %d: "
4674 "advance Address by %" PRIu64
4675 " to %#" PRIx64
"[%d]%s"),
4676 op_code
, uladv
, state_machine_regs
.address
,
4677 state_machine_regs
.op_index
,
4678 verbose_view
&& addrdelta
4679 ? _(" (reset view)") : "");
4681 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4682 state_machine_regs
.line
+= adv
;
4683 printf (_(" and Line by %" PRId64
" to %d"),
4684 adv
, state_machine_regs
.line
);
4685 if (verbose_view
|| state_machine_regs
.view
)
4686 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4689 state_machine_regs
.view
++;
4694 case DW_LNS_extended_op
:
4695 data
+= process_extended_line_op (data
,
4696 linfo
.li_default_is_stmt
,
4701 printf (_(" Copy"));
4702 if (verbose_view
|| state_machine_regs
.view
)
4703 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4706 state_machine_regs
.view
++;
4709 case DW_LNS_advance_pc
:
4710 READ_ULEB (uladv
, data
, end
);
4711 if (linfo
.li_max_ops_per_insn
== 1)
4713 uladv
*= linfo
.li_min_insn_length
;
4714 state_machine_regs
.address
+= uladv
;
4716 state_machine_regs
.view
= 0;
4717 printf (_(" Advance PC by %" PRIu64
4718 " to %#" PRIx64
"%s\n"),
4719 uladv
, state_machine_regs
.address
,
4720 verbose_view
&& uladv
4721 ? _(" (reset view)") : "");
4726 = ((state_machine_regs
.op_index
+ uladv
)
4727 / linfo
.li_max_ops_per_insn
)
4728 * linfo
.li_min_insn_length
;
4729 state_machine_regs
.address
4731 state_machine_regs
.op_index
4732 = (state_machine_regs
.op_index
+ uladv
)
4733 % linfo
.li_max_ops_per_insn
;
4735 state_machine_regs
.view
= 0;
4736 printf (_(" Advance PC by %" PRIu64
4737 " to %#" PRIx64
"[%d]%s\n"),
4738 uladv
, state_machine_regs
.address
,
4739 state_machine_regs
.op_index
,
4740 verbose_view
&& addrdelta
4741 ? _(" (reset view)") : "");
4745 case DW_LNS_advance_line
:
4746 READ_SLEB (adv
, data
, end
);
4747 state_machine_regs
.line
+= adv
;
4748 printf (_(" Advance Line by %" PRId64
" to %d\n"),
4749 adv
, state_machine_regs
.line
);
4752 case DW_LNS_set_file
:
4753 READ_ULEB (uladv
, data
, end
);
4754 printf (_(" Set File Name to entry %" PRIu64
4755 " in the File Name Table\n"), uladv
);
4756 state_machine_regs
.file
= uladv
;
4759 case DW_LNS_set_column
:
4760 READ_ULEB (uladv
, data
, end
);
4761 printf (_(" Set column to %" PRIu64
"\n"), uladv
);
4762 state_machine_regs
.column
= uladv
;
4765 case DW_LNS_negate_stmt
:
4766 adv
= state_machine_regs
.is_stmt
;
4768 printf (_(" Set is_stmt to %" PRId64
"\n"), adv
);
4769 state_machine_regs
.is_stmt
= adv
;
4772 case DW_LNS_set_basic_block
:
4773 printf (_(" Set basic block\n"));
4774 state_machine_regs
.basic_block
= 1;
4777 case DW_LNS_const_add_pc
:
4778 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4779 if (linfo
.li_max_ops_per_insn
)
4781 uladv
*= linfo
.li_min_insn_length
;
4782 state_machine_regs
.address
+= uladv
;
4784 state_machine_regs
.view
= 0;
4785 printf (_(" Advance PC by constant %" PRIu64
4786 " to %#" PRIx64
"%s\n"),
4787 uladv
, state_machine_regs
.address
,
4788 verbose_view
&& uladv
4789 ? _(" (reset view)") : "");
4794 = ((state_machine_regs
.op_index
+ uladv
)
4795 / linfo
.li_max_ops_per_insn
)
4796 * linfo
.li_min_insn_length
;
4797 state_machine_regs
.address
4799 state_machine_regs
.op_index
4800 = (state_machine_regs
.op_index
+ uladv
)
4801 % linfo
.li_max_ops_per_insn
;
4803 state_machine_regs
.view
= 0;
4804 printf (_(" Advance PC by constant %" PRIu64
4805 " to %#" PRIx64
"[%d]%s\n"),
4806 uladv
, state_machine_regs
.address
,
4807 state_machine_regs
.op_index
,
4808 verbose_view
&& addrdelta
4809 ? _(" (reset view)") : "");
4813 case DW_LNS_fixed_advance_pc
:
4814 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4815 state_machine_regs
.address
+= uladv
;
4816 state_machine_regs
.op_index
= 0;
4817 printf (_(" Advance PC by fixed size amount %" PRIu64
4818 " to %#" PRIx64
"\n"),
4819 uladv
, state_machine_regs
.address
);
4820 /* Do NOT reset view. */
4823 case DW_LNS_set_prologue_end
:
4824 printf (_(" Set prologue_end to true\n"));
4827 case DW_LNS_set_epilogue_begin
:
4828 printf (_(" Set epilogue_begin to true\n"));
4831 case DW_LNS_set_isa
:
4832 READ_ULEB (uladv
, data
, end
);
4833 printf (_(" Set ISA to %" PRIu64
"\n"), uladv
);
4837 printf (_(" Unknown opcode %d with operands: "), op_code
);
4839 if (standard_opcodes
!= NULL
)
4840 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4842 READ_ULEB (uladv
, data
, end
);
4843 printf ("%#" PRIx64
"%s", uladv
, i
== 1 ? "" : ", ");
4858 unsigned char *name
;
4859 unsigned int directory_index
;
4860 unsigned int modification_date
;
4861 unsigned int length
;
4864 /* Output a decoded representation of the .debug_line section. */
4867 display_debug_lines_decoded (struct dwarf_section
* section
,
4868 unsigned char * start
,
4869 unsigned char * data
,
4870 unsigned char * end
,
4873 static DWARF2_Internal_LineInfo saved_linfo
;
4875 introduce (section
, false);
4879 /* This loop amounts to one iteration per compilation unit. */
4880 DWARF2_Internal_LineInfo linfo
;
4881 unsigned char *standard_opcodes
;
4882 unsigned char *end_of_sequence
;
4884 File_Entry
*file_table
= NULL
;
4885 unsigned int n_files
= 0;
4886 unsigned char **directory_table
= NULL
;
4887 uint64_t n_directories
= 0;
4889 if (startswith (section
->name
, ".debug_line.")
4890 /* Note: the following does not apply to .debug_line.dwo sections.
4891 These are full debug_line sections. */
4892 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4894 /* See comment in display_debug_lines_raw(). */
4895 end_of_sequence
= end
;
4896 standard_opcodes
= NULL
;
4897 linfo
= saved_linfo
;
4898 /* PR 17531: file: 0522b371. */
4899 if (linfo
.li_line_range
== 0)
4901 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4904 reset_state_machine (linfo
.li_default_is_stmt
);
4908 unsigned char *hdrptr
;
4910 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4911 & end_of_sequence
)) == NULL
)
4914 /* PR 17531: file: 0522b371. */
4915 if (linfo
.li_line_range
== 0)
4917 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4918 linfo
.li_line_range
= 1;
4920 reset_state_machine (linfo
.li_default_is_stmt
);
4922 /* Save a pointer to the contents of the Opcodes table. */
4923 standard_opcodes
= hdrptr
;
4925 /* Traverse the Directory table just to count entries. */
4926 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4930 warn (_("opcode base of %d extends beyond end of section\n"),
4931 linfo
.li_opcode_base
);
4935 if (linfo
.li_version
>= 5)
4937 unsigned char *format_start
, format_count
, *format
;
4938 uint64_t formati
, entryi
;
4940 load_debug_section_with_follow (line_str
, fileptr
);
4942 /* Skip directories format. */
4943 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4944 if (do_checks
&& format_count
> 1)
4945 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4947 format_start
= data
;
4948 for (formati
= 0; formati
< format_count
; formati
++)
4950 SKIP_ULEB (data
, end
);
4951 SKIP_ULEB (data
, end
);
4954 READ_ULEB (n_directories
, data
, end
);
4957 warn (_("Corrupt directories list\n"));
4961 if (n_directories
== 0)
4962 directory_table
= NULL
;
4964 directory_table
= (unsigned char **)
4965 xmalloc (n_directories
* sizeof (unsigned char *));
4967 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4969 unsigned char **pathp
= &directory_table
[entryi
];
4971 format
= format_start
;
4972 for (formati
= 0; formati
< format_count
; formati
++)
4974 uint64_t content_type
, form
;
4977 READ_ULEB (content_type
, format
, end
);
4978 READ_ULEB (form
, format
, end
);
4981 warn (_("Corrupt directories list\n"));
4984 switch (content_type
)
4989 case DW_FORM_string
:
4992 case DW_FORM_line_strp
:
4993 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4995 /* Remove const by the cast. */
4996 *pathp
= (unsigned char *)
4997 fetch_indirect_line_string (uvalue
);
5002 data
= read_and_display_attr_value (0, form
, 0, start
,
5004 linfo
.li_offset_size
,
5011 warn (_("Corrupt directories list\n"));
5016 /* Skip files format. */
5017 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
5018 if (do_checks
&& format_count
> 5)
5019 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
5021 format_start
= data
;
5022 for (formati
= 0; formati
< format_count
; formati
++)
5024 SKIP_ULEB (data
, end
);
5025 SKIP_ULEB (data
, end
);
5028 READ_ULEB (n_files
, data
, end
);
5029 if (data
>= end
&& n_files
> 0)
5031 warn (_("Corrupt file name list\n"));
5038 file_table
= (File_Entry
*) xcalloc (1, n_files
5039 * sizeof (File_Entry
));
5041 for (entryi
= 0; entryi
< n_files
; entryi
++)
5043 File_Entry
*file
= &file_table
[entryi
];
5045 format
= format_start
;
5046 for (formati
= 0; formati
< format_count
; formati
++)
5048 uint64_t content_type
, form
;
5052 READ_ULEB (content_type
, format
, end
);
5053 READ_ULEB (form
, format
, end
);
5056 warn (_("Corrupt file name list\n"));
5059 switch (content_type
)
5064 case DW_FORM_string
:
5067 case DW_FORM_line_strp
:
5068 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
5070 /* Remove const by the cast. */
5071 file
->name
= (unsigned char *)
5072 fetch_indirect_line_string (uvalue
);
5076 case DW_LNCT_directory_index
:
5080 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5084 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5089 READ_ULEB (file
->directory_index
, tmp
, end
);
5094 data
= read_and_display_attr_value (0, form
, 0, start
,
5096 linfo
.li_offset_size
,
5103 warn (_("Corrupt file name list\n"));
5112 unsigned char *ptr_directory_table
= data
;
5114 while (data
< end
&& *data
!= 0)
5116 data
+= strnlen ((char *) data
, end
- data
);
5125 warn (_("directory table ends unexpectedly\n"));
5130 /* Go through the directory table again to save the directories. */
5131 directory_table
= (unsigned char **)
5132 xmalloc (n_directories
* sizeof (unsigned char *));
5135 while (*ptr_directory_table
!= 0)
5137 directory_table
[i
] = ptr_directory_table
;
5139 += strlen ((char *) ptr_directory_table
) + 1;
5143 /* Skip the NUL at the end of the table. */
5146 /* Traverse the File Name table just to count the entries. */
5147 if (data
< end
&& *data
!= 0)
5149 unsigned char *ptr_file_name_table
= data
;
5151 while (data
< end
&& *data
!= 0)
5153 /* Skip Name, directory index, last modification
5154 time and length of file. */
5155 data
+= strnlen ((char *) data
, end
- data
);
5158 SKIP_ULEB (data
, end
);
5159 SKIP_ULEB (data
, end
);
5160 SKIP_ULEB (data
, end
);
5166 warn (_("file table ends unexpectedly\n"));
5171 /* Go through the file table again to save the strings. */
5172 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5175 while (*ptr_file_name_table
!= 0)
5177 file_table
[i
].name
= ptr_file_name_table
;
5179 += strlen ((char *) ptr_file_name_table
) + 1;
5181 /* We are not interested in directory, time or size. */
5182 READ_ULEB (file_table
[i
].directory_index
,
5183 ptr_file_name_table
, end
);
5184 READ_ULEB (file_table
[i
].modification_date
,
5185 ptr_file_name_table
, end
);
5186 READ_ULEB (file_table
[i
].length
,
5187 ptr_file_name_table
, end
);
5193 /* Skip the NUL at the end of the table. */
5197 /* Print the Compilation Unit's name and a header. */
5198 if (file_table
== NULL
)
5199 printf (_("CU: No directory table\n"));
5200 else if (directory_table
== NULL
)
5201 printf (_("CU: %s:\n"), file_table
[0].name
);
5204 unsigned int ix
= file_table
[0].directory_index
;
5205 const char *directory
;
5210 else if (n_directories
== 0)
5211 directory
= _("<unknown>");
5212 else if (ix
> n_directories
)
5214 warn (_("directory index %u > number of directories %" PRIu64
"\n"),
5216 directory
= _("<corrupt>");
5219 directory
= (char *) directory_table
[ix
- 1];
5222 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5224 printf ("%s:\n", file_table
[0].name
);
5228 printf (_("File name Line number Starting address View Stmt\n"));
5230 printf (_("CU: Empty file name table\n"));
5231 saved_linfo
= linfo
;
5234 /* This loop iterates through the Dwarf Line Number Program. */
5235 while (data
< end_of_sequence
)
5237 unsigned char op_code
;
5240 unsigned long int uladv
;
5241 int is_special_opcode
= 0;
5246 if (op_code
>= linfo
.li_opcode_base
)
5248 op_code
-= linfo
.li_opcode_base
;
5249 uladv
= (op_code
/ linfo
.li_line_range
);
5250 if (linfo
.li_max_ops_per_insn
== 1)
5252 uladv
*= linfo
.li_min_insn_length
;
5253 state_machine_regs
.address
+= uladv
;
5255 state_machine_regs
.view
= 0;
5260 = ((state_machine_regs
.op_index
+ uladv
)
5261 / linfo
.li_max_ops_per_insn
)
5262 * linfo
.li_min_insn_length
;
5263 state_machine_regs
.address
5265 state_machine_regs
.op_index
5266 = (state_machine_regs
.op_index
+ uladv
)
5267 % linfo
.li_max_ops_per_insn
;
5269 state_machine_regs
.view
= 0;
5272 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5273 state_machine_regs
.line
+= adv
;
5274 is_special_opcode
= 1;
5275 /* Increment view after printing this row. */
5280 case DW_LNS_extended_op
:
5282 unsigned int ext_op_code_len
;
5283 unsigned char ext_op_code
;
5284 unsigned char *op_code_end
;
5285 unsigned char *op_code_data
= data
;
5287 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5288 op_code_end
= op_code_data
+ ext_op_code_len
;
5289 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5291 warn (_("Badly formed extended line op encountered!\n"));
5294 ext_op_code
= *op_code_data
++;
5298 switch (ext_op_code
)
5300 case DW_LNE_end_sequence
:
5301 /* Reset stuff after printing this row. */
5303 case DW_LNE_set_address
:
5304 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5306 op_code_end
- op_code_data
,
5308 state_machine_regs
.op_index
= 0;
5309 state_machine_regs
.view
= 0;
5311 case DW_LNE_define_file
:
5312 file_table
= (File_Entry
*) xrealloc
5313 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5315 ++state_machine_regs
.last_file_entry
;
5316 /* Source file name. */
5317 file_table
[n_files
].name
= op_code_data
;
5318 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5319 /* Directory index. */
5320 READ_ULEB (file_table
[n_files
].directory_index
,
5321 op_code_data
, op_code_end
);
5322 /* Last modification time. */
5323 READ_ULEB (file_table
[n_files
].modification_date
,
5324 op_code_data
, op_code_end
);
5326 READ_ULEB (file_table
[n_files
].length
,
5327 op_code_data
, op_code_end
);
5331 case DW_LNE_set_discriminator
:
5332 case DW_LNE_HP_set_sequence
:
5333 /* Simply ignored. */
5337 printf (_("UNKNOWN (%u): length %ld\n"),
5338 ext_op_code
, (long int) (op_code_data
- data
));
5345 /* Increment view after printing this row. */
5348 case DW_LNS_advance_pc
:
5349 READ_ULEB (uladv
, data
, end
);
5350 if (linfo
.li_max_ops_per_insn
== 1)
5352 uladv
*= linfo
.li_min_insn_length
;
5353 state_machine_regs
.address
+= uladv
;
5355 state_machine_regs
.view
= 0;
5360 = ((state_machine_regs
.op_index
+ uladv
)
5361 / linfo
.li_max_ops_per_insn
)
5362 * linfo
.li_min_insn_length
;
5363 state_machine_regs
.address
5365 state_machine_regs
.op_index
5366 = (state_machine_regs
.op_index
+ uladv
)
5367 % linfo
.li_max_ops_per_insn
;
5369 state_machine_regs
.view
= 0;
5373 case DW_LNS_advance_line
:
5374 READ_SLEB (adv
, data
, end
);
5375 state_machine_regs
.line
+= adv
;
5378 case DW_LNS_set_file
:
5379 READ_ULEB (uladv
, data
, end
);
5380 state_machine_regs
.file
= uladv
;
5383 unsigned file
= state_machine_regs
.file
;
5386 if (linfo
.li_version
< 5)
5388 if (file_table
== NULL
|| n_files
== 0)
5389 printf (_("\n [Use file table entry %d]\n"), file
);
5391 else if (file
>= n_files
)
5393 warn (_("file index %u > number of files %u\n"), file
, n_files
);
5394 printf (_("\n <over large file table index %u>"), file
);
5396 else if ((dir
= file_table
[file
].directory_index
) == 0)
5397 /* If directory index is 0, that means current directory. */
5398 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5399 else if (directory_table
== NULL
|| n_directories
== 0)
5400 printf (_("\n [Use file %s in directory table entry %d]\n"),
5401 file_table
[file
].name
, dir
);
5403 else if (dir
> n_directories
)
5405 warn (_("directory index %u > number of directories %" PRIu64
"\n"),
5406 dir
, n_directories
);
5407 printf (_("\n <over large directory table entry %u>\n"), dir
);
5410 printf ("\n%s/%s:\n",
5411 /* The directory index starts counting at 1. */
5412 directory_table
[dir
- 1], file_table
[file
].name
);
5416 case DW_LNS_set_column
:
5417 READ_ULEB (uladv
, data
, end
);
5418 state_machine_regs
.column
= uladv
;
5421 case DW_LNS_negate_stmt
:
5422 adv
= state_machine_regs
.is_stmt
;
5424 state_machine_regs
.is_stmt
= adv
;
5427 case DW_LNS_set_basic_block
:
5428 state_machine_regs
.basic_block
= 1;
5431 case DW_LNS_const_add_pc
:
5432 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5433 if (linfo
.li_max_ops_per_insn
== 1)
5435 uladv
*= linfo
.li_min_insn_length
;
5436 state_machine_regs
.address
+= uladv
;
5438 state_machine_regs
.view
= 0;
5443 = ((state_machine_regs
.op_index
+ uladv
)
5444 / linfo
.li_max_ops_per_insn
)
5445 * linfo
.li_min_insn_length
;
5446 state_machine_regs
.address
5448 state_machine_regs
.op_index
5449 = (state_machine_regs
.op_index
+ uladv
)
5450 % linfo
.li_max_ops_per_insn
;
5452 state_machine_regs
.view
= 0;
5456 case DW_LNS_fixed_advance_pc
:
5457 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5458 state_machine_regs
.address
+= uladv
;
5459 state_machine_regs
.op_index
= 0;
5460 /* Do NOT reset view. */
5463 case DW_LNS_set_prologue_end
:
5466 case DW_LNS_set_epilogue_begin
:
5469 case DW_LNS_set_isa
:
5470 READ_ULEB (uladv
, data
, end
);
5471 printf (_(" Set ISA to %lu\n"), uladv
);
5475 printf (_(" Unknown opcode %d with operands: "), op_code
);
5477 if (standard_opcodes
!= NULL
)
5478 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5482 READ_ULEB (val
, data
, end
);
5483 printf ("%#" PRIx64
"%s", val
, i
== 1 ? "" : ", ");
5489 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5490 to the DWARF address/line matrix. */
5491 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5492 || (xop
== DW_LNS_copy
))
5494 const unsigned int MAX_FILENAME_LENGTH
= 35;
5496 char *newFileName
= NULL
;
5497 size_t fileNameLength
;
5501 unsigned indx
= state_machine_regs
.file
;
5503 if (linfo
.li_version
< 5)
5506 if (indx
>= n_files
)
5508 warn (_("corrupt file index %u encountered\n"), indx
);
5509 fileName
= _("<corrupt>");
5512 fileName
= (char *) file_table
[indx
].name
;
5515 fileName
= _("<unknown>");
5517 fileNameLength
= strlen (fileName
);
5518 newFileName
= fileName
;
5519 if (fileNameLength
> MAX_FILENAME_LENGTH
&& !do_wide
)
5521 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5522 /* Truncate file name */
5523 memcpy (newFileName
,
5524 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5525 MAX_FILENAME_LENGTH
);
5526 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5529 /* A row with end_seq set to true has a meaningful address, but
5530 the other information in the same row is not significant.
5531 In such a row, print line as "-", and don't print
5533 if (!do_wide
|| fileNameLength
<= MAX_FILENAME_LENGTH
)
5535 if (linfo
.li_max_ops_per_insn
== 1)
5537 if (xop
== -DW_LNE_end_sequence
)
5538 printf ("%-35s %11s %#18" PRIx64
,
5540 state_machine_regs
.address
);
5542 printf ("%-35s %11d %#18" PRIx64
,
5543 newFileName
, state_machine_regs
.line
,
5544 state_machine_regs
.address
);
5548 if (xop
== -DW_LNE_end_sequence
)
5549 printf ("%-35s %11s %#18" PRIx64
"[%d]",
5551 state_machine_regs
.address
,
5552 state_machine_regs
.op_index
);
5554 printf ("%-35s %11d %#18" PRIx64
"[%d]",
5555 newFileName
, state_machine_regs
.line
,
5556 state_machine_regs
.address
,
5557 state_machine_regs
.op_index
);
5562 if (linfo
.li_max_ops_per_insn
== 1)
5564 if (xop
== -DW_LNE_end_sequence
)
5565 printf ("%s %11s %#18" PRIx64
,
5567 state_machine_regs
.address
);
5569 printf ("%s %11d %#18" PRIx64
,
5570 newFileName
, state_machine_regs
.line
,
5571 state_machine_regs
.address
);
5575 if (xop
== -DW_LNE_end_sequence
)
5576 printf ("%s %11s %#18" PRIx64
"[%d]",
5578 state_machine_regs
.address
,
5579 state_machine_regs
.op_index
);
5581 printf ("%s %11d %#18" PRIx64
"[%d]",
5582 newFileName
, state_machine_regs
.line
,
5583 state_machine_regs
.address
,
5584 state_machine_regs
.op_index
);
5588 if (xop
!= -DW_LNE_end_sequence
)
5590 if (state_machine_regs
.view
)
5591 printf (" %6u", state_machine_regs
.view
);
5595 if (state_machine_regs
.is_stmt
)
5600 state_machine_regs
.view
++;
5602 if (xop
== -DW_LNE_end_sequence
)
5604 reset_state_machine (linfo
.li_default_is_stmt
);
5608 if (newFileName
!= fileName
)
5620 if (directory_table
)
5622 free (directory_table
);
5623 directory_table
= NULL
;
5634 display_debug_lines (struct dwarf_section
*section
, void *file
)
5636 unsigned char *data
= section
->start
;
5637 unsigned char *end
= data
+ section
->size
;
5639 int retValDecoded
= 1;
5641 if (do_debug_lines
== 0)
5642 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5644 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5645 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5647 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5648 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5650 if (!retValRaw
|| !retValDecoded
)
5657 find_debug_info_for_offset (uint64_t offset
)
5661 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5664 for (i
= 0; i
< num_debug_info_entries
; i
++)
5665 if (debug_information
[i
].cu_offset
== offset
)
5666 return debug_information
+ i
;
5672 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5674 /* See gdb/gdb-index.h. */
5675 static const char * const kinds
[] =
5687 return _ (kinds
[kind
]);
5691 display_debug_pubnames_worker (struct dwarf_section
*section
,
5692 void *file ATTRIBUTE_UNUSED
,
5695 DWARF2_Internal_PubNames names
;
5696 unsigned char *start
= section
->start
;
5697 unsigned char *end
= start
+ section
->size
;
5699 /* It does not matter if this load fails,
5700 we test for that later on. */
5701 load_debug_info (file
);
5703 introduce (section
, false);
5707 unsigned char *data
;
5708 unsigned long sec_off
= start
- section
->start
;
5709 unsigned int offset_size
;
5711 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5712 if (names
.pn_length
== 0xffffffff)
5714 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5720 if (names
.pn_length
> (size_t) (end
- start
))
5722 warn (_("Debug info is corrupted, "
5723 "%s header at %#lx has length %#" PRIx64
"\n"),
5724 section
->name
, sec_off
, names
.pn_length
);
5729 start
+= names
.pn_length
;
5731 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
5732 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
5734 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5735 && num_debug_info_entries
> 0
5736 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5737 warn (_(".debug_info offset of %#" PRIx64
5738 " in %s section does not point to a CU header.\n"),
5739 names
.pn_offset
, section
->name
);
5741 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
5743 printf (_(" Length: %" PRId64
"\n"),
5745 printf (_(" Version: %d\n"),
5747 printf (_(" Offset into .debug_info section: %#" PRIx64
"\n"),
5749 printf (_(" Size of area in .debug_info section: %" PRId64
"\n"),
5752 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5754 static int warned
= 0;
5758 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5766 printf (_("\n Offset Kind Name\n"));
5768 printf (_("\n Offset\tName\n"));
5775 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
5782 maxprint
= (start
- data
) - 1;
5786 unsigned int kind_data
;
5787 gdb_index_symbol_kind kind
;
5788 const char *kind_name
;
5791 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
5793 /* GCC computes the kind as the upper byte in the CU index
5794 word, and then right shifts it by the CU index size.
5795 Left shift KIND to where the gdb-index.h accessor macros
5797 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5798 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5799 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5800 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5801 printf (" %-6" PRIx64
" %s,%-10s %.*s\n",
5802 offset
, is_static
? _("s") : _("g"),
5803 kind_name
, (int) maxprint
, data
);
5806 printf (" %-6" PRIx64
"\t%.*s\n",
5807 offset
, (int) maxprint
, data
);
5809 data
+= strnlen ((char *) data
, maxprint
);
5822 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5824 return display_debug_pubnames_worker (section
, file
, 0);
5828 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5830 return display_debug_pubnames_worker (section
, file
, 1);
5834 display_debug_macinfo (struct dwarf_section
*section
,
5835 void *file ATTRIBUTE_UNUSED
)
5837 unsigned char *start
= section
->start
;
5838 unsigned char *end
= start
+ section
->size
;
5839 unsigned char *curr
= start
;
5840 enum dwarf_macinfo_record_type op
;
5842 introduce (section
, false);
5846 unsigned int lineno
;
5847 const unsigned char *string
;
5849 op
= (enum dwarf_macinfo_record_type
) *curr
;
5854 case DW_MACINFO_start_file
:
5856 unsigned int filenum
;
5858 READ_ULEB (lineno
, curr
, end
);
5859 READ_ULEB (filenum
, curr
, end
);
5860 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5865 case DW_MACINFO_end_file
:
5866 printf (_(" DW_MACINFO_end_file\n"));
5869 case DW_MACINFO_define
:
5870 READ_ULEB (lineno
, curr
, end
);
5872 curr
+= strnlen ((char *) string
, end
- string
);
5873 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
5874 lineno
, (int) (curr
- string
), string
);
5879 case DW_MACINFO_undef
:
5880 READ_ULEB (lineno
, curr
, end
);
5882 curr
+= strnlen ((char *) string
, end
- string
);
5883 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
5884 lineno
, (int) (curr
- string
), string
);
5889 case DW_MACINFO_vendor_ext
:
5891 unsigned int constant
;
5893 READ_ULEB (constant
, curr
, end
);
5895 curr
+= strnlen ((char *) string
, end
- string
);
5896 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
5897 constant
, (int) (curr
- string
), string
);
5908 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5909 filename and dirname corresponding to file name table entry with index
5910 FILEIDX. Return NULL on failure. */
5912 static unsigned char *
5913 get_line_filename_and_dirname (uint64_t line_offset
,
5915 unsigned char **dir_name
)
5917 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5918 unsigned char *hdrptr
, *dirtable
, *file_name
;
5919 unsigned int offset_size
;
5920 unsigned int version
, opcode_base
;
5921 uint64_t length
, diridx
;
5922 const unsigned char * end
;
5925 if (section
->start
== NULL
5926 || line_offset
>= section
->size
5930 hdrptr
= section
->start
+ line_offset
;
5931 end
= section
->start
+ section
->size
;
5933 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5934 if (length
== 0xffffffff)
5936 /* This section is 64-bit DWARF 3. */
5937 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5943 if (length
> (size_t) (end
- hdrptr
)
5944 || length
< 2 + offset_size
+ 1 + 3 + 1)
5946 end
= hdrptr
+ length
;
5948 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5949 if (version
!= 2 && version
!= 3 && version
!= 4)
5951 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5953 hdrptr
++; /* Skip max_ops_per_insn. */
5954 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5956 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5957 if (opcode_base
== 0
5958 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
5961 hdrptr
+= opcode_base
- 1;
5964 /* Skip over dirname table. */
5965 while (*hdrptr
!= '\0')
5967 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5973 hdrptr
++; /* Skip the NUL at the end of the table. */
5975 /* Now skip over preceding filename table entries. */
5976 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5978 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5981 SKIP_ULEB (hdrptr
, end
);
5982 SKIP_ULEB (hdrptr
, end
);
5983 SKIP_ULEB (hdrptr
, end
);
5985 if (hdrptr
>= end
|| *hdrptr
== '\0')
5989 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5994 READ_ULEB (diridx
, hdrptr
, end
);
5997 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5999 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
6003 if (dirtable
>= end
|| *dirtable
== '\0')
6005 *dir_name
= dirtable
;
6010 display_debug_macro (struct dwarf_section
*section
,
6013 unsigned char *start
= section
->start
;
6014 unsigned char *end
= start
+ section
->size
;
6015 unsigned char *curr
= start
;
6016 unsigned char *extended_op_buf
[256];
6017 bool is_dwo
= false;
6018 const char *suffix
= strrchr (section
->name
, '.');
6020 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6023 load_debug_section_with_follow (str
, file
);
6024 load_debug_section_with_follow (line
, file
);
6025 load_debug_section_with_follow (str_index
, file
);
6027 introduce (section
, false);
6031 unsigned int lineno
, version
, flags
;
6032 unsigned int offset_size
;
6033 const unsigned char *string
;
6034 uint64_t line_offset
= 0, sec_offset
= curr
- start
, offset
;
6035 unsigned char **extended_ops
= NULL
;
6037 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6038 if (version
!= 4 && version
!= 5)
6040 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
6041 section
->name
, version
);
6045 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
6046 offset_size
= (flags
& 1) ? 8 : 4;
6047 printf (_(" Offset: %#" PRIx64
"\n"), sec_offset
);
6048 printf (_(" Version: %d\n"), version
);
6049 printf (_(" Offset size: %d\n"), offset_size
);
6052 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
6053 printf (_(" Offset into .debug_line: %#" PRIx64
"\n"),
6058 unsigned int i
, count
, op
;
6061 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
6063 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
6064 extended_ops
= extended_op_buf
;
6067 printf (_(" Extension opcode arguments:\n"));
6068 for (i
= 0; i
< count
; i
++)
6070 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6071 extended_ops
[op
] = curr
;
6072 READ_ULEB (nargs
, curr
, end
);
6074 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
6077 printf (_(" DW_MACRO_%02x arguments: "), op
);
6078 for (n
= 0; n
< nargs
; n
++)
6082 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6083 printf ("%s%s", get_FORM_name (form
),
6084 n
== nargs
- 1 ? "\n" : ", ");
6094 case DW_FORM_block1
:
6095 case DW_FORM_block2
:
6096 case DW_FORM_block4
:
6098 case DW_FORM_string
:
6100 case DW_FORM_sec_offset
:
6103 error (_("Invalid extension opcode form %s\n"),
6104 get_FORM_name (form
));
6120 error (_(".debug_macro section not zero terminated\n"));
6124 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6130 case DW_MACRO_define
:
6131 READ_ULEB (lineno
, curr
, end
);
6133 curr
+= strnlen ((char *) string
, end
- string
);
6134 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6135 lineno
, (int) (curr
- string
), string
);
6140 case DW_MACRO_undef
:
6141 READ_ULEB (lineno
, curr
, end
);
6143 curr
+= strnlen ((char *) string
, end
- string
);
6144 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6145 lineno
, (int) (curr
- string
), string
);
6150 case DW_MACRO_start_file
:
6152 unsigned int filenum
;
6153 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6155 READ_ULEB (lineno
, curr
, end
);
6156 READ_ULEB (filenum
, curr
, end
);
6158 if ((flags
& 2) == 0)
6159 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6162 = get_line_filename_and_dirname (line_offset
, filenum
,
6164 if (file_name
== NULL
)
6165 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6168 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6170 dir_name
!= NULL
? (const char *) dir_name
: "",
6171 dir_name
!= NULL
? "/" : "", file_name
);
6175 case DW_MACRO_end_file
:
6176 printf (_(" DW_MACRO_end_file\n"));
6179 case DW_MACRO_define_strp
:
6180 READ_ULEB (lineno
, curr
, end
);
6181 if (version
== 4 && is_dwo
)
6182 READ_ULEB (offset
, curr
, end
);
6184 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6185 string
= fetch_indirect_string (offset
);
6186 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6190 case DW_MACRO_undef_strp
:
6191 READ_ULEB (lineno
, curr
, end
);
6192 if (version
== 4 && is_dwo
)
6193 READ_ULEB (offset
, curr
, end
);
6195 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6196 string
= fetch_indirect_string (offset
);
6197 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6201 case DW_MACRO_import
:
6202 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6203 printf (_(" DW_MACRO_import - offset : %#" PRIx64
"\n"),
6207 case DW_MACRO_define_sup
:
6208 READ_ULEB (lineno
, curr
, end
);
6209 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6210 printf (_(" DW_MACRO_define_sup - lineno : %d"
6211 " macro offset : %#" PRIx64
"\n"),
6215 case DW_MACRO_undef_sup
:
6216 READ_ULEB (lineno
, curr
, end
);
6217 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6218 printf (_(" DW_MACRO_undef_sup - lineno : %d"
6219 " macro offset : %#" PRIx64
"\n"),
6223 case DW_MACRO_import_sup
:
6224 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6225 printf (_(" DW_MACRO_import_sup - offset : %#" PRIx64
"\n"),
6229 case DW_MACRO_define_strx
:
6230 case DW_MACRO_undef_strx
:
6231 READ_ULEB (lineno
, curr
, end
);
6232 READ_ULEB (offset
, curr
, end
);
6233 string
= (const unsigned char *)
6234 fetch_indexed_string (offset
, NULL
, offset_size
, false, 0);
6235 if (op
== DW_MACRO_define_strx
)
6236 printf (" DW_MACRO_define_strx ");
6238 printf (" DW_MACRO_undef_strx ");
6240 printf (_("(with offset %#" PRIx64
") "), offset
);
6241 printf (_("lineno : %d macro : %s\n"),
6246 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6248 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6252 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6254 error (_(" Unknown macro opcode %02x seen\n"), op
);
6259 /* Skip over unhandled opcodes. */
6261 unsigned char *desc
= extended_ops
[op
];
6262 READ_ULEB (nargs
, desc
, end
);
6265 printf (_(" DW_MACRO_%02x\n"), op
);
6268 printf (_(" DW_MACRO_%02x -"), op
);
6269 for (n
= 0; n
< nargs
; n
++)
6273 /* DW_FORM_implicit_const is not expected here. */
6274 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6276 = read_and_display_attr_value (0, val
, 0,
6277 start
, curr
, end
, 0, 0,
6278 offset_size
, version
,
6297 display_debug_abbrev (struct dwarf_section
*section
,
6298 void *file ATTRIBUTE_UNUSED
)
6300 abbrev_entry
*entry
;
6301 unsigned char *start
= section
->start
;
6303 introduce (section
, false);
6307 uint64_t offset
= start
- section
->start
;
6308 abbrev_list
*list
= find_and_process_abbrev_set (section
, 0,
6309 section
->size
, offset
,
6314 if (list
->first_abbrev
)
6315 printf (_(" Number TAG (%#" PRIx64
")\n"), offset
);
6317 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6321 printf (" %ld %s [%s]\n",
6323 get_TAG_name (entry
->tag
),
6324 entry
->children
? _("has children") : _("no children"));
6326 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6328 printf (" %-18s %s",
6329 get_AT_name (attr
->attribute
),
6330 get_FORM_name (attr
->form
));
6331 if (attr
->form
== DW_FORM_implicit_const
)
6332 printf (": %" PRId64
, attr
->implicit_const
);
6336 start
= list
->start_of_next_abbrevs
;
6337 free_abbrev_list (list
);
6346 /* Return true when ADDR is the maximum address, when addresses are
6347 POINTER_SIZE bytes long. */
6350 is_max_address (uint64_t addr
, unsigned int pointer_size
)
6352 uint64_t mask
= ~(~(uint64_t) 0 << 1 << (pointer_size
* 8 - 1));
6353 return ((addr
& mask
) == mask
);
6356 /* Display a view pair list starting at *VSTART_PTR and ending at
6357 VLISTEND within SECTION. */
6360 display_view_pair_list (struct dwarf_section
*section
,
6361 unsigned char **vstart_ptr
,
6362 unsigned int debug_info_entry
,
6363 unsigned char *vlistend
)
6365 unsigned char *vstart
= *vstart_ptr
;
6366 unsigned char *section_end
= section
->start
+ section
->size
;
6367 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6369 if (vlistend
< section_end
)
6370 section_end
= vlistend
;
6374 while (vstart
< section_end
)
6376 uint64_t off
= vstart
- section
->start
;
6377 uint64_t vbegin
, vend
;
6379 READ_ULEB (vbegin
, vstart
, section_end
);
6380 if (vstart
== section_end
)
6383 READ_ULEB (vend
, vstart
, section_end
);
6384 printf (" %8.8" PRIx64
" ", off
);
6386 print_view (vbegin
, pointer_size
);
6387 print_view (vend
, pointer_size
);
6388 printf (_("location view pair\n"));
6392 *vstart_ptr
= vstart
;
6395 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6398 display_loc_list (struct dwarf_section
*section
,
6399 unsigned char **start_ptr
,
6400 unsigned int debug_info_entry
,
6402 uint64_t base_address
,
6403 unsigned char **vstart_ptr
,
6406 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6407 unsigned char *section_end
= section
->start
+ section
->size
;
6409 unsigned int pointer_size
;
6410 unsigned int offset_size
;
6414 unsigned short length
;
6415 int need_frame_base
;
6417 if (debug_info_entry
>= num_debug_info_entries
)
6419 warn (_("No debug information available for loc lists of entry: %u\n"),
6424 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6425 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6426 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6427 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6429 if (pointer_size
< 2 || pointer_size
> 8)
6431 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6432 pointer_size
, debug_info_entry
);
6438 uint64_t off
= offset
+ (start
- *start_ptr
);
6439 uint64_t vbegin
= -1, vend
= -1;
6441 if (2 * pointer_size
> (size_t) (section_end
- start
))
6443 warn (_("Location list starting at offset %#" PRIx64
6444 " is not terminated.\n"), offset
);
6451 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6452 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6454 if (begin
== 0 && end
== 0)
6456 /* PR 18374: In a object file we can have a location list that
6457 starts with a begin and end of 0 because there are relocations
6458 that need to be applied to the addresses. Actually applying
6459 the relocations now does not help as they will probably resolve
6460 to 0, since the object file has not been fully linked. Real
6461 end of list markers will not have any relocations against them. */
6462 if (! reloc_at (section
, off
)
6463 && ! reloc_at (section
, off
+ pointer_size
))
6465 printf (_("<End of list>\n"));
6470 /* Check base address specifiers. */
6471 if (is_max_address (begin
, pointer_size
)
6472 && !is_max_address (end
, pointer_size
))
6475 print_hex (begin
, pointer_size
);
6476 print_hex (end
, pointer_size
);
6477 printf (_("(base address)\n"));
6483 off
= offset
+ (vstart
- *start_ptr
);
6485 READ_ULEB (vbegin
, vstart
, section_end
);
6486 print_view (vbegin
, pointer_size
);
6488 READ_ULEB (vend
, vstart
, section_end
);
6489 print_view (vend
, pointer_size
);
6491 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6494 if (2 > (size_t) (section_end
- start
))
6496 warn (_("Location list starting at offset %#" PRIx64
6497 " is not terminated.\n"), offset
);
6501 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6503 if (length
> (size_t) (section_end
- start
))
6505 warn (_("Location list starting at offset %#" PRIx64
6506 " is not terminated.\n"), offset
);
6510 print_hex (begin
+ base_address
, pointer_size
);
6511 print_hex (end
+ base_address
, pointer_size
);
6514 need_frame_base
= decode_location_expression (start
,
6519 cu_offset
, section
);
6522 if (need_frame_base
&& !has_frame_base
)
6523 printf (_(" [without DW_AT_frame_base]"));
6525 if (begin
== end
&& vbegin
== vend
)
6526 fputs (_(" (start == end)"), stdout
);
6527 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6528 fputs (_(" (start > end)"), stdout
);
6536 *vstart_ptr
= vstart
;
6539 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6542 display_loclists_list (struct dwarf_section
* section
,
6543 unsigned char ** start_ptr
,
6544 unsigned int debug_info_entry
,
6546 uint64_t base_address
,
6547 unsigned char ** vstart_ptr
,
6550 unsigned char *start
= *start_ptr
;
6551 unsigned char *vstart
= *vstart_ptr
;
6552 unsigned char *section_end
= section
->start
+ section
->size
;
6554 unsigned int pointer_size
;
6555 unsigned int offset_size
;
6556 unsigned int dwarf_version
;
6558 /* Initialize it due to a false compiler warning. */
6559 uint64_t begin
= -1, vbegin
= -1;
6560 uint64_t end
= -1, vend
= -1;
6562 int need_frame_base
;
6564 if (debug_info_entry
>= num_debug_info_entries
)
6566 warn (_("No debug information available for "
6567 "loclists lists of entry: %u\n"),
6572 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6573 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6574 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6575 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6577 if (pointer_size
< 2 || pointer_size
> 8)
6579 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6580 pointer_size
, debug_info_entry
);
6586 uint64_t off
= offset
+ (start
- *start_ptr
);
6587 enum dwarf_location_list_entry_type llet
;
6589 if (start
+ 1 > section_end
)
6591 warn (_("Location list starting at offset %#" PRIx64
6592 " is not terminated.\n"), offset
);
6599 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6601 if (vstart
&& (llet
== DW_LLE_offset_pair
6602 || llet
== DW_LLE_start_end
6603 || llet
== DW_LLE_start_length
))
6605 off
= offset
+ (vstart
- *start_ptr
);
6607 READ_ULEB (vbegin
, vstart
, section_end
);
6608 print_view (vbegin
, pointer_size
);
6610 READ_ULEB (vend
, vstart
, section_end
);
6611 print_view (vend
, pointer_size
);
6613 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6618 case DW_LLE_end_of_list
:
6619 printf (_("<End of list>\n"));
6622 case DW_LLE_base_addressx
:
6623 READ_ULEB (base_address
, start
, section_end
);
6624 print_hex (base_address
, pointer_size
);
6625 printf (_("(index into .debug_addr) "));
6626 base_address
= fetch_indexed_addr (base_address
, pointer_size
);
6627 print_hex (base_address
, pointer_size
);
6628 printf (_("(base address)\n"));
6631 case DW_LLE_startx_endx
:
6632 READ_ULEB (begin
, start
, section_end
);
6633 begin
= fetch_indexed_addr (begin
, pointer_size
);
6634 READ_ULEB (end
, start
, section_end
);
6635 end
= fetch_indexed_addr (end
, pointer_size
);
6638 case DW_LLE_startx_length
:
6639 READ_ULEB (begin
, start
, section_end
);
6640 begin
= fetch_indexed_addr (begin
, pointer_size
);
6641 READ_ULEB (end
, start
, section_end
);
6645 case DW_LLE_default_location
:
6649 case DW_LLE_offset_pair
:
6650 READ_ULEB (begin
, start
, section_end
);
6651 begin
+= base_address
;
6652 READ_ULEB (end
, start
, section_end
);
6653 end
+= base_address
;
6656 case DW_LLE_base_address
:
6657 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6659 print_hex (base_address
, pointer_size
);
6660 printf (_("(base address)\n"));
6663 case DW_LLE_start_end
:
6664 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6665 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6668 case DW_LLE_start_length
:
6669 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6670 READ_ULEB (end
, start
, section_end
);
6674 #ifdef DW_LLE_view_pair
6675 case DW_LLE_view_pair
:
6677 printf (_("View pair entry in loclist with locviews attribute\n"));
6678 READ_ULEB (vbegin
, start
, section_end
);
6679 print_view (vbegin
, pointer_size
);
6681 READ_ULEB (vend
, start
, section_end
);
6682 print_view (vend
, pointer_size
);
6684 printf (_("views for:\n"));
6689 error (_("Invalid location list entry type %d\n"), llet
);
6693 if (llet
== DW_LLE_end_of_list
)
6696 if (llet
== DW_LLE_base_address
6697 || llet
== DW_LLE_base_addressx
)
6700 if (start
== section_end
)
6702 warn (_("Location list starting at offset %#" PRIx64
6703 " is not terminated.\n"), offset
);
6706 READ_ULEB (length
, start
, section_end
);
6708 if (length
> (size_t) (section_end
- start
))
6710 warn (_("Location list starting at offset %#" PRIx64
6711 " is not terminated.\n"), offset
);
6715 print_hex (begin
, pointer_size
);
6716 print_hex (end
, pointer_size
);
6719 need_frame_base
= decode_location_expression (start
,
6724 cu_offset
, section
);
6727 if (need_frame_base
&& !has_frame_base
)
6728 printf (_(" [without DW_AT_frame_base]"));
6730 if (begin
== end
&& vbegin
== vend
)
6731 fputs (_(" (start == end)"), stdout
);
6732 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6733 fputs (_(" (start > end)"), stdout
);
6741 if (vbegin
!= (uint64_t) -1 || vend
!= (uint64_t) -1)
6742 printf (_("Trailing view pair not used in a range"));
6745 *vstart_ptr
= vstart
;
6748 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6749 right-adjusted in a field of length LEN, and followed by a space. */
6752 print_addr_index (unsigned int idx
, unsigned int len
)
6754 static char buf
[15];
6755 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6756 printf ("%*s ", len
, buf
);
6759 /* Display a location list from a .dwo section. It uses address indexes rather
6760 than embedded addresses. This code closely follows display_loc_list, but the
6761 two are sufficiently different that combining things is very ugly. */
6764 display_loc_list_dwo (struct dwarf_section
*section
,
6765 unsigned char **start_ptr
,
6766 unsigned int debug_info_entry
,
6768 unsigned char **vstart_ptr
,
6771 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6772 unsigned char *section_end
= section
->start
+ section
->size
;
6774 unsigned int pointer_size
;
6775 unsigned int offset_size
;
6778 unsigned short length
;
6779 int need_frame_base
;
6782 if (debug_info_entry
>= num_debug_info_entries
)
6784 warn (_("No debug information for loc lists of entry: %u\n"),
6789 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6790 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6791 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6792 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6794 if (pointer_size
< 2 || pointer_size
> 8)
6796 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6797 pointer_size
, debug_info_entry
);
6804 print_hex (offset
+ (start
- *start_ptr
), 4);
6806 if (start
>= section_end
)
6808 warn (_("Location list starting at offset %#" PRIx64
6809 " is not terminated.\n"), offset
);
6813 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6826 uint64_t off
= offset
+ (vstart
- *start_ptr
);
6828 READ_ULEB (view
, vstart
, section_end
);
6829 print_view (view
, 8);
6831 READ_ULEB (view
, vstart
, section_end
);
6832 print_view (view
, 8);
6834 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6842 case 0: /* A terminating entry. */
6844 *vstart_ptr
= vstart
;
6845 printf (_("<End of list>\n"));
6847 case 1: /* A base-address entry. */
6848 READ_ULEB (idx
, start
, section_end
);
6849 print_addr_index (idx
, 8);
6850 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6851 printf (_("(base address selection entry)\n"));
6853 case 2: /* A start/end entry. */
6854 READ_ULEB (idx
, start
, section_end
);
6855 print_addr_index (idx
, 8);
6856 READ_ULEB (idx
, start
, section_end
);
6857 print_addr_index (idx
, 8);
6859 case 3: /* A start/length entry. */
6860 READ_ULEB (idx
, start
, section_end
);
6861 print_addr_index (idx
, 8);
6862 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6863 printf ("%08x ", idx
);
6865 case 4: /* An offset pair entry. */
6866 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6867 printf ("%08x ", idx
);
6868 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6869 printf ("%08x ", idx
);
6872 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6874 *vstart_ptr
= vstart
;
6878 if (2 > (size_t) (section_end
- start
))
6880 warn (_("Location list starting at offset %#" PRIx64
6881 " is not terminated.\n"), offset
);
6885 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6886 if (length
> (size_t) (section_end
- start
))
6888 warn (_("Location list starting at offset %#" PRIx64
6889 " is not terminated.\n"), offset
);
6894 need_frame_base
= decode_location_expression (start
,
6899 cu_offset
, section
);
6902 if (need_frame_base
&& !has_frame_base
)
6903 printf (_(" [without DW_AT_frame_base]"));
6911 *vstart_ptr
= vstart
;
6914 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6917 static uint64_t *loc_offsets
, *loc_views
;
6920 loc_offsets_compar (const void *ap
, const void *bp
)
6922 uint64_t a
= loc_offsets
[*(const unsigned int *) ap
];
6923 uint64_t b
= loc_offsets
[*(const unsigned int *) bp
];
6925 int ret
= (a
> b
) - (b
> a
);
6929 a
= loc_views
[*(const unsigned int *) ap
];
6930 b
= loc_views
[*(const unsigned int *) bp
];
6932 ret
= (a
> b
) - (b
> a
);
6938 display_offset_entry_loclists (struct dwarf_section
*section
)
6940 unsigned char * start
= section
->start
;
6941 unsigned char * const end
= start
+ section
->size
;
6943 introduce (section
, false);
6948 unsigned short version
;
6949 unsigned char address_size
;
6950 unsigned char segment_selector_size
;
6951 uint32_t offset_entry_count
;
6955 printf (_("Table at Offset %#tx\n"), start
- section
->start
);
6957 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
6958 if (length
== 0xffffffff)
6961 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
6966 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
6967 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, end
);
6968 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, end
);
6969 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, end
);
6971 printf (_(" Length: %#" PRIx64
"\n"), length
);
6972 printf (_(" DWARF version: %u\n"), version
);
6973 printf (_(" Address size: %u\n"), address_size
);
6974 printf (_(" Segment size: %u\n"), segment_selector_size
);
6975 printf (_(" Offset entries: %u\n"), offset_entry_count
);
6979 warn (_("The %s section contains a corrupt or "
6980 "unsupported version number: %d.\n"),
6981 section
->name
, version
);
6985 if (segment_selector_size
!= 0)
6987 warn (_("The %s section contains an "
6988 "unsupported segment selector size: %d.\n"),
6989 section
->name
, segment_selector_size
);
6993 if (offset_entry_count
== 0)
6995 warn (_("The %s section contains a table without offset\n"),
7000 printf (_("\n Offset Entries starting at %#tx:\n"),
7001 start
- section
->start
);
7003 for (i
= 0; i
< offset_entry_count
; i
++)
7007 SAFE_BYTE_GET_AND_INC (entry
, start
, is_64bit
? 8 : 4, end
);
7008 printf (_(" [%6u] %#" PRIx64
"\n"), i
, entry
);
7015 for (j
= 1, i
= 0; i
< offset_entry_count
;)
7018 uint64_t base_address
= 0;
7021 uint64_t off
= start
- section
->start
;
7025 printf (_(" Offset Entry %u\n"), i
);
7032 SAFE_BYTE_GET_AND_INC (lle
, start
, 1, end
);
7036 case DW_LLE_end_of_list
:
7037 printf (_("<End of list>\n\n"));
7041 case DW_LLE_base_addressx
:
7042 READ_ULEB (base_address
, start
, end
);
7043 print_hex (base_address
, address_size
);
7044 printf (_("(index into .debug_addr) "));
7045 base_address
= fetch_indexed_addr (base_address
, address_size
);
7046 print_hex (base_address
, address_size
);
7047 printf (_("(base address)\n"));
7050 case DW_LLE_startx_endx
:
7051 READ_ULEB (begin
, start
, end
);
7052 begin
= fetch_indexed_addr (begin
, address_size
);
7053 READ_ULEB (finish
, start
, end
);
7054 finish
= fetch_indexed_addr (finish
, address_size
);
7057 case DW_LLE_startx_length
:
7058 READ_ULEB (begin
, start
, end
);
7059 begin
= fetch_indexed_addr (begin
, address_size
);
7060 READ_ULEB (finish
, start
, end
);
7064 case DW_LLE_offset_pair
:
7065 READ_ULEB (begin
, start
, end
);
7066 begin
+= base_address
;
7067 READ_ULEB (finish
, start
, end
);
7068 finish
+= base_address
;
7071 case DW_LLE_default_location
:
7075 case DW_LLE_base_address
:
7076 SAFE_BYTE_GET_AND_INC (base_address
, start
, address_size
, end
);
7077 print_hex (base_address
, address_size
);
7078 printf (_("(base address)\n"));
7081 case DW_LLE_start_end
:
7082 SAFE_BYTE_GET_AND_INC (begin
, start
, address_size
, end
);
7083 SAFE_BYTE_GET_AND_INC (finish
, start
, address_size
, end
);
7086 case DW_LLE_start_length
:
7087 SAFE_BYTE_GET_AND_INC (begin
, start
, address_size
, end
);
7088 READ_ULEB (finish
, start
, end
);
7093 error (_("Invalid location list entry type %d\n"), lle
);
7099 warn (_("Location list starting at offset %#" PRIx64
7100 " is not terminated.\n"), off
);
7104 print_hex (begin
, address_size
);
7105 print_hex (finish
, address_size
);
7107 if (begin
== finish
)
7108 fputs (_("(start == end)"), stdout
);
7109 else if (begin
> finish
)
7110 fputs (_("(start > end)"), stdout
);
7112 /* Read the counted location descriptions. */
7113 READ_ULEB (length
, start
, end
);
7115 if (length
> (size_t) (end
- start
))
7117 warn (_("Location list starting at offset %#" PRIx64
7118 " is not terminated.\n"), off
);
7122 (void) decode_location_expression (start
, address_size
, address_size
,
7123 version
, length
, 0, section
);
7130 while (start
< end
);
7136 display_debug_loc (struct dwarf_section
*section
, void *file
)
7138 unsigned char *start
= section
->start
, *vstart
= NULL
;
7140 unsigned char *section_begin
= start
;
7141 unsigned int num_loc_list
= 0;
7142 uint64_t last_offset
= 0;
7143 uint64_t last_view
= 0;
7144 unsigned int first
= 0;
7147 int seen_first_offset
= 0;
7148 int locs_sorted
= 1;
7149 unsigned char *next
= start
, *vnext
= vstart
;
7150 unsigned int *array
= NULL
;
7151 const char *suffix
= strrchr (section
->name
, '.');
7152 bool is_dwo
= false;
7153 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
7154 uint64_t expected_start
= 0;
7156 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
7159 bytes
= section
->size
;
7163 printf (_("\nThe %s section is empty.\n"), section
->name
);
7169 unsigned char *hdrptr
= section_begin
;
7171 unsigned short ll_version
;
7172 unsigned char *end
= section_begin
+ section
->size
;
7173 unsigned char address_size
, segment_selector_size
;
7174 uint32_t offset_entry_count
;
7176 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
7177 if (ll_length
== 0xffffffff)
7178 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
7180 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
7181 if (ll_version
!= 5)
7183 warn (_("The %s section contains corrupt or "
7184 "unsupported version number: %d.\n"),
7185 section
->name
, ll_version
);
7189 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
7191 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
7192 if (segment_selector_size
!= 0)
7194 warn (_("The %s section contains "
7195 "unsupported segment selector size: %d.\n"),
7196 section
->name
, segment_selector_size
);
7200 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
7202 if (offset_entry_count
!= 0)
7203 return display_offset_entry_loclists (section
);
7205 expected_start
= hdrptr
- section_begin
;
7208 if (load_debug_info (file
) == 0)
7210 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7215 /* Check the order of location list in .debug_info section. If
7216 offsets of location lists are in the ascending order, we can
7217 use `debug_information' directly. */
7218 for (i
= 0; i
< num_debug_info_entries
; i
++)
7222 num
= debug_information
[i
].num_loc_offsets
;
7223 if (num
> num_loc_list
)
7226 /* Check if we can use `debug_information' directly. */
7227 if (locs_sorted
&& num
!= 0)
7229 if (!seen_first_offset
)
7231 /* This is the first location list. */
7232 last_offset
= debug_information
[i
].loc_offsets
[0];
7233 last_view
= debug_information
[i
].loc_views
[0];
7235 seen_first_offset
= 1;
7241 for (; j
< num
; j
++)
7244 debug_information
[i
].loc_offsets
[j
]
7245 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
7246 && last_view
> debug_information
[i
].loc_views
[j
]))
7251 last_offset
= debug_information
[i
].loc_offsets
[j
];
7252 last_view
= debug_information
[i
].loc_views
[j
];
7257 if (!seen_first_offset
)
7258 error (_("No location lists in .debug_info section!\n"));
7260 if (debug_information
[first
].num_loc_offsets
> 0
7261 && debug_information
[first
].loc_offsets
[0] != expected_start
7262 && debug_information
[first
].loc_views
[0] != expected_start
)
7263 warn (_("Location lists in %s section start at %#" PRIx64
7264 " rather than %#" PRIx64
"\n"),
7265 section
->name
, debug_information
[first
].loc_offsets
[0],
7269 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
7271 introduce (section
, false);
7273 if (reloc_at (section
, 0))
7274 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
7276 printf (_(" Offset Begin End Expression\n"));
7278 seen_first_offset
= 0;
7279 for (i
= first
; i
< num_debug_info_entries
; i
++)
7281 uint64_t offset
, voffset
;
7282 uint64_t base_address
;
7288 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
7290 loc_offsets
= debug_information
[i
].loc_offsets
;
7291 loc_views
= debug_information
[i
].loc_views
;
7292 qsort (array
, debug_information
[i
].num_loc_offsets
,
7293 sizeof (*array
), loc_offsets_compar
);
7296 int adjacent_view_loclists
= 1;
7297 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
7299 j
= locs_sorted
? k
: array
[k
];
7301 && (debug_information
[i
].loc_offsets
[locs_sorted
7302 ? k
- 1 : array
[k
- 1]]
7303 == debug_information
[i
].loc_offsets
[j
])
7304 && (debug_information
[i
].loc_views
[locs_sorted
7305 ? k
- 1 : array
[k
- 1]]
7306 == debug_information
[i
].loc_views
[j
]))
7308 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
7309 offset
= debug_information
[i
].loc_offsets
[j
];
7310 next
= section_begin
+ offset
;
7311 voffset
= debug_information
[i
].loc_views
[j
];
7312 if (voffset
!= (uint64_t) -1)
7313 vnext
= section_begin
+ voffset
;
7316 base_address
= debug_information
[i
].base_address
;
7318 if (vnext
&& vnext
< next
)
7321 display_view_pair_list (section
, &vstart
, i
, next
);
7326 if (!seen_first_offset
|| !adjacent_view_loclists
)
7327 seen_first_offset
= 1;
7331 warn (_("There is a hole [%#tx - %#" PRIx64
"]"
7332 " in %s section.\n"),
7333 start
- section_begin
, offset
, section
->name
);
7334 else if (start
> next
)
7335 warn (_("There is an overlap [%#tx - %#" PRIx64
"]"
7336 " in %s section.\n"),
7337 start
- section_begin
, offset
, section
->name
);
7342 if (offset
>= bytes
)
7344 warn (_("Offset %#" PRIx64
" is bigger than %s section size.\n"),
7345 offset
, section
->name
);
7349 if (vnext
&& voffset
>= bytes
)
7351 warn (_("View Offset %#" PRIx64
" is bigger than %s section size.\n"),
7352 voffset
, section
->name
);
7359 display_loc_list_dwo (section
, &start
, i
, offset
,
7360 &vstart
, has_frame_base
);
7362 display_loc_list (section
, &start
, i
, offset
, base_address
,
7363 &vstart
, has_frame_base
);
7368 warn (_("DWO is not yet supported.\n"));
7370 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7371 &vstart
, has_frame_base
);
7374 /* FIXME: this arrangement is quite simplistic. Nothing
7375 requires locview lists to be adjacent to corresponding
7376 loclists, and a single loclist could be augmented by
7377 different locview lists, and vice-versa, unlikely as it
7378 is that it would make sense to do so. Hopefully we'll
7379 have view pair support built into loclists before we ever
7380 need to address all these possibilities. */
7381 if (adjacent_view_loclists
&& vnext
7382 && vnext
!= start
&& vstart
!= next
)
7384 adjacent_view_loclists
= 0;
7385 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7388 if (vnext
&& vnext
== start
)
7389 display_view_pair_list (section
, &start
, i
, vstart
);
7393 if (start
< section
->start
+ section
->size
)
7394 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7395 "There are %ld unused bytes at the end of section %s\n",
7396 (long) (section
->start
+ section
->size
- start
)),
7397 (long) (section
->start
+ section
->size
- start
), section
->name
);
7404 display_debug_str (struct dwarf_section
*section
,
7405 void *file ATTRIBUTE_UNUSED
)
7407 unsigned char *start
= section
->start
;
7408 uint64_t bytes
= section
->size
;
7409 uint64_t addr
= section
->address
;
7413 printf (_("\nThe %s section is empty.\n"), section
->name
);
7417 introduce (section
, false);
7425 lbytes
= (bytes
> 16 ? 16 : bytes
);
7427 printf (" 0x%8.8" PRIx64
" ", addr
);
7429 for (j
= 0; j
< 16; j
++)
7432 printf ("%2.2x", start
[j
]);
7440 for (j
= 0; j
< lbytes
; j
++)
7443 if (k
>= ' ' && k
< 0x80)
7462 display_debug_info (struct dwarf_section
*section
, void *file
)
7464 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7468 display_debug_types (struct dwarf_section
*section
, void *file
)
7470 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7474 display_trace_info (struct dwarf_section
*section
, void *file
)
7476 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7480 display_debug_aranges (struct dwarf_section
*section
,
7481 void *file ATTRIBUTE_UNUSED
)
7483 unsigned char *start
= section
->start
;
7484 unsigned char *end
= start
+ section
->size
;
7486 introduce (section
, false);
7488 /* It does not matter if this load fails,
7489 we test for that later on. */
7490 load_debug_info (file
);
7494 unsigned char *hdrptr
;
7495 DWARF2_Internal_ARange arange
;
7496 unsigned char *addr_ranges
;
7500 unsigned char address_size
;
7501 unsigned int offset_size
;
7502 unsigned char *end_ranges
;
7505 sec_off
= hdrptr
- section
->start
;
7507 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7508 if (arange
.ar_length
== 0xffffffff)
7510 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7516 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7518 warn (_("Debug info is corrupted, %s header at %#" PRIx64
7519 " has length %#" PRIx64
"\n"),
7520 section
->name
, sec_off
, arange
.ar_length
);
7523 end_ranges
= hdrptr
+ arange
.ar_length
;
7525 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7526 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7529 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7530 && num_debug_info_entries
> 0
7531 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7532 warn (_(".debug_info offset of %#" PRIx64
7533 " in %s section does not point to a CU header.\n"),
7534 arange
.ar_info_offset
, section
->name
);
7536 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7537 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7539 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7541 /* PR 19872: A version number of 0 probably means that there is
7542 padding at the end of the .debug_aranges section. Gold puts
7543 it there when performing an incremental link, for example.
7544 So do not generate a warning in this case. */
7545 if (arange
.ar_version
)
7546 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7550 printf (_(" Length: %" PRId64
"\n"), arange
.ar_length
);
7551 printf (_(" Version: %d\n"), arange
.ar_version
);
7552 printf (_(" Offset into .debug_info: %#" PRIx64
"\n"),
7553 arange
.ar_info_offset
);
7554 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7555 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7557 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7559 /* PR 17512: file: 001-108546-0.001:0.1. */
7560 if (address_size
== 0 || address_size
> 8)
7562 error (_("Invalid address size in %s section!\n"),
7567 /* The DWARF spec does not require that the address size be a power
7568 of two, but we do. This will have to change if we ever encounter
7569 an uneven architecture. */
7570 if ((address_size
& (address_size
- 1)) != 0)
7572 warn (_("Pointer size + Segment size is not a power of two.\n"));
7576 if (address_size
> 4)
7577 printf (_("\n Address Length\n"));
7579 printf (_("\n Address Length\n"));
7581 addr_ranges
= hdrptr
;
7583 /* Must pad to an alignment boundary that is twice the address size. */
7584 addr_ranges
+= (2 * address_size
- 1
7585 - (hdrptr
- start
- 1) % (2 * address_size
));
7587 while (2 * address_size
<= end_ranges
- addr_ranges
)
7589 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
,
7591 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
,
7594 print_hex (address
, address_size
);
7595 print_hex_ns (length
, address_size
);
7607 /* Comparison function for qsort. */
7609 comp_addr_base (const void * v0
, const void * v1
)
7611 debug_info
*info0
= *(debug_info
**) v0
;
7612 debug_info
*info1
= *(debug_info
**) v1
;
7613 return info0
->addr_base
- info1
->addr_base
;
7616 /* Display the debug_addr section. */
7618 display_debug_addr (struct dwarf_section
*section
,
7621 debug_info
**debug_addr_info
;
7622 unsigned char *entry
;
7626 unsigned char * header
;
7628 if (section
->size
== 0)
7630 printf (_("\nThe %s section is empty.\n"), section
->name
);
7634 if (load_debug_info (file
) == 0)
7636 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7641 introduce (section
, false);
7643 /* PR 17531: file: cf38d01b.
7644 We use xcalloc because a corrupt file may not have initialised all of the
7645 fields in the debug_info structure, which means that the sort below might
7646 try to move uninitialised data. */
7647 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7648 sizeof (debug_info
*));
7651 for (i
= 0; i
< num_debug_info_entries
; i
++)
7652 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7654 /* PR 17531: file: cf38d01b. */
7655 if (debug_information
[i
].addr_base
>= section
->size
)
7656 warn (_("Corrupt address base (%#" PRIx64
")"
7657 " found in debug section %u\n"),
7658 debug_information
[i
].addr_base
, i
);
7660 debug_addr_info
[count
++] = debug_information
+ i
;
7663 /* Add a sentinel to make iteration convenient. */
7664 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7665 debug_addr_info
[count
]->addr_base
= section
->size
;
7666 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7668 header
= section
->start
;
7669 for (i
= 0; i
< count
; i
++)
7672 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7674 printf (_(" For compilation unit at offset %#" PRIx64
":\n"),
7675 debug_addr_info
[i
]->cu_offset
);
7677 printf (_("\tIndex\tAddress\n"));
7678 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7679 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7681 size_t header_size
= entry
- header
;
7682 unsigned char *curr_header
= header
;
7685 int segment_selector_size
;
7687 if (header_size
!= 8 && header_size
!= 16)
7689 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %zd instead\n"),
7690 section
->name
, header_size
);
7694 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7695 if (length
== 0xffffffff)
7696 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7697 end
= curr_header
+ length
;
7699 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7701 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7702 section
->name
, version
);
7704 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7705 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7706 address_size
+= segment_selector_size
;
7709 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7714 uint64_t base
= byte_get (entry
, address_size
);
7715 printf (_("\t%d:\t"), idx
);
7716 print_hex_ns (base
, address_size
);
7718 entry
+= address_size
;
7724 free (debug_addr_info
);
7728 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7731 display_debug_str_offsets (struct dwarf_section
*section
,
7732 void *file ATTRIBUTE_UNUSED
)
7736 if (section
->size
== 0)
7738 printf (_("\nThe %s section is empty.\n"), section
->name
);
7742 unsigned char *start
= section
->start
;
7743 unsigned char *end
= start
+ section
->size
;
7744 unsigned char *curr
= start
;
7745 uint64_t debug_str_offsets_hdr_len
;
7747 const char *suffix
= strrchr (section
->name
, '.');
7748 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7751 load_debug_section_with_follow (str_dwo
, file
);
7753 load_debug_section_with_follow (str
, file
);
7755 introduce (section
, false);
7760 uint64_t entry_length
;
7762 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7763 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7764 if (length
== 0xffffffff)
7766 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7768 debug_str_offsets_hdr_len
= 16;
7773 debug_str_offsets_hdr_len
= 8;
7776 unsigned char *entries_end
;
7779 /* This is probably an old style .debug_str_offset section which
7780 just contains offsets and no header (and the first offset is 0). */
7781 length
= section
->size
;
7782 curr
= section
->start
;
7785 printf (_(" Length: %#" PRIx64
"\n"), length
);
7786 printf (_(" Index Offset [String]\n"));
7790 if (length
<= (size_t) (end
- curr
))
7791 entries_end
= curr
+ length
;
7794 warn (_("Section %s is too small %#" PRIx64
"\n"),
7795 section
->name
, section
->size
);
7800 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7802 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7805 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
7807 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7809 printf (_(" Length: %#" PRIx64
"\n"), length
);
7810 printf (_(" Version: %#x\n"), version
);
7811 printf (_(" Index Offset [String]\n"));
7814 for (idx
= 0; curr
< entries_end
; idx
++)
7817 const unsigned char * string
;
7819 if ((size_t) (entries_end
- curr
) < entry_length
)
7820 /* Not enough space to read one entry_length, give up. */
7823 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7825 string
= (const unsigned char *)
7826 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
, debug_str_offsets_hdr_len
);
7828 string
= fetch_indirect_string (offset
);
7830 printf (" %8lu ", idx
);
7831 print_hex (offset
, entry_length
);
7832 printf (" %s\n", string
);
7839 /* Each debug_information[x].range_lists[y] gets this representation for
7840 sorting purposes. */
7844 /* The debug_information[x].range_lists[y] value. */
7845 uint64_t ranges_offset
;
7847 /* Original debug_information to find parameters of the data. */
7848 debug_info
*debug_info_p
;
7851 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7854 range_entry_compar (const void *ap
, const void *bp
)
7856 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7857 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7858 const uint64_t a
= a_re
->ranges_offset
;
7859 const uint64_t b
= b_re
->ranges_offset
;
7861 return (a
> b
) - (b
> a
);
7865 display_debug_ranges_list (unsigned char * start
,
7866 unsigned char * finish
,
7867 unsigned int pointer_size
,
7869 uint64_t base_address
)
7871 while (start
< finish
)
7876 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7877 if (start
>= finish
)
7879 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7882 print_hex (offset
, 4);
7884 if (begin
== 0 && end
== 0)
7886 printf (_("<End of list>\n"));
7890 /* Check base address specifiers. */
7891 if (is_max_address (begin
, pointer_size
)
7892 && !is_max_address (end
, pointer_size
))
7895 print_hex (begin
, pointer_size
);
7896 print_hex (end
, pointer_size
);
7897 printf ("(base address)\n");
7901 print_hex (begin
+ base_address
, pointer_size
);
7902 print_hex_ns (end
+ base_address
, pointer_size
);
7905 fputs (_(" (start == end)"), stdout
);
7906 else if (begin
> end
)
7907 fputs (_(" (start > end)"), stdout
);
7913 static unsigned char *
7914 display_debug_rnglists_list (unsigned char * start
,
7915 unsigned char * finish
,
7916 unsigned int pointer_size
,
7918 uint64_t base_address
,
7919 unsigned int offset_size
)
7921 unsigned char *next
= start
;
7922 unsigned int debug_addr_section_hdr_len
;
7924 if (offset_size
== 4)
7925 debug_addr_section_hdr_len
= 8;
7927 debug_addr_section_hdr_len
= 16;
7931 uint64_t off
= offset
+ (start
- next
);
7932 enum dwarf_range_list_entry rlet
;
7933 /* Initialize it due to a false compiler warning. */
7934 uint64_t begin
= -1, length
, end
= -1;
7936 if (start
>= finish
)
7938 warn (_("Range list starting at offset %#" PRIx64
7939 " is not terminated.\n"), offset
);
7946 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7950 case DW_RLE_end_of_list
:
7951 printf (_("<End of list>\n"));
7953 case DW_RLE_base_addressx
:
7954 READ_ULEB (base_address
, start
, finish
);
7955 print_hex (base_address
, pointer_size
);
7956 printf (_("(base address index) "));
7957 base_address
= fetch_indexed_addr ((base_address
* pointer_size
)
7958 + debug_addr_section_hdr_len
, pointer_size
);
7959 print_hex (base_address
, pointer_size
);
7960 printf (_("(base address)\n"));
7962 case DW_RLE_startx_endx
:
7963 READ_ULEB (begin
, start
, finish
);
7964 READ_ULEB (end
, start
, finish
);
7965 begin
= fetch_indexed_addr ((begin
* pointer_size
)
7966 + debug_addr_section_hdr_len
, pointer_size
);
7967 end
= fetch_indexed_addr ((begin
* pointer_size
)
7968 + debug_addr_section_hdr_len
, pointer_size
);
7970 case DW_RLE_startx_length
:
7971 READ_ULEB (begin
, start
, finish
);
7972 READ_ULEB (length
, start
, finish
);
7973 begin
= fetch_indexed_addr ((begin
* pointer_size
)
7974 + debug_addr_section_hdr_len
, pointer_size
);
7975 end
= begin
+ length
;
7977 case DW_RLE_offset_pair
:
7978 READ_ULEB (begin
, start
, finish
);
7979 READ_ULEB (end
, start
, finish
);
7981 case DW_RLE_base_address
:
7982 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7983 print_hex (base_address
, pointer_size
);
7984 printf (_("(base address)\n"));
7986 case DW_RLE_start_end
:
7987 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7988 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7990 case DW_RLE_start_length
:
7991 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7992 READ_ULEB (length
, start
, finish
);
7993 end
= begin
+ length
;
7996 error (_("Invalid range list entry type %d\n"), rlet
);
7997 rlet
= DW_RLE_end_of_list
;
8001 if (rlet
== DW_RLE_end_of_list
)
8003 if (rlet
== DW_RLE_base_address
|| rlet
== DW_RLE_base_addressx
)
8006 /* Only a DW_RLE_offset_pair needs the base address added. */
8007 if (rlet
== DW_RLE_offset_pair
)
8009 begin
+= base_address
;
8010 end
+= base_address
;
8013 print_hex (begin
, pointer_size
);
8014 print_hex (end
, pointer_size
);
8017 fputs (_(" (start == end)"), stdout
);
8018 else if (begin
> end
)
8019 fputs (_(" (start > end)"), stdout
);
8028 display_debug_rnglists (struct dwarf_section
*section
)
8030 unsigned char *start
= section
->start
;
8031 unsigned char *finish
= start
+ section
->size
;
8033 while (start
< finish
)
8035 unsigned char *table_start
;
8036 uint64_t offset
= start
- section
->start
;
8038 uint64_t initial_length
;
8039 unsigned char segment_selector_size
;
8040 unsigned int offset_entry_count
;
8042 unsigned short version
;
8043 unsigned char address_size
= 0;
8044 unsigned char offset_size
;
8046 /* Get and check the length of the block. */
8047 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
8049 if (initial_length
== 0xffffffff)
8051 /* This section is 64-bit DWARF 3. */
8052 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
8058 if (initial_length
> (size_t) (finish
- start
))
8060 /* If the length field has a relocation against it, then we should
8061 not complain if it is inaccurate (and probably negative).
8062 It is copied from .debug_line handling code. */
8063 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
8064 initial_length
= finish
- start
;
8067 warn (_("The length field (%#" PRIx64
8068 ") in the debug_rnglists header is wrong"
8069 " - the section is too small\n"),
8075 end
= start
+ initial_length
;
8077 /* Get the other fields in the header. */
8078 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
8079 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
8080 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
8081 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
8083 printf (_(" Table at Offset: %#" PRIx64
":\n"), offset
);
8084 printf (_(" Length: %#" PRIx64
"\n"), initial_length
);
8085 printf (_(" DWARF version: %u\n"), version
);
8086 printf (_(" Address size: %u\n"), address_size
);
8087 printf (_(" Segment size: %u\n"), segment_selector_size
);
8088 printf (_(" Offset entries: %u\n"), offset_entry_count
);
8090 /* Check the fields. */
8091 if (segment_selector_size
!= 0)
8093 warn (_("The %s section contains "
8094 "unsupported segment selector size: %d.\n"),
8095 section
->name
, segment_selector_size
);
8101 warn (_("Only DWARF version 5+ debug_rnglists info "
8102 "is currently supported.\n"));
8106 table_start
= start
;
8108 if (offset_entry_count
!= 0)
8110 printf (_("\n Offsets starting at %#tx:\n"),
8111 start
- section
->start
);
8113 for (i
= 0; i
< offset_entry_count
; i
++)
8117 SAFE_BYTE_GET_AND_INC (entry
, start
, offset_size
, finish
);
8118 printf (_(" [%6u] %#" PRIx64
"\n"), i
, entry
);
8122 offset_entry_count
= 1;
8124 for (i
= 0; i
< offset_entry_count
; i
++)
8126 uint64_t indx
= start
- table_start
;
8128 offset
= start
- section
->start
;
8129 printf (_("\n Offset: %#" PRIx64
", Index: %#" PRIx64
"\n"),
8131 printf (_(" Offset Begin End\n"));
8132 start
= display_debug_rnglists_list
8133 (start
, end
, address_size
, offset
, 0, offset_size
);
8149 display_debug_ranges (struct dwarf_section
*section
,
8150 void *file ATTRIBUTE_UNUSED
)
8152 unsigned char *start
= section
->start
;
8153 unsigned char *last_start
= start
;
8154 uint64_t bytes
= section
->size
;
8155 unsigned char *section_begin
= start
;
8156 unsigned char *finish
= start
+ bytes
;
8157 unsigned int num_range_list
, i
;
8158 struct range_entry
*range_entries
;
8159 struct range_entry
*range_entry_fill
;
8160 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
8161 /* Initialize it due to a false compiler warning. */
8162 unsigned char address_size
= 0;
8163 uint64_t last_offset
= 0;
8167 printf (_("\nThe %s section is empty.\n"), section
->name
);
8171 introduce (section
, false);
8174 return display_debug_rnglists (section
);
8176 if (load_debug_info (file
) == 0)
8178 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
8184 for (i
= 0; i
< num_debug_info_entries
; i
++)
8185 num_range_list
+= debug_information
[i
].num_range_lists
;
8187 if (num_range_list
== 0)
8189 /* This can happen when the file was compiled with -gsplit-debug
8190 which removes references to range lists from the primary .o file. */
8191 printf (_("No range lists in .debug_info section.\n"));
8195 range_entries
= (struct range_entry
*)
8196 xmalloc (sizeof (*range_entries
) * num_range_list
);
8197 range_entry_fill
= range_entries
;
8199 for (i
= 0; i
< num_debug_info_entries
; i
++)
8201 debug_info
*debug_info_p
= &debug_information
[i
];
8204 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
8206 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
8207 range_entry_fill
->debug_info_p
= debug_info_p
;
8212 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
8213 range_entry_compar
);
8215 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
8216 warn (_("Range lists in %s section start at %#" PRIx64
"\n"),
8217 section
->name
, range_entries
[0].ranges_offset
);
8220 printf (_(" Offset Begin End\n"));
8222 for (i
= 0; i
< num_range_list
; i
++)
8224 struct range_entry
*range_entry
= &range_entries
[i
];
8225 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
8226 unsigned int pointer_size
;
8228 unsigned char *next
;
8229 uint64_t base_address
;
8231 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
8232 offset
= range_entry
->ranges_offset
;
8233 base_address
= debug_info_p
->base_address
;
8235 /* PR 17512: file: 001-101485-0.001:0.1. */
8236 if (pointer_size
< 2 || pointer_size
> 8)
8238 warn (_("Corrupt pointer size (%d) in debug entry at offset %#" PRIx64
"\n"),
8239 pointer_size
, offset
);
8243 if (offset
> (size_t) (finish
- section_begin
))
8245 warn (_("Corrupt offset (%#" PRIx64
") in range entry %u\n"),
8250 next
= section_begin
+ offset
+ debug_info_p
->rnglists_base
;
8252 /* If multiple DWARF entities reference the same range then we will
8253 have multiple entries in the `range_entries' list for the same
8254 offset. Thanks to the sort above these will all be consecutive in
8255 the `range_entries' list, so we can easily ignore duplicates
8257 if (i
> 0 && last_offset
== offset
)
8259 last_offset
= offset
;
8261 if (dwarf_check
!= 0 && i
> 0)
8264 warn (_("There is a hole [%#tx - %#tx] in %s section.\n"),
8265 start
- section_begin
, next
- section_begin
, section
->name
);
8266 else if (start
> next
)
8268 if (next
== last_start
)
8270 warn (_("There is an overlap [%#tx - %#tx] in %s section.\n"),
8271 start
- section_begin
, next
- section_begin
, section
->name
);
8278 display_debug_ranges_list
8279 (start
, finish
, pointer_size
, offset
, base_address
);
8283 free (range_entries
);
8288 typedef struct Frame_Chunk
8290 struct Frame_Chunk
*next
;
8291 unsigned char *chunk_start
;
8293 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8294 short int *col_type
;
8297 unsigned int code_factor
;
8301 unsigned int cfa_reg
;
8302 uint64_t cfa_offset
;
8304 unsigned char fde_encoding
;
8305 unsigned char cfa_exp
;
8306 unsigned char ptr_size
;
8307 unsigned char segment_size
;
8311 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
8312 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
8313 static const char *const *dwarf_regnames
;
8314 static unsigned int dwarf_regnames_count
;
8315 static bool is_aarch64
;
8317 /* A marker for a col_type that means this column was never referenced
8318 in the frame info. */
8319 #define DW_CFA_unreferenced (-1)
8321 /* Return 0 if no more space is needed, 1 if more space is needed,
8322 -1 for invalid reg. */
8325 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
8327 unsigned int prev
= fc
->ncols
;
8329 if (reg
< (unsigned int) fc
->ncols
)
8332 if (dwarf_regnames_count
> 0
8333 && reg
> dwarf_regnames_count
)
8336 fc
->ncols
= reg
+ 1;
8337 /* PR 17512: file: 10450-2643-0.004.
8338 If reg == -1 then this can happen... */
8342 /* PR 17512: file: 2844a11d. */
8343 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
8345 error (_("Unfeasibly large register number: %u\n"), reg
);
8347 /* FIXME: 1024 is an arbitrary limit. Increase it if
8348 we ever encounter a valid binary that exceeds it. */
8352 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
8353 sizeof (short int));
8354 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
8355 /* PR 17512: file:002-10025-0.005. */
8356 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
8358 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
8364 while (prev
< fc
->ncols
)
8366 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8367 fc
->col_offset
[prev
] = 0;
8373 static const char *const dwarf_regnames_i386
[] =
8375 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8376 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8377 "eip", "eflags", NULL
, /* 8 - 10 */
8378 "st0", "st1", "st2", "st3", /* 11 - 14 */
8379 "st4", "st5", "st6", "st7", /* 15 - 18 */
8380 NULL
, NULL
, /* 19 - 20 */
8381 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
8382 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
8383 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
8384 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
8385 "fcw", "fsw", "mxcsr", /* 37 - 39 */
8386 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8387 "tr", "ldtr", /* 48 - 49 */
8388 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8389 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8390 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8391 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8392 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8393 NULL
, NULL
, NULL
, /* 90 - 92 */
8394 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8397 static const char *const dwarf_regnames_iamcu
[] =
8399 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8400 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8401 "eip", "eflags", NULL
, /* 8 - 10 */
8402 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8403 NULL
, NULL
, /* 19 - 20 */
8404 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8405 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8406 NULL
, NULL
, NULL
, /* 37 - 39 */
8407 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8408 "tr", "ldtr", /* 48 - 49 */
8409 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8410 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8411 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8412 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8413 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8414 NULL
, NULL
, NULL
, /* 90 - 92 */
8415 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8419 init_dwarf_regnames_i386 (void)
8421 dwarf_regnames
= dwarf_regnames_i386
;
8422 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8423 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8427 init_dwarf_regnames_iamcu (void)
8429 dwarf_regnames
= dwarf_regnames_iamcu
;
8430 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8431 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8434 static const char *const DW_CFA_GNU_window_save_name
[] =
8436 "DW_CFA_GNU_window_save",
8437 "DW_CFA_AARCH64_negate_ra_state"
8440 static const char *const dwarf_regnames_x86_64
[] =
8442 "rax", "rdx", "rcx", "rbx",
8443 "rsi", "rdi", "rbp", "rsp",
8444 "r8", "r9", "r10", "r11",
8445 "r12", "r13", "r14", "r15",
8447 "xmm0", "xmm1", "xmm2", "xmm3",
8448 "xmm4", "xmm5", "xmm6", "xmm7",
8449 "xmm8", "xmm9", "xmm10", "xmm11",
8450 "xmm12", "xmm13", "xmm14", "xmm15",
8451 "st0", "st1", "st2", "st3",
8452 "st4", "st5", "st6", "st7",
8453 "mm0", "mm1", "mm2", "mm3",
8454 "mm4", "mm5", "mm6", "mm7",
8456 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8457 "fs.base", "gs.base", NULL
, NULL
,
8459 "mxcsr", "fcw", "fsw",
8460 "xmm16", "xmm17", "xmm18", "xmm19",
8461 "xmm20", "xmm21", "xmm22", "xmm23",
8462 "xmm24", "xmm25", "xmm26", "xmm27",
8463 "xmm28", "xmm29", "xmm30", "xmm31",
8464 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8465 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8466 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8467 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8468 NULL
, NULL
, NULL
, /* 115 - 117 */
8469 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8473 init_dwarf_regnames_x86_64 (void)
8475 dwarf_regnames
= dwarf_regnames_x86_64
;
8476 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8477 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8480 static const char *const dwarf_regnames_aarch64
[] =
8482 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8483 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8484 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8485 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8486 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8487 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8488 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8489 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8490 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8491 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8492 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8493 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8494 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8495 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8496 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8497 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8501 init_dwarf_regnames_aarch64 (void)
8503 dwarf_regnames
= dwarf_regnames_aarch64
;
8504 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8505 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8509 static const char *const dwarf_regnames_s390
[] =
8511 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8512 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8513 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8514 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8515 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8516 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8517 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8518 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8519 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8522 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8523 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8527 init_dwarf_regnames_s390 (void)
8529 dwarf_regnames
= dwarf_regnames_s390
;
8530 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8531 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8534 static const char *const dwarf_regnames_riscv
[] =
8536 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8537 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8538 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8539 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8540 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8541 "fs0", "fs1", /* 40 - 41 */
8542 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8543 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8544 "fs10", "fs11", /* 58 - 59 */
8545 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8548 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8549 the large number of CSRs. */
8552 regname_internal_riscv (unsigned int regno
)
8554 const char *name
= NULL
;
8556 /* Lookup in the table first, this covers GPR and FPR. */
8557 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8558 name
= dwarf_regnames_riscv
[regno
];
8559 else if (regno
>= 4096 && regno
<= 8191)
8561 /* This might be a CSR, these live in a sparse number space from 4096
8562 to 8191 These numbers are defined in the RISC-V ELF ABI
8566 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8567 case VALUE + 4096: name = #NAME; break;
8568 #include "opcode/riscv-opc.h"
8573 static char csr_name
[10];
8574 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8585 init_dwarf_regnames_riscv (void)
8587 dwarf_regnames
= NULL
;
8588 dwarf_regnames_count
= 8192;
8589 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8593 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8595 dwarf_regnames_lookup_func
= NULL
;
8601 init_dwarf_regnames_i386 ();
8605 init_dwarf_regnames_iamcu ();
8611 init_dwarf_regnames_x86_64 ();
8615 init_dwarf_regnames_aarch64 ();
8619 init_dwarf_regnames_s390 ();
8623 init_dwarf_regnames_riscv ();
8631 /* Initialize the DWARF register name lookup state based on the
8632 architecture and specific machine type of a BFD. */
8635 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8638 dwarf_regnames_lookup_func
= NULL
;
8646 case bfd_mach_x86_64
:
8647 case bfd_mach_x86_64_intel_syntax
:
8648 case bfd_mach_x64_32
:
8649 case bfd_mach_x64_32_intel_syntax
:
8650 init_dwarf_regnames_x86_64 ();
8654 init_dwarf_regnames_i386 ();
8659 case bfd_arch_iamcu
:
8660 init_dwarf_regnames_iamcu ();
8663 case bfd_arch_aarch64
:
8664 init_dwarf_regnames_aarch64();
8668 init_dwarf_regnames_s390 ();
8671 case bfd_arch_riscv
:
8672 init_dwarf_regnames_riscv ();
8681 regname_internal_by_table_only (unsigned int regno
)
8683 if (dwarf_regnames
!= NULL
8684 && regno
< dwarf_regnames_count
8685 && dwarf_regnames
[regno
] != NULL
)
8686 return dwarf_regnames
[regno
];
8692 regname (unsigned int regno
, int name_only_p
)
8694 static char reg
[64];
8696 const char *name
= NULL
;
8698 if (dwarf_regnames_lookup_func
!= NULL
)
8699 name
= dwarf_regnames_lookup_func (regno
);
8705 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8708 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8713 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8718 if (*max_regs
!= fc
->ncols
)
8719 *max_regs
= fc
->ncols
;
8721 if (*need_col_headers
)
8723 *need_col_headers
= 0;
8725 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8727 for (r
= 0; r
< *max_regs
; r
++)
8728 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8733 printf ("%-5s ", regname (r
, 1));
8739 print_hex (fc
->pc_begin
, eh_addr_size
);
8741 strcpy (tmp
, "exp");
8743 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8744 printf ("%-8s ", tmp
);
8746 for (r
= 0; r
< fc
->ncols
; r
++)
8748 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8750 switch (fc
->col_type
[r
])
8752 case DW_CFA_undefined
:
8755 case DW_CFA_same_value
:
8759 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8761 case DW_CFA_val_offset
:
8762 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8764 case DW_CFA_register
:
8765 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8767 case DW_CFA_expression
:
8768 strcpy (tmp
, "exp");
8770 case DW_CFA_val_expression
:
8771 strcpy (tmp
, "vexp");
8774 strcpy (tmp
, "n/a");
8777 printf ("%-5s ", tmp
);
8783 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8785 static unsigned char *
8786 read_cie (unsigned char *start
, unsigned char *end
,
8787 Frame_Chunk
**p_cie
, int *p_version
,
8788 uint64_t *p_aug_len
, unsigned char **p_aug
)
8792 unsigned char *augmentation_data
= NULL
;
8793 uint64_t augmentation_data_len
= 0;
8796 /* PR 17512: file: 001-228113-0.004. */
8800 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8801 memset (fc
, 0, sizeof (Frame_Chunk
));
8803 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8804 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8808 fc
->augmentation
= (char *) start
;
8809 /* PR 17512: file: 001-228113-0.004.
8810 Skip past augmentation name, but avoid running off the end of the data. */
8812 if (* start
++ == '\0')
8816 warn (_("No terminator for augmentation name\n"));
8820 if (strcmp (fc
->augmentation
, "eh") == 0)
8822 if (eh_addr_size
> (size_t) (end
- start
))
8824 start
+= eh_addr_size
;
8829 if (2 > (size_t) (end
- start
))
8831 GET (fc
->ptr_size
, 1);
8832 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8834 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8838 GET (fc
->segment_size
, 1);
8839 /* PR 17512: file: e99d2804. */
8840 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8842 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8846 eh_addr_size
= fc
->ptr_size
;
8850 fc
->ptr_size
= eh_addr_size
;
8851 fc
->segment_size
= 0;
8854 READ_ULEB (fc
->code_factor
, start
, end
);
8855 READ_SLEB (fc
->data_factor
, start
, end
);
8866 READ_ULEB (fc
->ra
, start
, end
);
8869 if (fc
->augmentation
[0] == 'z')
8873 READ_ULEB (augmentation_data_len
, start
, end
);
8874 augmentation_data
= start
;
8875 /* PR 17512: file: 11042-2589-0.004. */
8876 if (augmentation_data_len
> (size_t) (end
- start
))
8878 warn (_("Augmentation data too long: %#" PRIx64
8879 ", expected at most %#tx\n"),
8880 augmentation_data_len
, end
- start
);
8883 start
+= augmentation_data_len
;
8886 if (augmentation_data_len
)
8890 unsigned char *qend
;
8892 p
= (unsigned char *) fc
->augmentation
+ 1;
8893 q
= augmentation_data
;
8894 qend
= q
+ augmentation_data_len
;
8896 while (p
< end
&& q
< qend
)
8901 q
+= 1 + size_of_encoded_value (*q
);
8903 fc
->fde_encoding
= *q
++;
8912 /* Note - it is OK if this loop terminates with q < qend.
8913 Padding may have been inserted to align the end of the CIE. */
8918 *p_version
= version
;
8921 *p_aug_len
= augmentation_data_len
;
8922 *p_aug
= augmentation_data
;
8927 free (fc
->col_offset
);
8928 free (fc
->col_type
);
8933 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8934 If do_wide is not enabled, then formats the output to fit into 80 columns.
8935 PRINTED contains the number of characters already written to the current
8939 display_data (size_t printed
, const unsigned char *data
, size_t len
)
8941 if (do_wide
|| len
< ((80 - printed
) / 3))
8942 for (printed
= 0; printed
< len
; ++printed
)
8943 printf (" %02x", data
[printed
]);
8946 for (printed
= 0; printed
< len
; ++printed
)
8948 if (printed
% (80 / 3) == 0)
8950 printf (" %02x", data
[printed
]);
8955 /* Prints out the contents on the augmentation data array.
8956 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8959 display_augmentation_data (const unsigned char * data
, uint64_t len
)
8963 i
= printf (_(" Augmentation data: "));
8964 display_data (i
, data
, len
);
8968 display_debug_frames (struct dwarf_section
*section
,
8969 void *file ATTRIBUTE_UNUSED
)
8971 unsigned char *start
= section
->start
;
8972 unsigned char *end
= start
+ section
->size
;
8973 unsigned char *section_start
= start
;
8974 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8975 Frame_Chunk
*remembered_state
= NULL
;
8977 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8978 unsigned int max_regs
= 0;
8979 const char *bad_reg
= _("bad register: ");
8980 unsigned int saved_eh_addr_size
= eh_addr_size
;
8982 introduce (section
, false);
8986 unsigned char *saved_start
;
8987 unsigned char *block_end
;
8992 int need_col_headers
= 1;
8993 unsigned char *augmentation_data
= NULL
;
8994 uint64_t augmentation_data_len
= 0;
8995 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8996 unsigned int offset_size
;
8998 static Frame_Chunk fde_fc
;
9000 saved_start
= start
;
9002 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
9006 printf ("\n%08tx ZERO terminator\n\n",
9007 saved_start
- section_start
);
9008 /* Skip any zero terminators that directly follow.
9009 A corrupt section size could have loaded a whole
9010 slew of zero filled memory bytes. eg
9011 PR 17512: file: 070-19381-0.004. */
9012 while (start
< end
&& * start
== 0)
9017 if (length
== 0xffffffff)
9019 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
9025 if (length
> (size_t) (end
- start
))
9027 warn ("Invalid length %#" PRIx64
" in FDE at %#tx\n",
9028 length
, saved_start
- section_start
);
9032 block_end
= start
+ length
;
9034 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
9036 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
9037 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
9042 start
= read_cie (start
, block_end
, &cie
, &version
,
9043 &augmentation_data_len
, &augmentation_data
);
9044 /* PR 17512: file: 027-135133-0.005. */
9051 fc
->chunk_start
= saved_start
;
9052 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
9055 if (frame_need_space (fc
, mreg
) < 0)
9057 if (fc
->fde_encoding
)
9058 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9060 printf ("\n%08tx ", saved_start
- section_start
);
9061 print_hex (length
, fc
->ptr_size
);
9062 print_hex (cie_id
, offset_size
);
9064 if (do_debug_frames_interp
)
9066 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
9067 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
9072 printf (" Version: %d\n", version
);
9073 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9076 printf (" Pointer Size: %u\n", fc
->ptr_size
);
9077 printf (" Segment Size: %u\n", fc
->segment_size
);
9079 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9080 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9081 printf (" Return address column: %d\n", fc
->ra
);
9083 if (augmentation_data_len
)
9084 display_augmentation_data (augmentation_data
, augmentation_data_len
);
9091 unsigned char *look_for
;
9092 unsigned long segment_selector
;
9098 uint64_t sign
= (uint64_t) 1 << (offset_size
* 8 - 1);
9099 cie_off
= (cie_off
^ sign
) - sign
;
9100 cie_off
= start
- 4 - section_start
- cie_off
;
9103 look_for
= section_start
+ cie_off
;
9104 if (cie_off
<= (size_t) (saved_start
- section_start
))
9106 for (cie
= chunks
; cie
; cie
= cie
->next
)
9107 if (cie
->chunk_start
== look_for
)
9110 else if (cie_off
>= section
->size
)
9114 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
9115 if (cie
->chunk_start
== look_for
)
9119 unsigned int off_size
;
9120 unsigned char *cie_scan
;
9122 cie_scan
= look_for
;
9124 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
9125 if (length
== 0xffffffff)
9127 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
9130 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
9133 unsigned char *cie_end
= cie_scan
+ length
;
9135 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
9139 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
9140 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
9145 read_cie (cie_scan
, cie_end
, &cie
, &version
,
9146 &augmentation_data_len
, &augmentation_data
);
9147 /* PR 17512: file: 3450-2098-0.004. */
9150 warn (_("Failed to read CIE information\n"));
9153 cie
->next
= forward_refs
;
9155 cie
->chunk_start
= look_for
;
9156 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
9159 if (frame_need_space (cie
, mreg
) < 0)
9161 warn (_("Invalid max register\n"));
9164 if (cie
->fde_encoding
)
9166 = size_of_encoded_value (cie
->fde_encoding
);
9173 memset (fc
, 0, sizeof (Frame_Chunk
));
9178 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
9179 fc
->col_offset
= (int *) xmalloc (sizeof (int));
9180 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
9182 warn (_("Invalid max register\n"));
9186 fc
->augmentation
= "";
9187 fc
->fde_encoding
= 0;
9188 fc
->ptr_size
= eh_addr_size
;
9189 fc
->segment_size
= 0;
9193 fc
->ncols
= cie
->ncols
;
9194 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
9195 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
9196 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9197 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9198 fc
->augmentation
= cie
->augmentation
;
9199 fc
->ptr_size
= cie
->ptr_size
;
9200 eh_addr_size
= cie
->ptr_size
;
9201 fc
->segment_size
= cie
->segment_size
;
9202 fc
->code_factor
= cie
->code_factor
;
9203 fc
->data_factor
= cie
->data_factor
;
9204 fc
->cfa_reg
= cie
->cfa_reg
;
9205 fc
->cfa_offset
= cie
->cfa_offset
;
9207 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
9209 warn (_("Invalid max register\n"));
9212 fc
->fde_encoding
= cie
->fde_encoding
;
9215 if (fc
->fde_encoding
)
9216 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9218 segment_selector
= 0;
9219 if (fc
->segment_size
)
9221 if (fc
->segment_size
> sizeof (segment_selector
))
9223 /* PR 17512: file: 9e196b3e. */
9224 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
9225 fc
->segment_size
= 4;
9227 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
9228 fc
->segment_size
, block_end
);
9231 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9234 /* FIXME: It appears that sometimes the final pc_range value is
9235 encoded in less than encoded_ptr_size bytes. See the x86_64
9236 run of the "objcopy on compressed debug sections" test for an
9238 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
9241 if (cie
->augmentation
[0] == 'z')
9243 READ_ULEB (augmentation_data_len
, start
, block_end
);
9244 augmentation_data
= start
;
9245 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
9246 if (augmentation_data_len
> (size_t) (block_end
- start
))
9248 warn (_("Augmentation data too long: %#" PRIx64
", "
9249 "expected at most %#tx\n"),
9250 augmentation_data_len
, block_end
- start
);
9252 augmentation_data
= NULL
;
9253 augmentation_data_len
= 0;
9255 start
+= augmentation_data_len
;
9258 printf ("\n%08tx ", saved_start
- section_start
);
9259 print_hex (length
, fc
->ptr_size
);
9260 print_hex (cie_id
, offset_size
);
9263 if (cie
->chunk_start
)
9264 printf ("cie=%08tx", cie
->chunk_start
- section_start
);
9266 /* Ideally translate "invalid " to 8 chars, trailing space
9268 printf (_("cie=invalid "));
9271 if (fc
->segment_size
)
9272 printf ("%04lx:", segment_selector
);
9274 print_hex_ns (fc
->pc_begin
, fc
->ptr_size
);
9276 print_hex_ns (fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
);
9279 if (! do_debug_frames_interp
&& augmentation_data_len
)
9281 display_augmentation_data (augmentation_data
, augmentation_data_len
);
9286 /* At this point, fc is the current chunk, cie (if any) is set, and
9287 we're about to interpret instructions for the chunk. */
9288 /* ??? At present we need to do this always, since this sizes the
9289 fc->col_type and fc->col_offset arrays, which we write into always.
9290 We should probably split the interpreted and non-interpreted bits
9291 into two different routines, since there's so much that doesn't
9292 really overlap between them. */
9293 if (1 || do_debug_frames_interp
)
9295 /* Start by making a pass over the chunk, allocating storage
9296 and taking note of what registers are used. */
9297 unsigned char *tmp
= start
;
9299 while (start
< block_end
)
9301 unsigned int reg
, op
, opa
;
9309 /* Warning: if you add any more cases to this switch, be
9310 sure to add them to the corresponding switch below. */
9314 case DW_CFA_advance_loc
:
9317 SKIP_ULEB (start
, block_end
);
9320 case DW_CFA_restore
:
9323 case DW_CFA_set_loc
:
9324 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
9327 start
+= encoded_ptr_size
;
9329 case DW_CFA_advance_loc1
:
9330 if ((size_t) (block_end
- start
) < 1)
9335 case DW_CFA_advance_loc2
:
9336 if ((size_t) (block_end
- start
) < 2)
9341 case DW_CFA_advance_loc4
:
9342 if ((size_t) (block_end
- start
) < 4)
9347 case DW_CFA_offset_extended
:
9348 case DW_CFA_val_offset
:
9349 READ_ULEB (reg
, start
, block_end
);
9350 SKIP_ULEB (start
, block_end
);
9352 case DW_CFA_restore_extended
:
9353 READ_ULEB (reg
, start
, block_end
);
9355 case DW_CFA_undefined
:
9356 READ_ULEB (reg
, start
, block_end
);
9358 case DW_CFA_same_value
:
9359 READ_ULEB (reg
, start
, block_end
);
9361 case DW_CFA_register
:
9362 READ_ULEB (reg
, start
, block_end
);
9363 SKIP_ULEB (start
, block_end
);
9365 case DW_CFA_def_cfa
:
9366 SKIP_ULEB (start
, block_end
);
9367 SKIP_ULEB (start
, block_end
);
9369 case DW_CFA_def_cfa_register
:
9370 SKIP_ULEB (start
, block_end
);
9372 case DW_CFA_def_cfa_offset
:
9373 SKIP_ULEB (start
, block_end
);
9375 case DW_CFA_def_cfa_expression
:
9376 READ_ULEB (temp
, start
, block_end
);
9377 if ((size_t) (block_end
- start
) < temp
)
9382 case DW_CFA_expression
:
9383 case DW_CFA_val_expression
:
9384 READ_ULEB (reg
, start
, block_end
);
9385 READ_ULEB (temp
, start
, block_end
);
9386 if ((size_t) (block_end
- start
) < temp
)
9391 case DW_CFA_offset_extended_sf
:
9392 case DW_CFA_val_offset_sf
:
9393 READ_ULEB (reg
, start
, block_end
);
9394 SKIP_SLEB (start
, block_end
);
9396 case DW_CFA_def_cfa_sf
:
9397 SKIP_ULEB (start
, block_end
);
9398 SKIP_SLEB (start
, block_end
);
9400 case DW_CFA_def_cfa_offset_sf
:
9401 SKIP_SLEB (start
, block_end
);
9403 case DW_CFA_MIPS_advance_loc8
:
9404 if ((size_t) (block_end
- start
) < 8)
9409 case DW_CFA_GNU_args_size
:
9410 SKIP_ULEB (start
, block_end
);
9412 case DW_CFA_GNU_negative_offset_extended
:
9413 READ_ULEB (reg
, start
, block_end
);
9414 SKIP_ULEB (start
, block_end
);
9419 if (reg
!= -1u && frame_need_space (fc
, reg
) >= 0)
9421 /* Don't leave any reg as DW_CFA_unreferenced so
9422 that frame_display_row prints name of regs in
9423 header, and all referenced regs in each line. */
9424 if (reg
>= cie
->ncols
9425 || cie
->col_type
[reg
] == DW_CFA_unreferenced
)
9426 fc
->col_type
[reg
] = DW_CFA_undefined
;
9428 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9436 /* Now we know what registers are used, make a second pass over
9437 the chunk, this time actually printing out the info. */
9439 while (start
< block_end
)
9442 unsigned long ul
, roffs
;
9443 /* Note: It is tempting to use an unsigned long for 'reg' but there
9444 are various functions, notably frame_space_needed() that assume that
9445 reg is an unsigned int. */
9450 const char *reg_prefix
= "";
9457 /* Make a note if something other than DW_CFA_nop happens. */
9458 if (op
!= DW_CFA_nop
)
9461 /* Warning: if you add any more cases to this switch, be
9462 sure to add them to the corresponding switch above. */
9465 case DW_CFA_advance_loc
:
9466 if (do_debug_frames_interp
)
9467 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9470 printf (" DW_CFA_advance_loc: %d to ",
9471 opa
* fc
->code_factor
);
9472 print_hex_ns (fc
->pc_begin
+ opa
* fc
->code_factor
,
9476 fc
->pc_begin
+= opa
* fc
->code_factor
;
9480 READ_ULEB (roffs
, start
, block_end
);
9481 if (opa
>= fc
->ncols
)
9482 reg_prefix
= bad_reg
;
9483 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9484 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9485 reg_prefix
, regname (opa
, 0),
9486 roffs
* fc
->data_factor
);
9487 if (*reg_prefix
== '\0')
9489 fc
->col_type
[opa
] = DW_CFA_offset
;
9490 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9494 case DW_CFA_restore
:
9495 if (opa
>= fc
->ncols
)
9496 reg_prefix
= bad_reg
;
9497 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9498 printf (" DW_CFA_restore: %s%s\n",
9499 reg_prefix
, regname (opa
, 0));
9500 if (*reg_prefix
!= '\0')
9503 if (opa
>= cie
->ncols
9504 || cie
->col_type
[opa
] == DW_CFA_unreferenced
)
9506 fc
->col_type
[opa
] = DW_CFA_undefined
;
9507 fc
->col_offset
[opa
] = 0;
9511 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9512 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9516 case DW_CFA_set_loc
:
9517 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9519 if (do_debug_frames_interp
)
9520 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9523 printf (" DW_CFA_set_loc: ");
9524 print_hex_ns (vma
, fc
->ptr_size
);
9530 case DW_CFA_advance_loc1
:
9531 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9532 if (do_debug_frames_interp
)
9533 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9536 printf (" DW_CFA_advance_loc1: %" PRId64
" to ",
9537 ofs
* fc
->code_factor
);
9538 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9542 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9545 case DW_CFA_advance_loc2
:
9546 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9547 if (do_debug_frames_interp
)
9548 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9551 printf (" DW_CFA_advance_loc2: %" PRId64
" to ",
9552 ofs
* fc
->code_factor
);
9553 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9557 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9560 case DW_CFA_advance_loc4
:
9561 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9562 if (do_debug_frames_interp
)
9563 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9566 printf (" DW_CFA_advance_loc4: %" PRId64
" to ",
9567 ofs
* fc
->code_factor
);
9568 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9572 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9575 case DW_CFA_offset_extended
:
9576 READ_ULEB (reg
, start
, block_end
);
9577 READ_ULEB (roffs
, start
, block_end
);
9578 if (reg
>= fc
->ncols
)
9579 reg_prefix
= bad_reg
;
9580 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9581 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9582 reg_prefix
, regname (reg
, 0),
9583 roffs
* fc
->data_factor
);
9584 if (*reg_prefix
== '\0')
9586 fc
->col_type
[reg
] = DW_CFA_offset
;
9587 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9591 case DW_CFA_val_offset
:
9592 READ_ULEB (reg
, start
, block_end
);
9593 READ_ULEB (roffs
, start
, block_end
);
9594 if (reg
>= fc
->ncols
)
9595 reg_prefix
= bad_reg
;
9596 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9597 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9598 reg_prefix
, regname (reg
, 0),
9599 roffs
* fc
->data_factor
);
9600 if (*reg_prefix
== '\0')
9602 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9603 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9607 case DW_CFA_restore_extended
:
9608 READ_ULEB (reg
, start
, block_end
);
9609 if (reg
>= fc
->ncols
)
9610 reg_prefix
= bad_reg
;
9611 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9612 printf (" DW_CFA_restore_extended: %s%s\n",
9613 reg_prefix
, regname (reg
, 0));
9614 if (*reg_prefix
!= '\0')
9617 if (reg
>= cie
->ncols
9618 || cie
->col_type
[reg
] == DW_CFA_unreferenced
)
9620 fc
->col_type
[reg
] = DW_CFA_undefined
;
9621 fc
->col_offset
[reg
] = 0;
9625 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9626 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9630 case DW_CFA_undefined
:
9631 READ_ULEB (reg
, start
, block_end
);
9632 if (reg
>= fc
->ncols
)
9633 reg_prefix
= bad_reg
;
9634 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9635 printf (" DW_CFA_undefined: %s%s\n",
9636 reg_prefix
, regname (reg
, 0));
9637 if (*reg_prefix
== '\0')
9639 fc
->col_type
[reg
] = DW_CFA_undefined
;
9640 fc
->col_offset
[reg
] = 0;
9644 case DW_CFA_same_value
:
9645 READ_ULEB (reg
, start
, block_end
);
9646 if (reg
>= fc
->ncols
)
9647 reg_prefix
= bad_reg
;
9648 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9649 printf (" DW_CFA_same_value: %s%s\n",
9650 reg_prefix
, regname (reg
, 0));
9651 if (*reg_prefix
== '\0')
9653 fc
->col_type
[reg
] = DW_CFA_same_value
;
9654 fc
->col_offset
[reg
] = 0;
9658 case DW_CFA_register
:
9659 READ_ULEB (reg
, start
, block_end
);
9660 READ_ULEB (roffs
, start
, block_end
);
9661 if (reg
>= fc
->ncols
)
9662 reg_prefix
= bad_reg
;
9663 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9665 printf (" DW_CFA_register: %s%s in ",
9666 reg_prefix
, regname (reg
, 0));
9667 puts (regname (roffs
, 0));
9669 if (*reg_prefix
== '\0')
9671 fc
->col_type
[reg
] = DW_CFA_register
;
9672 fc
->col_offset
[reg
] = roffs
;
9676 case DW_CFA_remember_state
:
9677 if (! do_debug_frames_interp
)
9678 printf (" DW_CFA_remember_state\n");
9679 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9680 rs
->cfa_offset
= fc
->cfa_offset
;
9681 rs
->cfa_reg
= fc
->cfa_reg
;
9683 rs
->cfa_exp
= fc
->cfa_exp
;
9684 rs
->ncols
= fc
->ncols
;
9685 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9686 sizeof (* rs
->col_type
));
9687 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9688 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9689 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9690 rs
->next
= remembered_state
;
9691 remembered_state
= rs
;
9694 case DW_CFA_restore_state
:
9695 if (! do_debug_frames_interp
)
9696 printf (" DW_CFA_restore_state\n");
9697 rs
= remembered_state
;
9700 remembered_state
= rs
->next
;
9701 fc
->cfa_offset
= rs
->cfa_offset
;
9702 fc
->cfa_reg
= rs
->cfa_reg
;
9704 fc
->cfa_exp
= rs
->cfa_exp
;
9705 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9707 warn (_("Invalid column number in saved frame state\n"));
9711 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9712 memcpy (fc
->col_offset
, rs
->col_offset
,
9713 rs
->ncols
* sizeof (* rs
->col_offset
));
9714 free (rs
->col_type
);
9715 free (rs
->col_offset
);
9718 else if (do_debug_frames_interp
)
9719 printf ("Mismatched DW_CFA_restore_state\n");
9722 case DW_CFA_def_cfa
:
9723 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9724 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9726 if (! do_debug_frames_interp
)
9727 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9728 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9731 case DW_CFA_def_cfa_register
:
9732 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9734 if (! do_debug_frames_interp
)
9735 printf (" DW_CFA_def_cfa_register: %s\n",
9736 regname (fc
->cfa_reg
, 0));
9739 case DW_CFA_def_cfa_offset
:
9740 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9741 if (! do_debug_frames_interp
)
9742 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9746 if (! do_debug_frames_interp
)
9747 printf (" DW_CFA_nop\n");
9750 case DW_CFA_def_cfa_expression
:
9751 READ_ULEB (ul
, start
, block_end
);
9752 if (ul
> (size_t) (block_end
- start
))
9754 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9757 if (! do_debug_frames_interp
)
9759 printf (" DW_CFA_def_cfa_expression (");
9760 decode_location_expression (start
, eh_addr_size
, 0, -1,
9768 case DW_CFA_expression
:
9769 READ_ULEB (reg
, start
, block_end
);
9770 READ_ULEB (ul
, start
, block_end
);
9771 if (reg
>= fc
->ncols
)
9772 reg_prefix
= bad_reg
;
9773 /* PR 17512: file: 069-133014-0.006. */
9774 /* PR 17512: file: 98c02eb4. */
9775 if (ul
> (size_t) (block_end
- start
))
9777 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9780 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9782 printf (" DW_CFA_expression: %s%s (",
9783 reg_prefix
, regname (reg
, 0));
9784 decode_location_expression (start
, eh_addr_size
, 0, -1,
9788 if (*reg_prefix
== '\0')
9789 fc
->col_type
[reg
] = DW_CFA_expression
;
9793 case DW_CFA_val_expression
:
9794 READ_ULEB (reg
, start
, block_end
);
9795 READ_ULEB (ul
, start
, block_end
);
9796 if (reg
>= fc
->ncols
)
9797 reg_prefix
= bad_reg
;
9798 if (ul
> (size_t) (block_end
- start
))
9800 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9803 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9805 printf (" DW_CFA_val_expression: %s%s (",
9806 reg_prefix
, regname (reg
, 0));
9807 decode_location_expression (start
, eh_addr_size
, 0, -1,
9811 if (*reg_prefix
== '\0')
9812 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9816 case DW_CFA_offset_extended_sf
:
9817 READ_ULEB (reg
, start
, block_end
);
9818 READ_SLEB (l
, start
, block_end
);
9819 if (reg
>= fc
->ncols
)
9820 reg_prefix
= bad_reg
;
9821 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9822 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+" PRId64
"\n",
9823 reg_prefix
, regname (reg
, 0),
9824 l
* fc
->data_factor
);
9825 if (*reg_prefix
== '\0')
9827 fc
->col_type
[reg
] = DW_CFA_offset
;
9828 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9832 case DW_CFA_val_offset_sf
:
9833 READ_ULEB (reg
, start
, block_end
);
9834 READ_SLEB (l
, start
, block_end
);
9835 if (reg
>= fc
->ncols
)
9836 reg_prefix
= bad_reg
;
9837 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9838 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+" PRId64
"\n",
9839 reg_prefix
, regname (reg
, 0),
9840 l
* fc
->data_factor
);
9841 if (*reg_prefix
== '\0')
9843 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9844 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9848 case DW_CFA_def_cfa_sf
:
9849 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9850 READ_SLEB (l
, start
, block_end
);
9851 l
*= fc
->data_factor
;
9854 if (! do_debug_frames_interp
)
9855 printf (" DW_CFA_def_cfa_sf: %s ofs %" PRId64
"\n",
9856 regname (fc
->cfa_reg
, 0), l
);
9859 case DW_CFA_def_cfa_offset_sf
:
9860 READ_SLEB (l
, start
, block_end
);
9861 l
*= fc
->data_factor
;
9863 if (! do_debug_frames_interp
)
9864 printf (" DW_CFA_def_cfa_offset_sf: %" PRId64
"\n", l
);
9867 case DW_CFA_MIPS_advance_loc8
:
9868 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9869 if (do_debug_frames_interp
)
9870 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9873 printf (" DW_CFA_MIPS_advance_loc8: %" PRId64
" to ",
9874 ofs
* fc
->code_factor
);
9875 print_hex_ns (fc
->pc_begin
+ ofs
* fc
->code_factor
,
9879 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9882 case DW_CFA_GNU_window_save
:
9883 if (! do_debug_frames_interp
)
9884 printf (" %s\n", DW_CFA_GNU_window_save_name
[is_aarch64
]);
9887 case DW_CFA_GNU_args_size
:
9888 READ_ULEB (ul
, start
, block_end
);
9889 if (! do_debug_frames_interp
)
9890 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9893 case DW_CFA_GNU_negative_offset_extended
:
9894 READ_ULEB (reg
, start
, block_end
);
9895 READ_SLEB (l
, start
, block_end
);
9897 if (reg
>= fc
->ncols
)
9898 reg_prefix
= bad_reg
;
9899 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9900 printf (" DW_CFA_GNU_negative_offset_extended: %s%s "
9901 "at cfa%+" PRId64
"\n",
9902 reg_prefix
, regname (reg
, 0),
9903 l
* fc
->data_factor
);
9904 if (*reg_prefix
== '\0')
9906 fc
->col_type
[reg
] = DW_CFA_offset
;
9907 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9912 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9913 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9915 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9920 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9921 if (do_debug_frames_interp
&& ! all_nops
)
9922 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9924 if (fde_fc
.col_type
!= NULL
)
9926 free (fde_fc
.col_type
);
9927 fde_fc
.col_type
= NULL
;
9929 if (fde_fc
.col_offset
!= NULL
)
9931 free (fde_fc
.col_offset
);
9932 fde_fc
.col_offset
= NULL
;
9936 eh_addr_size
= saved_eh_addr_size
;
9941 while (remembered_state
!= NULL
)
9943 rs
= remembered_state
;
9944 remembered_state
= rs
->next
;
9945 free (rs
->col_type
);
9946 free (rs
->col_offset
);
9947 rs
->next
= NULL
; /* Paranoia. */
9951 while (chunks
!= NULL
)
9955 free (rs
->col_type
);
9956 free (rs
->col_offset
);
9957 rs
->next
= NULL
; /* Paranoia. */
9961 while (forward_refs
!= NULL
)
9964 forward_refs
= rs
->next
;
9965 free (rs
->col_type
);
9966 free (rs
->col_offset
);
9967 rs
->next
= NULL
; /* Paranoia. */
9977 display_debug_names (struct dwarf_section
*section
, void *file
)
9979 unsigned char *hdrptr
= section
->start
;
9980 uint64_t unit_length
;
9981 unsigned char *unit_start
;
9982 const unsigned char *const section_end
= section
->start
+ section
->size
;
9983 unsigned char *unit_end
;
9985 introduce (section
, false);
9987 load_debug_section_with_follow (str
, file
);
9989 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9991 unsigned int offset_size
;
9992 uint16_t dwarf_version
, padding
;
9993 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9994 uint64_t bucket_count
, name_count
, abbrev_table_size
;
9995 uint32_t augmentation_string_size
;
9997 bool augmentation_printable
;
9998 const char *augmentation_string
;
10001 unit_start
= hdrptr
;
10003 /* Get and check the length of the block. */
10004 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
10006 if (unit_length
== 0xffffffff)
10008 /* This section is 64-bit DWARF. */
10009 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
10015 if (unit_length
> (size_t) (section_end
- hdrptr
)
10016 || unit_length
< 2 + 2 + 4 * 7)
10019 warn (_("Debug info is corrupted, %s header at %#tx"
10020 " has length %#" PRIx64
"\n"),
10021 section
->name
, unit_start
- section
->start
, unit_length
);
10024 unit_end
= hdrptr
+ unit_length
;
10026 /* Get and check the version number. */
10027 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
10028 printf (_("Version %d\n"), (int) dwarf_version
);
10030 /* Prior versions did not exist, and future versions may not be
10031 backwards compatible. */
10032 if (dwarf_version
!= 5)
10034 warn (_("Only DWARF version 5 .debug_names "
10035 "is currently supported.\n"));
10039 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
10041 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
10044 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
10045 if (comp_unit_count
== 0)
10046 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
10048 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
10049 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
10050 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
10051 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
10052 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
10054 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
10055 if (augmentation_string_size
% 4 != 0)
10057 warn (_("Augmentation string length %u must be rounded up "
10058 "to a multiple of 4 in .debug_names.\n"),
10059 augmentation_string_size
);
10060 augmentation_string_size
+= (-augmentation_string_size
) & 3;
10062 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
10065 printf (_("Augmentation string:"));
10067 augmentation_printable
= true;
10068 augmentation_string
= (const char *) hdrptr
;
10070 for (i
= 0; i
< augmentation_string_size
; i
++)
10074 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
10075 printf (" %02x", uc
);
10077 if (uc
!= 0 && !ISPRINT (uc
))
10078 augmentation_printable
= false;
10081 if (augmentation_printable
)
10085 i
< augmentation_string_size
&& augmentation_string
[i
];
10087 putchar (augmentation_string
[i
]);
10092 printf (_("CU table:\n"));
10093 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
10094 || total
> (size_t) (unit_end
- hdrptr
))
10096 for (i
= 0; i
< comp_unit_count
; i
++)
10098 uint64_t cu_offset
;
10100 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
10101 printf ("[%3u] %#" PRIx64
"\n", i
, cu_offset
);
10105 printf (_("TU table:\n"));
10106 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
10107 || total
> (size_t) (unit_end
- hdrptr
))
10109 for (i
= 0; i
< local_type_unit_count
; i
++)
10111 uint64_t tu_offset
;
10113 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
10114 printf ("[%3u] %#" PRIx64
"\n", i
, tu_offset
);
10118 printf (_("Foreign TU table:\n"));
10119 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
10120 || total
> (size_t) (unit_end
- hdrptr
))
10122 for (i
= 0; i
< foreign_type_unit_count
; i
++)
10124 uint64_t signature
;
10126 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
10127 printf (_("[%3u] "), i
);
10128 print_hex_ns (signature
, 8);
10133 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
10134 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
10135 + abbrev_table_size
);
10136 if (xtra
> (size_t) (unit_end
- hdrptr
))
10138 warn (_("Entry pool offset (%#" PRIx64
") exceeds unit size %#tx "
10139 "for unit %#tx in the debug_names\n"),
10140 xtra
, unit_end
- unit_start
, unit_start
- section
->start
);
10143 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
10144 hdrptr
+= bucket_count
* sizeof (uint32_t);
10145 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
10146 hdrptr
+= name_count
* sizeof (uint32_t);
10147 unsigned char *const name_table_string_offsets
= hdrptr
;
10148 hdrptr
+= name_count
* offset_size
;
10149 unsigned char *const name_table_entry_offsets
= hdrptr
;
10150 hdrptr
+= name_count
* offset_size
;
10151 unsigned char *const abbrev_table
= hdrptr
;
10152 hdrptr
+= abbrev_table_size
;
10153 const unsigned char *const abbrev_table_end
= hdrptr
;
10154 unsigned char *const entry_pool
= hdrptr
;
10156 size_t buckets_filled
= 0;
10158 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
10160 const uint32_t bucket
= hash_table_buckets
[bucketi
];
10165 printf (ngettext ("Used %zu of %lu bucket.\n",
10166 "Used %zu of %lu buckets.\n",
10167 (unsigned long) bucket_count
),
10168 buckets_filled
, (unsigned long) bucket_count
);
10170 if (bucket_count
!= 0)
10172 uint32_t hash_prev
= 0;
10173 size_t hash_clash_count
= 0;
10174 size_t longest_clash
= 0;
10175 size_t this_length
= 0;
10177 for (hashi
= 0; hashi
< name_count
; hashi
++)
10179 const uint32_t hash_this
= hash_table_hashes
[hashi
];
10183 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
10185 ++hash_clash_count
;
10187 longest_clash
= MAX (longest_clash
, this_length
);
10192 hash_prev
= hash_this
;
10194 printf (_("Out of %" PRIu64
" items there are %zu bucket clashes"
10195 " (longest of %zu entries).\n"),
10196 name_count
, hash_clash_count
, longest_clash
);
10198 if (name_count
!= buckets_filled
+ hash_clash_count
)
10199 warn (_("The name_count (%" PRIu64
")"
10200 " is not the same as the used bucket_count"
10201 " (%zu) + the hash clash count (%zu)"),
10202 name_count
, buckets_filled
, hash_clash_count
);
10205 struct abbrev_lookup_entry
10207 uint64_t abbrev_tag
;
10208 unsigned char *abbrev_lookup_ptr
;
10210 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
10211 size_t abbrev_lookup_used
= 0;
10212 size_t abbrev_lookup_allocated
= 0;
10214 unsigned char *abbrevptr
= abbrev_table
;
10217 uint64_t abbrev_tag
;
10219 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
10220 if (abbrev_tag
== 0)
10222 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
10224 abbrev_lookup_allocated
= MAX (0x100,
10225 abbrev_lookup_allocated
* 2);
10226 abbrev_lookup
= xrealloc (abbrev_lookup
,
10227 (abbrev_lookup_allocated
10228 * sizeof (*abbrev_lookup
)));
10230 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
10231 struct abbrev_lookup_entry
*entry
;
10232 for (entry
= abbrev_lookup
;
10233 entry
< abbrev_lookup
+ abbrev_lookup_used
;
10235 if (entry
->abbrev_tag
== abbrev_tag
)
10237 warn (_("Duplicate abbreviation tag %" PRIu64
10238 " in unit %#tx in the debug_names section\n"),
10239 abbrev_tag
, unit_start
- section
->start
);
10242 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
10243 entry
->abbrev_tag
= abbrev_tag
;
10244 entry
->abbrev_lookup_ptr
= abbrevptr
;
10246 /* Skip DWARF tag. */
10247 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
10250 uint64_t xindex
, form
;
10252 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
10253 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
10254 if (xindex
== 0 && form
== 0)
10259 printf (_("\nSymbol table:\n"));
10261 for (namei
= 0; namei
< name_count
; ++namei
)
10263 uint64_t string_offset
, entry_offset
;
10266 p
= name_table_string_offsets
+ namei
* offset_size
;
10267 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
10268 p
= name_table_entry_offsets
+ namei
* offset_size
;
10269 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
10271 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
10272 fetch_indirect_string (string_offset
));
10274 unsigned char *entryptr
= entry_pool
+ entry_offset
;
10276 /* We need to scan first whether there is a single or multiple
10277 entries. TAGNO is -2 for the first entry, it is -1 for the
10278 initial tag read of the second entry, then it becomes 0 for the
10279 first entry for real printing etc. */
10281 /* Initialize it due to a false compiler warning. */
10282 uint64_t second_abbrev_tag
= -1;
10285 uint64_t abbrev_tag
;
10286 uint64_t dwarf_tag
;
10287 const struct abbrev_lookup_entry
*entry
;
10289 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
10292 second_abbrev_tag
= abbrev_tag
;
10294 entryptr
= entry_pool
+ entry_offset
;
10297 if (abbrev_tag
== 0)
10300 printf ("%s<%" PRIu64
">",
10301 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
10304 for (entry
= abbrev_lookup
;
10305 entry
< abbrev_lookup
+ abbrev_lookup_used
;
10307 if (entry
->abbrev_tag
== abbrev_tag
)
10309 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
10311 warn (_("Undefined abbreviation tag %" PRId64
10312 " in unit %#tx in the debug_names section\n"),
10314 unit_start
- section
->start
);
10317 abbrevptr
= entry
->abbrev_lookup_ptr
;
10318 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
10320 printf (" %s", get_TAG_name (dwarf_tag
));
10323 uint64_t xindex
, form
;
10325 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
10326 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
10327 if (xindex
== 0 && form
== 0)
10331 printf (" %s", get_IDX_name (xindex
));
10332 entryptr
= read_and_display_attr_value (0, form
, 0,
10333 unit_start
, entryptr
, unit_end
,
10335 dwarf_version
, NULL
,
10336 (tagno
< 0), section
,
10342 printf (_(" <no entries>"));
10346 free (abbrev_lookup
);
10353 display_debug_links (struct dwarf_section
* section
,
10354 void * file ATTRIBUTE_UNUSED
)
10356 const unsigned char * filename
;
10357 unsigned int filelen
;
10359 introduce (section
, false);
10361 /* The .gnu_debuglink section is formatted as:
10362 (c-string) Filename.
10363 (padding) If needed to reach a 4 byte boundary.
10364 (uint32_t) CRC32 value.
10366 The .gun_debugaltlink section is formatted as:
10367 (c-string) Filename.
10368 (binary) Build-ID. */
10370 filename
= section
->start
;
10371 filelen
= strnlen ((const char *) filename
, section
->size
);
10372 if (filelen
== section
->size
)
10374 warn (_("The debuglink filename is corrupt/missing\n"));
10378 printf (_(" Separate debug info file: %s\n"), filename
);
10380 if (startswith (section
->name
, ".gnu_debuglink"))
10382 unsigned int crc32
;
10383 unsigned int crc_offset
;
10385 crc_offset
= filelen
+ 1;
10386 crc_offset
= (crc_offset
+ 3) & ~3;
10387 if (crc_offset
+ 4 > section
->size
)
10389 warn (_("CRC offset missing/truncated\n"));
10393 crc32
= byte_get (filename
+ crc_offset
, 4);
10395 printf (_(" CRC value: %#x\n"), crc32
);
10397 if (crc_offset
+ 4 < section
->size
)
10399 warn (_("There are %#" PRIx64
10400 " extraneous bytes at the end of the section\n"),
10401 section
->size
- (crc_offset
+ 4));
10405 else /* startswith (section->name, ".gnu_debugaltlink") */
10407 const unsigned char *build_id
= section
->start
+ filelen
+ 1;
10408 size_t build_id_len
= section
->size
- (filelen
+ 1);
10411 /* FIXME: Should we support smaller build-id notes ? */
10412 if (build_id_len
< 0x14)
10414 warn (_("Build-ID is too short (%#zx bytes)\n"), build_id_len
);
10418 printed
= printf (_(" Build-ID (%#zx bytes):"), build_id_len
);
10419 display_data (printed
, build_id
, build_id_len
);
10428 display_gdb_index (struct dwarf_section
*section
,
10429 void *file ATTRIBUTE_UNUSED
)
10431 unsigned char *start
= section
->start
;
10433 uint32_t cu_list_offset
, tu_list_offset
;
10434 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10435 unsigned int cu_list_elements
, tu_list_elements
;
10436 unsigned int address_table_elements
, symbol_table_slots
;
10437 unsigned char *cu_list
, *tu_list
;
10438 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10441 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10443 introduce (section
, false);
10445 if (section
->size
< 6 * sizeof (uint32_t))
10447 warn (_("Truncated header in the %s section.\n"), section
->name
);
10451 version
= byte_get_little_endian (start
, 4);
10452 printf (_("Version %lu\n"), (unsigned long) version
);
10454 /* Prior versions are obsolete, and future versions may not be
10455 backwards compatible. */
10456 if (version
< 3 || version
> 8)
10458 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10462 warn (_("The address table data in version 3 may be wrong.\n"));
10464 warn (_("Version 4 does not support case insensitive lookups.\n"));
10466 warn (_("Version 5 does not include inlined functions.\n"));
10468 warn (_("Version 6 does not include symbol attributes.\n"));
10469 /* Version 7 indices generated by Gold have bad type unit references,
10470 PR binutils/15021. But we don't know if the index was generated by
10471 Gold or not, so to avoid worrying users with gdb-generated indices
10472 we say nothing for version 7 here. */
10474 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10475 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10476 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10477 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10478 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10480 if (cu_list_offset
> section
->size
10481 || tu_list_offset
> section
->size
10482 || address_table_offset
> section
->size
10483 || symbol_table_offset
> section
->size
10484 || constant_pool_offset
> section
->size
10485 || tu_list_offset
< cu_list_offset
10486 || address_table_offset
< tu_list_offset
10487 || symbol_table_offset
< address_table_offset
10488 || constant_pool_offset
< symbol_table_offset
)
10490 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10494 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 16;
10495 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 24;
10496 address_table_elements
= (symbol_table_offset
- address_table_offset
) / 20;
10497 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10499 cu_list
= start
+ cu_list_offset
;
10500 tu_list
= start
+ tu_list_offset
;
10501 address_table
= start
+ address_table_offset
;
10502 symbol_table
= start
+ symbol_table_offset
;
10503 constant_pool
= start
+ constant_pool_offset
;
10505 printf (_("\nCU table:\n"));
10506 for (i
= 0; i
< cu_list_elements
; i
++)
10508 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 16, 8);
10509 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 16 + 8, 8);
10511 printf ("[%3u] %#" PRIx64
" - %#" PRIx64
"\n",
10512 i
, cu_offset
, cu_offset
+ cu_length
- 1);
10515 printf (_("\nTU table:\n"));
10516 for (i
= 0; i
< tu_list_elements
; i
++)
10518 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 24, 8);
10519 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 24 + 8, 8);
10520 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 24 + 16, 8);
10522 printf ("[%3u] %#" PRIx64
" %#" PRIx64
" ",
10523 i
, tu_offset
, type_offset
);
10524 print_hex_ns (signature
, 8);
10528 printf (_("\nAddress table:\n"));
10529 for (i
= 0; i
< address_table_elements
; i
++)
10531 uint64_t low
= byte_get_little_endian (address_table
+ i
* 20, 8);
10532 uint64_t high
= byte_get_little_endian (address_table
+ i
* 20 + 8, 8);
10533 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 20 + 16, 4);
10535 print_hex (low
, 8);
10536 print_hex (high
, 8);
10537 printf ("%" PRIu32
"\n", cu_index
);
10540 printf (_("\nSymbol table:\n"));
10541 for (i
= 0; i
< symbol_table_slots
; ++i
)
10543 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10544 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10545 uint32_t num_cus
, cu
;
10547 if (name_offset
!= 0
10548 || cu_vector_offset
!= 0)
10552 /* PR 17531: file: 5b7b07ad. */
10553 if (name_offset
>= section
->size
- constant_pool_offset
)
10555 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10556 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10560 printf ("[%3u] %.*s:", i
,
10561 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10562 constant_pool
+ name_offset
);
10564 if (section
->size
- constant_pool_offset
< 4
10565 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10567 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10568 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10569 cu_vector_offset
, i
);
10573 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10575 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10576 + cu_vector_offset
+ 4))
10578 printf ("<invalid number of CUs: %d>\n", num_cus
);
10579 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10587 for (j
= 0; j
< num_cus
; ++j
)
10590 gdb_index_symbol_kind kind
;
10592 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10593 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10594 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10595 cu
= GDB_INDEX_CU_VALUE (cu
);
10596 /* Convert to TU number if it's for a type unit. */
10597 if (cu
>= cu_list_elements
)
10598 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10599 (unsigned long) cu
- cu_list_elements
);
10601 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10603 printf (" [%s, %s]",
10604 is_static
? _("static") : _("global"),
10605 get_gdb_index_symbol_kind_name (kind
));
10617 /* Pre-allocate enough space for the CU/TU sets needed. */
10620 prealloc_cu_tu_list (unsigned int nshndx
)
10622 if (shndx_pool
== NULL
)
10624 shndx_pool_size
= nshndx
;
10625 shndx_pool_used
= 0;
10626 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10627 sizeof (unsigned int));
10631 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10632 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10633 sizeof (unsigned int));
10638 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10640 if (shndx_pool_used
>= shndx_pool_size
)
10642 error (_("Internal error: out of space in the shndx pool.\n"));
10645 shndx_pool
[shndx_pool_used
++] = shndx
;
10649 end_cu_tu_entry (void)
10651 if (shndx_pool_used
>= shndx_pool_size
)
10653 error (_("Internal error: out of space in the shndx pool.\n"));
10656 shndx_pool
[shndx_pool_used
++] = 0;
10659 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10661 static const char *
10662 get_DW_SECT_short_name (unsigned int dw_sect
)
10664 static char buf
[16];
10670 case DW_SECT_TYPES
:
10672 case DW_SECT_ABBREV
:
10678 case DW_SECT_STR_OFFSETS
:
10680 case DW_SECT_MACINFO
:
10682 case DW_SECT_MACRO
:
10688 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10692 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10693 These sections are extensions for Fission.
10694 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10697 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10699 unsigned char *phdr
= section
->start
;
10700 unsigned char *limit
= phdr
+ section
->size
;
10701 unsigned char *phash
;
10702 unsigned char *pindex
;
10703 unsigned char *ppool
;
10704 unsigned int version
;
10705 unsigned int ncols
= 0;
10706 unsigned int nused
;
10707 unsigned int nslots
;
10710 uint64_t signature
;
10713 /* PR 17512: file: 002-168123-0.004. */
10716 warn (_("Section %s is empty\n"), section
->name
);
10719 /* PR 17512: file: 002-376-0.004. */
10720 if (section
->size
< 24)
10722 warn (_("Section %s is too small to contain a CU/TU header\n"),
10728 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10730 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10731 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10732 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10734 pindex
= phash
+ (size_t) nslots
* 8;
10735 ppool
= pindex
+ (size_t) nslots
* 4;
10739 introduce (section
, false);
10741 printf (_(" Version: %u\n"), version
);
10743 printf (_(" Number of columns: %u\n"), ncols
);
10744 printf (_(" Number of used entries: %u\n"), nused
);
10745 printf (_(" Number of slots: %u\n\n"), nslots
);
10748 /* PR 17531: file: 45d69832. */
10749 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10750 || total
> (size_t) (limit
- phash
))
10752 warn (ngettext ("Section %s is too small for %u slot\n",
10753 "Section %s is too small for %u slots\n",
10755 section
->name
, nslots
);
10762 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10763 for (i
= 0; i
< nslots
; i
++)
10765 unsigned char *shndx_list
;
10766 unsigned int shndx
;
10768 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10769 if (signature
!= 0)
10771 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10772 shndx_list
= ppool
+ j
* 4;
10773 /* PR 17531: file: 705e010d. */
10774 if (shndx_list
< ppool
)
10776 warn (_("Section index pool located before start of section\n"));
10781 printf (_(" [%3d] Signature: %#" PRIx64
" Sections: "),
10785 if (shndx_list
>= limit
)
10787 warn (_("Section %s too small for shndx pool\n"),
10791 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10795 printf (" %d", shndx
);
10797 add_shndx_to_cu_tu_entry (shndx
);
10803 end_cu_tu_entry ();
10809 else if (version
== 2)
10812 unsigned int dw_sect
;
10813 unsigned char *ph
= phash
;
10814 unsigned char *pi
= pindex
;
10815 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10816 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10818 struct cu_tu_set
*this_set
= NULL
;
10820 unsigned char *prow
;
10823 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10825 /* PR 17531: file: 0dd159bf.
10826 Check for integer overflow (can occur when size_t is 32-bit)
10827 with overlarge ncols or nused values. */
10829 || _mul_overflow ((size_t) ncols
, 4, &temp
)
10830 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
10831 || total
> (size_t) (limit
- ppool
))
10833 warn (_("Section %s too small for offset and size tables\n"),
10840 printf (_(" Offset table\n"));
10841 printf (" slot %-16s ",
10842 is_tu_index
? _("signature") : _("dwo_id"));
10849 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10850 this_set
= tu_sets
;
10855 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10856 this_set
= cu_sets
;
10862 for (j
= 0; j
< ncols
; j
++)
10864 unsigned char *p
= ppool
+ j
* 4;
10865 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10866 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10871 for (i
= 0; i
< nslots
; i
++)
10873 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10875 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10878 /* PR 17531: file: a05f6ab3. */
10881 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10888 size_t num_copy
= sizeof (uint64_t);
10890 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10893 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10895 printf (" [%3d] %#" PRIx64
, i
, signature
);
10896 for (j
= 0; j
< ncols
; j
++)
10898 unsigned char *p
= prow
+ j
* 4;
10899 SAFE_BYTE_GET (val
, p
, 4, limit
);
10901 printf (" %8d", val
);
10905 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10907 /* PR 17531: file: 10796eb3. */
10908 if (dw_sect
>= DW_SECT_MAX
)
10909 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10911 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10927 printf (_(" Size table\n"));
10928 printf (" slot %-16s ",
10929 is_tu_index
? _("signature") : _("dwo_id"));
10932 for (j
= 0; j
< ncols
; j
++)
10934 unsigned char *p
= ppool
+ j
* 4;
10935 SAFE_BYTE_GET (val
, p
, 4, limit
);
10937 printf (" %8s", get_DW_SECT_short_name (val
));
10943 for (i
= 0; i
< nslots
; i
++)
10945 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10947 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10950 prow
= psizes
+ (row
- 1) * ncols
* 4;
10953 printf (" [%3d] %#" PRIx64
, i
, signature
);
10955 for (j
= 0; j
< ncols
; j
++)
10957 unsigned char *p
= prow
+ j
* 4;
10959 /* PR 28645: Check for overflow. Since we do not know how
10960 many populated rows there will be, we cannot just
10961 perform a single check at the start of this function. */
10962 if (p
> (limit
- 4))
10966 warn (_("Too many rows/columns in DWARF index section %s\n"),
10971 SAFE_BYTE_GET (val
, p
, 4, limit
);
10974 printf (" %8d", val
);
10978 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10979 if (dw_sect
>= DW_SECT_MAX
)
10980 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10982 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10994 else if (do_display
)
10995 printf (_(" Unsupported version (%d)\n"), version
);
11003 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
11005 /* Load the CU and TU indexes if present. This will build a list of
11006 section sets that we can use to associate a .debug_info.dwo section
11007 with its associated .debug_abbrev.dwo section in a .dwp file. */
11010 load_cu_tu_indexes (void *file
)
11012 /* If we have already loaded (or tried to load) the CU and TU indexes
11013 then do not bother to repeat the task. */
11014 if (cu_tu_indexes_read
== -1)
11016 cu_tu_indexes_read
= true;
11018 if (load_debug_section_with_follow (dwp_cu_index
, file
))
11019 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
11020 cu_tu_indexes_read
= false;
11022 if (load_debug_section_with_follow (dwp_tu_index
, file
))
11023 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
11024 cu_tu_indexes_read
= false;
11027 return (bool) cu_tu_indexes_read
;
11030 /* Find the set of sections that includes section SHNDX. */
11033 find_cu_tu_set (void *file
, unsigned int shndx
)
11037 if (! load_cu_tu_indexes (file
))
11040 /* Find SHNDX in the shndx pool. */
11041 for (i
= 0; i
< shndx_pool_used
; i
++)
11042 if (shndx_pool
[i
] == shndx
)
11045 if (i
>= shndx_pool_used
)
11048 /* Now backup to find the first entry in the set. */
11049 while (i
> 0 && shndx_pool
[i
- 1] != 0)
11052 return shndx_pool
+ i
;
11055 /* Display a .debug_cu_index or .debug_tu_index section. */
11058 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
11060 return process_cu_tu_index (section
, 1);
11064 display_debug_not_supported (struct dwarf_section
*section
,
11065 void *file ATTRIBUTE_UNUSED
)
11067 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11073 /* Like malloc, but takes two parameters like calloc.
11074 Verifies that the first parameter is not too large.
11075 Note: does *not* initialise the allocated memory to zero. */
11078 cmalloc (size_t nmemb
, size_t size
)
11080 /* Check for overflow. */
11081 if (nmemb
>= ~(size_t) 0 / size
)
11084 return xmalloc (nmemb
* size
);
11087 /* Like xmalloc, but takes two parameters like calloc.
11088 Verifies that the first parameter is not too large.
11089 Note: does *not* initialise the allocated memory to zero. */
11092 xcmalloc (size_t nmemb
, size_t size
)
11094 /* Check for overflow. */
11095 if (nmemb
>= ~(size_t) 0 / size
)
11098 _("Attempt to allocate an array with an excessive number of elements: %#zx\n"),
11103 return xmalloc (nmemb
* size
);
11106 /* Like xrealloc, but takes three parameters.
11107 Verifies that the second parameter is not too large.
11108 Note: does *not* initialise any new memory to zero. */
11111 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
11113 /* Check for overflow. */
11114 if (nmemb
>= ~(size_t) 0 / size
)
11116 error (_("Attempt to re-allocate an array with an excessive number of elements: %#zx\n"),
11121 return xrealloc (ptr
, nmemb
* size
);
11124 /* Like xcalloc, but verifies that the first parameter is not too large. */
11127 xcalloc2 (size_t nmemb
, size_t size
)
11129 /* Check for overflow. */
11130 if (nmemb
>= ~(size_t) 0 / size
)
11132 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: %#zx\n"),
11137 return xcalloc (nmemb
, size
);
11140 static unsigned long
11141 calc_gnu_debuglink_crc32 (unsigned long crc
,
11142 const unsigned char *buf
,
11145 static const unsigned long crc32_table
[256] =
11147 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
11148 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
11149 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
11150 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
11151 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
11152 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
11153 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
11154 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
11155 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
11156 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
11157 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
11158 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
11159 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
11160 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
11161 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
11162 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
11163 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
11164 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
11165 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
11166 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
11167 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
11168 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
11169 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
11170 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
11171 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
11172 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
11173 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
11174 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
11175 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
11176 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
11177 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
11178 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
11179 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
11180 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
11181 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
11182 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
11183 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
11184 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
11185 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
11186 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
11187 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
11188 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
11189 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
11190 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
11191 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
11192 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
11193 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
11194 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
11195 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
11196 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
11197 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
11200 const unsigned char *end
;
11202 crc
= ~crc
& 0xffffffff;
11203 for (end
= buf
+ len
; buf
< end
; ++ buf
)
11204 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
11205 return ~crc
& 0xffffffff;
11208 typedef bool (*check_func_type
) (const char *, void *);
11209 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
11212 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
11214 static unsigned char buffer
[8 * 1024];
11217 unsigned long crc
= 0;
11220 sep_data
= open_debug_file (pathname
);
11221 if (sep_data
== NULL
)
11224 /* Yes - we are opening the file twice... */
11225 f
= fopen (pathname
, "rb");
11228 /* Paranoia: This should never happen. */
11229 close_debug_file (sep_data
);
11230 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
11234 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
11235 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
11239 if (crc
!= * (unsigned long *) crc_pointer
)
11241 close_debug_file (sep_data
);
11242 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
11250 static const char *
11251 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
11254 unsigned int crc_offset
;
11255 unsigned long * crc32
= (unsigned long *) data
;
11257 /* The name is first.
11258 The CRC value is stored after the filename, aligned up to 4 bytes. */
11259 name
= (const char *) section
->start
;
11261 crc_offset
= strnlen (name
, section
->size
) + 1;
11262 if (crc_offset
== 1)
11264 crc_offset
= (crc_offset
+ 3) & ~3;
11265 if (crc_offset
+ 4 > section
->size
)
11268 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
11273 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
11275 void * sep_data
= open_debug_file (filename
);
11277 if (sep_data
== NULL
)
11280 /* FIXME: We should now extract the build-id in the separate file
11286 typedef struct build_id_data
11289 const unsigned char *data
;
11292 static const char *
11293 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
11298 Build_id_data
*build_id_data
;
11300 /* The name is first.
11301 The build-id follows immediately, with no padding, up to the section's end. */
11303 name
= (const char *) section
->start
;
11304 namelen
= strnlen (name
, section
->size
) + 1;
11307 if (namelen
>= section
->size
)
11310 id_len
= section
->size
- namelen
;
11314 build_id_data
= (Build_id_data
*) data
;
11315 build_id_data
->len
= id_len
;
11316 build_id_data
->data
= section
->start
+ namelen
;
11322 add_separate_debug_file (const char * filename
, void * handle
)
11324 separate_info
* i
= xmalloc (sizeof * i
);
11326 i
->filename
= filename
;
11327 i
->handle
= handle
;
11328 i
->next
= first_separate_info
;
11329 first_separate_info
= i
;
11332 #if HAVE_LIBDEBUGINFOD
11333 /* Query debuginfod servers for the target debuglink or debugaltlink
11334 file. If successful, store the path of the file in filename and
11335 return TRUE, otherwise return FALSE. */
11338 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
11342 size_t build_id_len
;
11343 unsigned char * build_id
;
11345 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
11347 /* Get the build-id of file. */
11348 build_id
= get_build_id (file
);
11351 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
11353 /* Get the build-id of the debugaltlink file. */
11354 unsigned int filelen
;
11356 filelen
= strnlen ((const char *)section
->start
, section
->size
);
11357 if (filelen
== section
->size
)
11358 /* Corrupt debugaltlink. */
11361 build_id
= section
->start
+ filelen
+ 1;
11362 build_id_len
= section
->size
- (filelen
+ 1);
11364 if (build_id_len
== 0)
11373 debuginfod_client
* client
;
11375 client
= debuginfod_begin ();
11376 if (client
== NULL
)
11379 /* Query debuginfod servers for the target file. If found its path
11380 will be stored in filename. */
11381 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
11382 debuginfod_end (client
);
11384 /* Only free build_id if we allocated space for a hex string
11385 in get_build_id (). */
11386 if (build_id_len
== 0)
11391 /* File successfully retrieved. Close fd since we want to
11392 use open_debug_file () on filename instead. */
11400 #endif /* HAVE_LIBDEBUGINFOD */
11403 load_separate_debug_info (const char * main_filename
,
11404 struct dwarf_section
* xlink
,
11405 parse_func_type parse_func
,
11406 check_func_type check_func
,
11408 void * file ATTRIBUTE_UNUSED
)
11410 const char * separate_filename
;
11411 char * debug_filename
;
11413 size_t canon_dirlen
;
11415 char * canon_filename
;
11416 char * canon_debug_filename
;
11419 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11421 warn (_("Corrupt debuglink section: %s\n"),
11422 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11426 /* Attempt to locate the separate file.
11427 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11429 canon_filename
= lrealpath (main_filename
);
11430 canon_dir
= xstrdup (canon_filename
);
11432 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11433 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11435 canon_dir
[canon_dirlen
] = '\0';
11438 #define DEBUGDIR "/lib/debug"
11440 #ifndef EXTRA_DEBUG_ROOT1
11441 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11443 #ifndef EXTRA_DEBUG_ROOT2
11444 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11447 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11449 + strlen (".debug/")
11450 #ifdef EXTRA_DEBUG_ROOT1
11451 + strlen (EXTRA_DEBUG_ROOT1
)
11453 #ifdef EXTRA_DEBUG_ROOT2
11454 + strlen (EXTRA_DEBUG_ROOT2
)
11456 + strlen (separate_filename
)
11458 if (debug_filename
== NULL
)
11460 warn (_("Out of memory"));
11462 free (canon_filename
);
11466 /* First try in the current directory. */
11467 sprintf (debug_filename
, "%s", separate_filename
);
11468 if (check_func (debug_filename
, func_data
))
11471 /* Then try in a subdirectory called .debug. */
11472 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11473 if (check_func (debug_filename
, func_data
))
11476 /* Then try in the same directory as the original file. */
11477 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11478 if (check_func (debug_filename
, func_data
))
11481 /* And the .debug subdirectory of that directory. */
11482 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11483 if (check_func (debug_filename
, func_data
))
11486 #ifdef EXTRA_DEBUG_ROOT1
11487 /* Try the first extra debug file root. */
11488 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11489 if (check_func (debug_filename
, func_data
))
11492 /* Try the first extra debug file root. */
11493 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11494 if (check_func (debug_filename
, func_data
))
11498 #ifdef EXTRA_DEBUG_ROOT2
11499 /* Try the second extra debug file root. */
11500 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11501 if (check_func (debug_filename
, func_data
))
11505 /* Then try in the global debug_filename directory. */
11506 strcpy (debug_filename
, DEBUGDIR
);
11507 dirlen
= strlen (DEBUGDIR
) - 1;
11508 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11509 strcat (debug_filename
, "/");
11510 strcat (debug_filename
, (const char *) separate_filename
);
11512 if (check_func (debug_filename
, func_data
))
11515 #if HAVE_LIBDEBUGINFOD
11517 char * tmp_filename
;
11520 && debuginfod_fetch_separate_debug_info (xlink
,
11524 /* File successfully downloaded from server, replace
11525 debug_filename with the file's path. */
11526 free (debug_filename
);
11527 debug_filename
= tmp_filename
;
11533 if (do_debug_links
)
11535 /* Failed to find the file. */
11536 warn (_("could not find separate debug file '%s'\n"),
11537 separate_filename
);
11538 warn (_("tried: %s\n"), debug_filename
);
11540 #ifdef EXTRA_DEBUG_ROOT2
11541 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11542 separate_filename
);
11543 warn (_("tried: %s\n"), debug_filename
);
11546 #ifdef EXTRA_DEBUG_ROOT1
11547 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11548 canon_dir
, separate_filename
);
11549 warn (_("tried: %s\n"), debug_filename
);
11551 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11552 separate_filename
);
11553 warn (_("tried: %s\n"), debug_filename
);
11556 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11557 separate_filename
);
11558 warn (_("tried: %s\n"), debug_filename
);
11560 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11561 warn (_("tried: %s\n"), debug_filename
);
11563 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11564 warn (_("tried: %s\n"), debug_filename
);
11566 sprintf (debug_filename
, "%s", separate_filename
);
11567 warn (_("tried: %s\n"), debug_filename
);
11569 #if HAVE_LIBDEBUGINFOD
11570 if (use_debuginfod
)
11572 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11577 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11583 free (debug_filename
);
11584 free (canon_filename
);
11590 canon_debug_filename
= lrealpath (debug_filename
);
11591 self
= strcmp (canon_debug_filename
, canon_filename
) == 0;
11592 free (canon_filename
);
11593 free (canon_debug_filename
);
11596 free (debug_filename
);
11600 void * debug_handle
;
11602 /* Now open the file.... */
11603 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11605 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11606 free (debug_filename
);
11610 /* FIXME: We do not check to see if there are any other separate debug info
11611 files that would also match. */
11613 if (do_debug_links
)
11614 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11615 add_separate_debug_file (debug_filename
, debug_handle
);
11617 /* Do not free debug_filename - it might be referenced inside
11618 the structure returned by open_debug_file(). */
11619 return debug_handle
;
11622 /* Attempt to load a separate dwarf object file. */
11625 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11627 char * separate_filename
;
11628 void * separate_handle
;
11630 if (IS_ABSOLUTE_PATH (name
))
11631 separate_filename
= strdup (name
);
11633 /* FIXME: Skip adding / if dwo_dir ends in /. */
11634 separate_filename
= concat (dir
, "/", name
, NULL
);
11635 if (separate_filename
== NULL
)
11637 warn (_("Out of memory allocating dwo filename\n"));
11641 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11643 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11644 free (separate_filename
);
11648 /* FIXME: We should check the dwo_id. */
11650 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11652 add_separate_debug_file (separate_filename
, separate_handle
);
11653 /* Note - separate_filename will be freed in free_debug_memory(). */
11654 return separate_handle
;
11658 try_build_id_prefix (const char * prefix
, char * filename
, const unsigned char * data
, unsigned long id_len
)
11660 char * f
= filename
;
11662 f
+= sprintf (f
, "%s.build-id/%02x/", prefix
, (unsigned) *data
++);
11665 f
+= sprintf (f
, "%02x", (unsigned) *data
++);
11666 strcpy (f
, ".debug");
11668 return open_debug_file (filename
);
11671 /* Try to load a debug file based upon the build-id held in the .note.gnu.build-id section. */
11674 load_build_id_debug_file (const char * main_filename ATTRIBUTE_UNUSED
, void * main_file
)
11676 if (! load_debug_section (note_gnu_build_id
, main_file
))
11677 return; /* No .note.gnu.build-id section. */
11679 struct dwarf_section
* section
= & debug_displays
[note_gnu_build_id
].section
;
11680 if (section
== NULL
)
11682 warn (_("Unable to load the .note.gnu.build-id section\n"));
11686 if (section
->start
== NULL
|| section
->size
< 0x18)
11688 warn (_(".note.gnu.build-id section is corrupt/empty\n"));
11692 /* In theory we should extract the contents of the section into
11693 a note structure and then check the fields. For now though
11694 just use hard coded offsets instead:
11696 Field Bytes Contents
11699 Type 8..11 3 (NT_GNU_BUILD_ID)
11703 /* FIXME: Check the name size, name and type fields. */
11705 unsigned long build_id_size
;
11706 build_id_size
= byte_get (section
->start
+ 4, 4);
11707 if (build_id_size
< 8)
11709 warn (_(".note.gnu.build-id data size is too small\n"));
11713 if (build_id_size
> (section
->size
- 16))
11715 warn (_(".note.gnu.build-id data size is too bug\n"));
11720 filename
= xmalloc (strlen (".build-id/")
11721 + build_id_size
* 2 + 2
11722 + strlen (".debug")
11723 /* The next string should be the same as the longest
11724 name found in the prefixes[] array below. */
11725 + strlen ("/usrlib64/debug/usr")
11729 static const char * prefixes
[] =
11734 "/usr/lib/debug/usr/",
11735 "/usr/lib64/debug/",
11736 "/usr/lib64/debug/usr"
11738 long unsigned int i
;
11740 for (i
= 0; i
< ARRAY_SIZE (prefixes
); i
++)
11742 handle
= try_build_id_prefix (prefixes
[i
], filename
,
11743 section
->start
+ 16, build_id_size
);
11744 if (handle
!= NULL
)
11747 /* FIXME: TYhe BFD library also tries a global debugfile directory prefix. */
11748 if (handle
== NULL
)
11750 /* Failed to find a debug file associated with the build-id.
11751 This is not an error however, rather it just means that
11752 the debug info has probably not been loaded on the system,
11753 or that another method is being used to link to the debug
11759 add_separate_debug_file (filename
, handle
);
11762 /* Try to load a debug file pointed to by the .debug_sup section. */
11765 load_debug_sup_file (const char * main_filename
, void * file
)
11767 if (! load_debug_section (debug_sup
, file
))
11768 return; /* No .debug_sup section. */
11770 struct dwarf_section
* section
;
11771 section
= & debug_displays
[debug_sup
].section
;
11772 assert (section
!= NULL
);
11774 if (section
->start
== NULL
|| section
->size
< 5)
11776 warn (_(".debug_sup section is corrupt/empty\n"));
11780 if (section
->start
[2] != 0)
11781 return; /* This is a supplementary file. */
11783 const char * filename
= (const char *) section
->start
+ 3;
11784 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11786 warn (_("filename in .debug_sup section is corrupt\n"));
11790 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11795 new_len
= asprintf (& new_name
, "%.*s/%s",
11796 (int) (strrchr (main_filename
, '/') - main_filename
),
11801 warn (_("unable to construct path for supplementary debug file"));
11806 filename
= new_name
;
11810 /* PR 27796: Make sure that we pass a filename that can be free'd to
11811 add_separate_debug_file(). */
11812 filename
= strdup (filename
);
11813 if (filename
== NULL
)
11815 warn (_("out of memory constructing filename for .debug_sup link\n"));
11820 void * handle
= open_debug_file (filename
);
11821 if (handle
== NULL
)
11823 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11824 free ((void *) filename
);
11828 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11830 /* FIXME: Compare the checksums, if present. */
11831 add_separate_debug_file (filename
, handle
);
11834 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11835 Recursively check the loaded files for more of these sections.
11836 Also follow any links in .debug_sup sections.
11837 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11840 check_for_and_load_links (void * file
, const char * filename
)
11842 void * handle
= NULL
;
11844 if (load_debug_section (gnu_debugaltlink
, file
))
11846 Build_id_data build_id_data
;
11848 handle
= load_separate_debug_info (filename
,
11849 & debug_displays
[gnu_debugaltlink
].section
,
11850 parse_gnu_debugaltlink
,
11851 check_gnu_debugaltlink
,
11856 assert (handle
== first_separate_info
->handle
);
11857 check_for_and_load_links (first_separate_info
->handle
,
11858 first_separate_info
->filename
);
11862 if (load_debug_section (gnu_debuglink
, file
))
11864 unsigned long crc32
;
11866 handle
= load_separate_debug_info (filename
,
11867 & debug_displays
[gnu_debuglink
].section
,
11868 parse_gnu_debuglink
,
11869 check_gnu_debuglink
,
11874 assert (handle
== first_separate_info
->handle
);
11875 check_for_and_load_links (first_separate_info
->handle
,
11876 first_separate_info
->filename
);
11880 load_debug_sup_file (filename
, file
);
11882 load_build_id_debug_file (filename
, file
);
11885 /* Load the separate debug info file(s) attached to FILE, if any exist.
11886 Returns TRUE if any were found, FALSE otherwise.
11887 If TRUE is returned then the linked list starting at first_separate_info
11888 will be populated with open file handles. */
11891 load_separate_debug_files (void * file
, const char * filename
)
11893 /* Skip this operation if we are not interested in debug links. */
11894 if (! do_follow_links
&& ! do_debug_links
)
11897 /* See if there are any dwo links. */
11898 if (load_debug_section (str
, file
)
11899 && load_debug_section (abbrev
, file
)
11900 && load_debug_section (info
, file
))
11902 /* Load the .debug_addr section, if it exists. */
11903 load_debug_section (debug_addr
, file
);
11904 /* Load the .debug_str_offsets section, if it exists. */
11905 load_debug_section (str_index
, file
);
11906 /* Load the .debug_loclists section, if it exists. */
11907 load_debug_section (loclists
, file
);
11908 /* Load the .debug_rnglists section, if it exists. */
11909 load_debug_section (rnglists
, file
);
11913 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11916 bool introduced
= false;
11918 const char *dir
= NULL
;
11919 const char *id
= NULL
;
11920 const char *name
= NULL
;
11922 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11924 /* Accumulate NAME, DIR and ID fields. */
11925 switch (dwinfo
->type
)
11929 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11930 name
= dwinfo
->value
;
11934 /* There can be multiple DW_AT_comp_dir entries in a CU,
11935 so do not complain. */
11936 dir
= dwinfo
->value
;
11941 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11942 id
= dwinfo
->value
;
11946 error (_("Unexpected DWO INFO type"));
11950 /* If we have reached the end of our list, or we are changing
11951 CUs, then display the information that we have accumulated
11954 && (dwinfo
->next
== NULL
11955 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11957 if (do_debug_links
)
11961 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11962 debug_displays
[info
].section
.uncompressed_name
);
11966 printf (_(" Name: %s\n"), name
);
11967 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11969 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11970 else if (debug_information
[0].dwarf_version
!= 5)
11971 printf (_(" ID: <not specified>\n"));
11975 if (do_follow_links
)
11976 load_dwo_file (filename
, name
, dir
, id
);
11978 name
= dir
= id
= NULL
;
11984 if (! do_follow_links
)
11985 /* The other debug links will be displayed by display_debug_links()
11986 so we do not need to do any further processing here. */
11989 /* FIXME: We do not check for the presence of both link sections in the same file. */
11990 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11991 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11993 check_for_and_load_links (file
, filename
);
11994 if (first_separate_info
!= NULL
)
11997 do_follow_links
= 0;
12002 free_debug_memory (void)
12006 free_all_abbrevs ();
12010 shndx_pool_size
= 0;
12011 shndx_pool_used
= 0;
12019 memset (level_type_signed
, 0, sizeof level_type_signed
);
12020 cu_tu_indexes_read
= -1;
12022 for (i
= 0; i
< max
; i
++)
12023 free_debug_section ((enum dwarf_section_display_enum
) i
);
12025 if (debug_information
!= NULL
)
12027 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
12028 free_debug_information (&debug_information
[i
]);
12029 free (debug_information
);
12030 debug_information
= NULL
;
12031 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
12035 separate_info
* next
;
12037 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
12039 close_debug_file (d
->handle
);
12040 free ((void *) d
->filename
);
12044 first_separate_info
= NULL
;
12052 const char *option
;
12055 } debug_dump_long_opts
;
12057 static const debug_dump_long_opts debug_option_table
[] =
12059 { 'A', "addr", &do_debug_addr
, 1 },
12060 { 'a', "abbrev", &do_debug_abbrevs
, 1 },
12061 { 'c', "cu_index", &do_debug_cu_index
, 1 },
12062 #ifdef HAVE_LIBDEBUGINFOD
12063 { 'D', "use-debuginfod", &use_debuginfod
, 1 },
12064 { 'E', "do-not-use-debuginfod", &use_debuginfod
, 0 },
12066 { 'F', "frames-interp", &do_debug_frames_interp
, 1 },
12067 { 'f', "frames", &do_debug_frames
, 1 },
12068 { 'g', "gdb_index", &do_gdb_index
, 1 },
12069 { 'i', "info", &do_debug_info
, 1 },
12070 { 'K', "follow-links", &do_follow_links
, 1 },
12071 { 'k', "links", &do_debug_links
, 1 },
12072 { 'L', "decodedline", &do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
12073 { 'l', "rawline", &do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
12074 /* For compatibility with earlier versions of readelf. */
12075 { 'l', "line", &do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
12076 { 'm', "macro", &do_debug_macinfo
, 1 },
12077 { 'N', "no-follow-links", &do_follow_links
, 0 },
12078 { 'O', "str-offsets", &do_debug_str_offsets
, 1 },
12079 { 'o', "loc", &do_debug_loc
, 1 },
12080 { 'p', "pubnames", &do_debug_pubnames
, 1 },
12081 { 'R', "Ranges", &do_debug_ranges
, 1 },
12082 { 'r', "aranges", &do_debug_aranges
, 1 },
12083 /* For compatibility with earlier versions of readelf. */
12084 { 'r', "ranges", &do_debug_aranges
, 1 },
12085 { 's', "str", &do_debug_str
, 1 },
12086 { 'T', "trace_aranges", &do_trace_aranges
, 1 },
12087 { 't', "pubtypes", &do_debug_pubtypes
, 1 },
12088 { 'U', "trace_info", &do_trace_info
, 1 },
12089 { 'u', "trace_abbrev", &do_trace_abbrevs
, 1 },
12090 { 0, NULL
, NULL
, 0 }
12093 /* Enable display of specific DWARF sections as determined by the comma
12094 separated strings in NAMES. Returns non-zero if any displaying was
12098 dwarf_select_sections_by_names (const char *names
)
12106 const debug_dump_long_opts
*entry
;
12108 for (entry
= debug_option_table
; entry
->option
; entry
++)
12110 size_t len
= strlen (entry
->option
);
12112 if (strncmp (p
, entry
->option
, len
) == 0
12113 && (p
[len
] == ',' || p
[len
] == '\0'))
12115 if (entry
->val
== 0)
12116 * entry
->variable
= 0;
12118 * entry
->variable
= entry
->val
;
12119 result
|= entry
->val
;
12126 if (entry
->option
== NULL
)
12128 warn (_("Unrecognized debug option '%s'\n"), p
);
12129 p
= strchr (p
, ',');
12138 /* The --debug-dump=frames-interp option also enables the
12139 --debug-dump=frames option. */
12140 if (do_debug_frames_interp
)
12141 do_debug_frames
= 1;
12146 /* Enable display of specific DWARF sections as determined by the characters
12147 in LETTERS. Returns non-zero if any displaying was enabled. */
12150 dwarf_select_sections_by_letters (const char *letters
)
12156 const debug_dump_long_opts
*entry
;
12158 for (entry
= debug_option_table
; entry
->letter
; entry
++)
12160 if (entry
->letter
== * letters
)
12162 if (entry
->val
== 0)
12163 * entry
->variable
= 0;
12165 * entry
->variable
|= entry
->val
;
12166 result
|= entry
->val
;
12171 if (entry
->letter
== 0)
12172 warn (_("Unrecognized debug letter option '%c'\n"), * letters
);
12177 /* The --debug-dump=frames-interp option also enables the
12178 --debug-dump=frames option. */
12179 if (do_debug_frames_interp
)
12180 do_debug_frames
= 1;
12186 dwarf_select_sections_all (void)
12189 do_debug_abbrevs
= 1;
12190 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
12191 do_debug_pubnames
= 1;
12192 do_debug_pubtypes
= 1;
12193 do_debug_aranges
= 1;
12194 do_debug_ranges
= 1;
12195 do_debug_frames
= 1;
12196 do_debug_macinfo
= 1;
12201 do_trace_abbrevs
= 1;
12202 do_trace_aranges
= 1;
12204 do_debug_cu_index
= 1;
12205 do_follow_links
= 1;
12206 do_debug_links
= 1;
12207 do_debug_str_offsets
= 1;
12210 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
12211 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
12213 /* N.B. The order here must match the order in section_display_enum. */
12215 struct dwarf_section_display debug_displays
[] =
12217 { { ".debug_abbrev", ".zdebug_abbrev", ".dwabrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
12218 { { ".debug_aranges", ".zdebug_aranges", ".dwarnge", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
12219 { { ".debug_frame", ".zdebug_frame", ".dwframe", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
12220 { { ".debug_info", ".zdebug_info", ".dwinfo", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
12221 { { ".debug_line", ".zdebug_line", ".dwline", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
12222 { { ".debug_pubnames", ".zdebug_pubnames", ".dwpbnms", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
12223 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
12224 { { ".eh_frame", "", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
12225 { { ".debug_macinfo", ".zdebug_macinfo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
12226 { { ".debug_macro", ".zdebug_macro", ".dwmac", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
12227 { { ".debug_str", ".zdebug_str", ".dwstr", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12228 { { ".debug_line_str", ".zdebug_line_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12229 { { ".debug_loc", ".zdebug_loc", ".dwloc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12230 { { ".debug_loclists", ".zdebug_loclists", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12231 { { ".debug_loclists.dwo", ".zdebug_loclists.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12232 { { ".debug_pubtypes", ".zdebug_pubtypes", ".dwpbtyp", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
12233 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
12234 { { ".debug_ranges", ".zdebug_ranges", ".dwrnges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12235 { { ".debug_rnglists", ".zdebug_rnglists", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12236 { { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12237 { { ".debug_static_func", ".zdebug_static_func", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12238 { { ".debug_static_vars", ".zdebug_static_vars", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12239 { { ".debug_types", ".zdebug_types", "", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
12240 { { ".debug_weaknames", ".zdebug_weaknames", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12241 { { ".gdb_index", "", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
12242 { { ".debug_names", "", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
12243 { { ".trace_info", "", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
12244 { { ".trace_abbrev", "", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
12245 { { ".trace_aranges", "", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
12246 { { ".debug_info.dwo", ".zdebug_info.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
12247 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", "", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
12248 { { ".debug_types.dwo", ".zdebug_types.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
12249 { { ".debug_line.dwo", ".zdebug_line.dwo", "", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
12250 { { ".debug_loc.dwo", ".zdebug_loc.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12251 { { ".debug_macro.dwo", ".zdebug_macro.dwo", "", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
12252 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
12253 { { ".debug_str.dwo", ".zdebug_str.dwo", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
12254 { { ".debug_str_offsets", ".zdebug_str_offsets", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
12255 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
12256 { { ".debug_addr", ".zdebug_addr", "", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
12257 { { ".debug_cu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
12258 { { ".debug_tu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
12259 { { ".gnu_debuglink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
12260 { { ".gnu_debugaltlink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
12261 { { ".debug_sup", "", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
12262 /* Separate debug info files can containt their own .debug_str section,
12263 and this might be in *addition* to a .debug_str section already present
12264 in the main file. Hence we need to have two entries for .debug_str. */
12265 { { ".debug_str", ".zdebug_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12266 { { ".note.gnu.build-id", "", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12269 /* A static assertion. */
12270 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];