1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2023 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 frame_base_level
= -1; /* To support nested DW_TAG_subprogram's. */
58 static int need_base_address
;
60 static unsigned int num_debug_info_entries
= 0;
61 static unsigned int alloc_num_debug_info_entries
= 0;
62 static debug_info
*debug_information
= NULL
;
63 /* Special value for num_debug_info_entries to indicate
64 that the .debug_info section could not be loaded/parsed. */
65 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
67 /* A .debug_info section can contain multiple links to separate
68 DWO object files. We use these structures to record these links. */
76 typedef struct dwo_info
81 struct dwo_info
* next
;
84 static dwo_info
*first_dwo_info
= NULL
;
85 static bool need_dwo_info
;
87 separate_info
* first_separate_info
= NULL
;
89 unsigned int eh_addr_size
;
94 int do_debug_pubnames
;
95 int do_debug_pubtypes
;
99 int do_debug_frames_interp
;
100 int do_debug_macinfo
;
102 int do_debug_str_offsets
;
106 int do_trace_abbrevs
;
107 int do_trace_aranges
;
109 int do_debug_cu_index
;
112 int do_follow_links
= DEFAULT_FOR_FOLLOW_LINKS
;
113 #ifdef HAVE_LIBDEBUGINFOD
114 int use_debuginfod
= 1;
118 int dwarf_cutoff_level
= -1;
119 unsigned long dwarf_start_die
;
123 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
124 sections. For version 1 package files, each set is stored in SHNDX_POOL
125 as a zero-terminated list of section indexes comprising one set of debug
126 sections from a .dwo file. */
128 static unsigned int *shndx_pool
= NULL
;
129 static unsigned int shndx_pool_size
= 0;
130 static unsigned int shndx_pool_used
= 0;
132 /* For version 2 package files, each set contains an array of section offsets
133 and an array of section sizes, giving the offset and size of the
134 contribution from a CU or TU within one of the debug sections.
135 When displaying debug info from a package file, we need to use these
136 tables to locate the corresponding contributions to each section. */
141 uint64_t section_offsets
[DW_SECT_MAX
];
142 size_t section_sizes
[DW_SECT_MAX
];
145 static int cu_count
= 0;
146 static int tu_count
= 0;
147 static struct cu_tu_set
*cu_sets
= NULL
;
148 static struct cu_tu_set
*tu_sets
= NULL
;
150 static bool load_cu_tu_indexes (void *);
152 /* An array that indicates for a given level of CU nesting whether
153 the latest DW_AT_type seen for that level was a signed type or
155 #define MAX_CU_NESTING (1 << 8)
156 static bool level_type_signed
[MAX_CU_NESTING
];
158 /* Values for do_debug_lines. */
159 #define FLAG_DEBUG_LINES_RAW 1
160 #define FLAG_DEBUG_LINES_DECODED 2
163 size_of_encoded_value (int encoding
)
165 switch (encoding
& 0x7)
168 case 0: return eh_addr_size
;
176 get_encoded_value (unsigned char **pdata
,
178 struct dwarf_section
*section
,
181 unsigned char * data
= * pdata
;
182 unsigned int size
= size_of_encoded_value (encoding
);
185 if (data
>= end
|| size
> (size_t) (end
- data
))
187 warn (_("Encoded value extends past end of section\n"));
192 /* PR 17512: file: 002-829853-0.004. */
195 warn (_("Encoded size of %d is too large to read\n"), size
);
200 /* PR 17512: file: 1085-5603-0.004. */
203 warn (_("Encoded size of 0 is too small to read\n"));
208 if (encoding
& DW_EH_PE_signed
)
209 val
= byte_get_signed (data
, size
);
211 val
= byte_get (data
, size
);
213 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
214 val
+= section
->address
+ (data
- section
->start
);
216 * pdata
= data
+ size
;
220 /* Print a uint64_t value (typically an address, offset or length) in
221 hexadecimal format, followed by a space. The precision displayed is
222 determined by the NUM_BYTES parameter. */
225 print_hex (uint64_t value
, unsigned num_bytes
)
230 printf ("%0*" PRIx64
" ", num_bytes
* 2,
231 value
& ~(~(uint64_t) 0 << num_bytes
* 4 << num_bytes
* 4));
234 /* Like print_hex, but no trailing space. */
237 print_hex_ns (uint64_t value
, unsigned num_bytes
)
242 printf ("%0*" PRIx64
, num_bytes
* 2,
243 value
& ~(~(uint64_t) 0 << num_bytes
* 4 << num_bytes
* 4));
246 /* Print a view number in hexadecimal value, with the same width as
247 print_hex would have printed it. */
250 print_view (uint64_t value
, unsigned num_bytes
)
255 printf ("v%0*" PRIx64
" ", num_bytes
* 2 - 1,
256 value
& ~(~(uint64_t) 0 << num_bytes
* 4 << num_bytes
* 4));
260 null_name (const char *p
)
267 /* Read in a LEB128 encoded value starting at address DATA.
268 If SIGN is true, return a signed LEB128 value.
269 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
270 If STATUS_RETURN is not NULL, return with bit 0 (LSB) set if the
271 terminating byte was not found and with bit 1 set if the value
272 overflows a uint64_t.
273 No bytes will be read at address END or beyond. */
276 read_leb128 (unsigned char *data
,
277 const unsigned char *const end
,
279 unsigned int *length_return
,
283 unsigned int num_read
= 0;
284 unsigned int shift
= 0;
289 unsigned char byte
= *data
++;
290 unsigned char lost
, mask
;
294 if (shift
< CHAR_BIT
* sizeof (result
))
296 result
|= ((uint64_t) (byte
& 0x7f)) << shift
;
297 /* These bits overflowed. */
298 lost
= byte
^ (result
>> shift
);
299 /* And this is the mask of possible overflow bits. */
300 mask
= 0x7f ^ ((uint64_t) 0x7f << shift
>> shift
);
308 if ((lost
& mask
) != (sign
&& (int64_t) result
< 0 ? mask
: 0))
311 if ((byte
& 0x80) == 0)
314 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
315 result
|= -((uint64_t) 1 << shift
);
320 if (length_return
!= NULL
)
321 *length_return
= num_read
;
322 if (status_return
!= NULL
)
323 *status_return
= status
;
328 /* Read AMOUNT bytes from PTR and store them in VAL.
329 Checks to make sure that the read will not reach or pass END.
330 FUNC chooses whether the value read is unsigned or signed, and may
331 be either byte_get or byte_get_signed. If INC is true, PTR is
332 incremented after reading the value.
333 This macro cannot protect against PTR values derived from user input.
334 The C standard sections 6.5.6 and 6.5.8 say attempts to do so using
335 pointers is undefined behaviour. */
336 #define SAFE_BYTE_GET_INTERNAL(VAL, PTR, AMOUNT, END, FUNC, INC) \
339 size_t amount = (AMOUNT); \
340 if (sizeof (VAL) < amount) \
342 error (ngettext ("internal error: attempt to read %d byte " \
343 "of data in to %d sized variable", \
344 "internal error: attempt to read %d bytes " \
345 "of data in to %d sized variable", \
347 (int) amount, (int) sizeof (VAL)); \
348 amount = sizeof (VAL); \
350 if (ENABLE_CHECKING) \
351 assert ((PTR) <= (END)); \
352 size_t avail = (END) - (PTR); \
355 if (amount > avail) \
360 (VAL) = (FUNC) ((PTR), amount); \
366 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
367 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, false)
369 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
370 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, true)
372 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
373 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, false)
375 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
376 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, true)
378 typedef struct State_Machine_Registers
387 unsigned char op_index
;
388 unsigned char end_sequence
;
389 /* This variable hold the number of the last entry seen
390 in the File Table. */
391 unsigned int last_file_entry
;
394 static SMR state_machine_regs
;
397 reset_state_machine (int is_stmt
)
399 state_machine_regs
.address
= 0;
400 state_machine_regs
.view
= 0;
401 state_machine_regs
.op_index
= 0;
402 state_machine_regs
.file
= 1;
403 state_machine_regs
.line
= 1;
404 state_machine_regs
.column
= 0;
405 state_machine_regs
.is_stmt
= is_stmt
;
406 state_machine_regs
.basic_block
= 0;
407 state_machine_regs
.end_sequence
= 0;
408 state_machine_regs
.last_file_entry
= 0;
411 /* Handled an extend line op.
412 Returns the number of bytes read. */
415 process_extended_line_op (unsigned char * data
,
419 unsigned char op_code
;
420 size_t len
, header_len
;
422 unsigned char *orig_data
= data
;
425 READ_ULEB (len
, data
, end
);
426 header_len
= data
- orig_data
;
428 if (len
== 0 || data
>= end
|| len
> (size_t) (end
- data
))
430 warn (_("Badly formed extended line op encountered!\n"));
436 printf (_(" Extended opcode %d: "), op_code
);
440 case DW_LNE_end_sequence
:
441 printf (_("End of Sequence\n\n"));
442 reset_state_machine (is_stmt
);
445 case DW_LNE_set_address
:
446 /* PR 17512: file: 002-100480-0.004. */
449 warn (_("Length (%zu) of DW_LNE_set_address op is too long\n"),
454 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
455 printf (_("set Address to %#" PRIx64
"\n"), adr
);
456 state_machine_regs
.address
= adr
;
457 state_machine_regs
.view
= 0;
458 state_machine_regs
.op_index
= 0;
461 case DW_LNE_define_file
:
462 printf (_("define new File Table entry\n"));
463 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
464 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
470 l
= strnlen ((char *) data
, end
- data
);
474 READ_ULEB (val
, data
, end
);
475 printf ("%" PRIu64
"\t", val
);
476 READ_ULEB (val
, data
, end
);
477 printf ("%" PRIu64
"\t", val
);
478 READ_ULEB (val
, data
, end
);
479 printf ("%" PRIu64
"\t", val
);
480 printf ("%.*s\n\n", (int) l
, name
);
483 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
>= end
)
484 warn (_("DW_LNE_define_file: Bad opcode length\n"));
487 case DW_LNE_set_discriminator
:
488 READ_ULEB (val
, data
, end
);
489 printf (_("set Discriminator to %" PRIu64
"\n"), val
);
493 case DW_LNE_HP_negate_is_UV_update
:
494 printf ("DW_LNE_HP_negate_is_UV_update\n");
496 case DW_LNE_HP_push_context
:
497 printf ("DW_LNE_HP_push_context\n");
499 case DW_LNE_HP_pop_context
:
500 printf ("DW_LNE_HP_pop_context\n");
502 case DW_LNE_HP_set_file_line_column
:
503 printf ("DW_LNE_HP_set_file_line_column\n");
505 case DW_LNE_HP_set_routine_name
:
506 printf ("DW_LNE_HP_set_routine_name\n");
508 case DW_LNE_HP_set_sequence
:
509 printf ("DW_LNE_HP_set_sequence\n");
511 case DW_LNE_HP_negate_post_semantics
:
512 printf ("DW_LNE_HP_negate_post_semantics\n");
514 case DW_LNE_HP_negate_function_exit
:
515 printf ("DW_LNE_HP_negate_function_exit\n");
517 case DW_LNE_HP_negate_front_end_logical
:
518 printf ("DW_LNE_HP_negate_front_end_logical\n");
520 case DW_LNE_HP_define_proc
:
521 printf ("DW_LNE_HP_define_proc\n");
523 case DW_LNE_HP_source_file_correlation
:
525 unsigned char *edata
= data
+ len
- 1;
527 printf ("DW_LNE_HP_source_file_correlation\n");
533 READ_ULEB (opc
, data
, edata
);
537 case DW_LNE_HP_SFC_formfeed
:
538 printf (" DW_LNE_HP_SFC_formfeed\n");
540 case DW_LNE_HP_SFC_set_listing_line
:
541 READ_ULEB (val
, data
, edata
);
542 printf (" DW_LNE_HP_SFC_set_listing_line (%" PRIu64
")\n",
545 case DW_LNE_HP_SFC_associate
:
546 printf (" DW_LNE_HP_SFC_associate ");
547 READ_ULEB (val
, data
, edata
);
548 printf ("(%" PRIu64
, val
);
549 READ_ULEB (val
, data
, edata
);
550 printf (",%" PRIu64
, val
);
551 READ_ULEB (val
, data
, edata
);
552 printf (",%" PRIu64
")\n", val
);
555 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
565 unsigned int rlen
= len
- 1;
567 if (op_code
>= DW_LNE_lo_user
568 /* The test against DW_LNW_hi_user is redundant due to
569 the limited range of the unsigned char data type used
571 /*&& op_code <= DW_LNE_hi_user*/)
572 printf (_("user defined: "));
574 printf (_("UNKNOWN: "));
575 printf (_("length %d ["), rlen
);
577 printf (" %02x", *data
++);
583 return len
+ header_len
;
586 static const unsigned char *
587 fetch_indirect_string (uint64_t offset
)
589 struct dwarf_section
*section
= &debug_displays
[str
].section
;
590 const unsigned char * ret
;
592 if (section
->start
== NULL
)
593 return (const unsigned char *) _("<no .debug_str section>");
595 if (offset
>= section
->size
)
597 warn (_("DW_FORM_strp offset too big: %#" PRIx64
"\n"), offset
);
598 return (const unsigned char *) _("<offset is too big>");
601 ret
= section
->start
+ offset
;
602 /* Unfortunately we cannot rely upon the .debug_str section ending with a
603 NUL byte. Since our caller is expecting to receive a well formed C
604 string we test for the lack of a terminating byte here. */
605 if (strnlen ((const char *) ret
, section
->size
- offset
)
606 == section
->size
- offset
)
607 ret
= (const unsigned char *)
608 _("<no NUL byte at end of .debug_str section>");
613 static const unsigned char *
614 fetch_indirect_line_string (uint64_t offset
)
616 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
617 const unsigned char * ret
;
619 if (section
->start
== NULL
)
620 return (const unsigned char *) _("<no .debug_line_str section>");
622 if (offset
>= section
->size
)
624 warn (_("DW_FORM_line_strp offset too big: %#" PRIx64
"\n"), offset
);
625 return (const unsigned char *) _("<offset is too big>");
628 ret
= section
->start
+ offset
;
629 /* Unfortunately we cannot rely upon the .debug_line_str section ending
630 with a NUL byte. Since our caller is expecting to receive a well formed
631 C string we test for the lack of a terminating byte here. */
632 if (strnlen ((const char *) ret
, section
->size
- offset
)
633 == section
->size
- offset
)
634 ret
= (const unsigned char *)
635 _("<no NUL byte at end of .debug_line_str section>");
641 fetch_indexed_string (uint64_t idx
,
642 struct cu_tu_set
*this_set
,
643 uint64_t offset_size
,
645 uint64_t str_offsets_base
)
647 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
648 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
649 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
650 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
651 uint64_t index_offset
;
655 if (index_section
->start
== NULL
)
656 return (dwo
? _("<no .debug_str_offsets.dwo section>")
657 : _("<no .debug_str_offsets section>"));
659 if (str_section
->start
== NULL
)
660 return (dwo
? _("<no .debug_str.dwo section>")
661 : _("<no .debug_str section>"));
663 if (_mul_overflow (idx
, offset_size
, &index_offset
)
665 && ((index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
])
666 < this_set
->section_offsets
[DW_SECT_STR_OFFSETS
]))
667 || (index_offset
+= str_offsets_base
) < str_offsets_base
668 || index_offset
+ offset_size
< offset_size
669 || index_offset
+ offset_size
> index_section
->size
)
671 warn (_("string index of %" PRIu64
" converts to an offset of %#" PRIx64
672 " which is too big for section %s"),
673 idx
, index_offset
, str_section
->name
);
675 return _("<string index too big>");
678 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
680 str_offset
-= str_section
->address
;
681 if (str_offset
>= str_section
->size
)
683 warn (_("indirect offset too big: %#" PRIx64
"\n"), str_offset
);
684 return _("<indirect index offset is too big>");
687 ret
= (const char *) str_section
->start
+ str_offset
;
689 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
690 Since our caller is expecting to receive a well formed C string we test
691 for the lack of a terminating byte here. */
692 if (strnlen (ret
, str_section
->size
- str_offset
)
693 == str_section
->size
- str_offset
)
694 return _("<no NUL byte at end of section>");
700 fetch_indexed_addr (uint64_t offset
, uint32_t num_bytes
)
702 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
704 if (section
->start
== NULL
)
706 warn (_("Cannot fetch indexed address: the .debug_addr section is missing\n"));
710 if (offset
+ num_bytes
> section
->size
)
712 warn (_("Offset into section %s too big: %#" PRIx64
"\n"),
713 section
->name
, offset
);
717 return byte_get (section
->start
+ offset
, num_bytes
);
720 /* This is for resolving DW_FORM_rnglistx and DW_FORM_loclistx.
722 The memory layout is: base_address (taken from the CU's top DIE) points at a table of offsets,
723 relative to the section start.
724 The table of offsets contains the offsets of objects of interest relative to the table of offsets.
725 IDX is the index of the desired object in said table of offsets.
727 This returns the offset of the desired object relative to the section start or -1 upon failure. */
730 fetch_indexed_offset (uint64_t idx
,
731 enum dwarf_section_display_enum sec_enum
,
732 uint64_t base_address
,
733 uint64_t offset_size
)
735 uint64_t offset_of_offset
= base_address
+ idx
* offset_size
;
736 struct dwarf_section
*section
= &debug_displays
[sec_enum
].section
;
738 if (section
->start
== NULL
)
740 warn (_("Unable to locate %s section\n"), section
->uncompressed_name
);
744 if (section
->size
< 4)
746 warn (_("Section %s is too small to contain an value indexed from another section!\n"),
751 if (offset_of_offset
+ offset_size
>= section
->size
)
753 warn (_("Offset of %#" PRIx64
" is too big for section %s\n"),
754 offset_of_offset
, section
->name
);
758 return base_address
+ byte_get (section
->start
+ offset_of_offset
, offset_size
);
761 /* FIXME: There are better and more efficient ways to handle
762 these structures. For now though, I just want something that
763 is simple to implement. */
764 /* Records a single attribute in an abbrev. */
765 typedef struct abbrev_attr
767 unsigned long attribute
;
769 int64_t implicit_const
;
770 struct abbrev_attr
*next
;
774 /* Records a single abbrev. */
775 typedef struct abbrev_entry
777 unsigned long number
;
780 struct abbrev_attr
* first_attr
;
781 struct abbrev_attr
* last_attr
;
782 struct abbrev_entry
* next
;
786 /* Records a set of abbreviations. */
787 typedef struct abbrev_list
789 abbrev_entry
* first_abbrev
;
790 abbrev_entry
* last_abbrev
;
792 struct abbrev_list
* next
;
793 unsigned char * start_of_next_abbrevs
;
797 /* Records all the abbrevs found so far. */
798 static struct abbrev_list
* abbrev_lists
= NULL
;
800 typedef struct abbrev_map
807 /* Maps between CU offsets and abbrev sets. */
808 static abbrev_map
* cu_abbrev_map
= NULL
;
809 static unsigned long num_abbrev_map_entries
= 0;
810 static unsigned long next_free_abbrev_map_entry
= 0;
812 #define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
813 #define ABBREV_MAP_ENTRIES_INCREMENT 8
816 record_abbrev_list_for_cu (uint64_t start
, uint64_t end
,
817 abbrev_list
*list
, abbrev_list
*free_list
)
819 if (free_list
!= NULL
)
821 list
->next
= abbrev_lists
;
825 if (cu_abbrev_map
== NULL
)
827 num_abbrev_map_entries
= INITIAL_NUM_ABBREV_MAP_ENTRIES
;
828 cu_abbrev_map
= xmalloc (num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
830 else if (next_free_abbrev_map_entry
== num_abbrev_map_entries
)
832 num_abbrev_map_entries
+= ABBREV_MAP_ENTRIES_INCREMENT
;
833 cu_abbrev_map
= xrealloc (cu_abbrev_map
, num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
836 cu_abbrev_map
[next_free_abbrev_map_entry
].start
= start
;
837 cu_abbrev_map
[next_free_abbrev_map_entry
].end
= end
;
838 cu_abbrev_map
[next_free_abbrev_map_entry
].list
= list
;
839 next_free_abbrev_map_entry
++;
843 free_abbrev_list (abbrev_list
*list
)
845 abbrev_entry
*abbrv
= list
->first_abbrev
;
849 abbrev_attr
*attr
= abbrv
->first_attr
;
853 abbrev_attr
*next_attr
= attr
->next
;
858 abbrev_entry
*next_abbrev
= abbrv
->next
;
863 abbrev_list
*next
= list
->next
;
869 free_all_abbrevs (void)
872 abbrev_lists
= free_abbrev_list (abbrev_lists
);
874 free (cu_abbrev_map
);
875 cu_abbrev_map
= NULL
;
876 next_free_abbrev_map_entry
= 0;
880 find_abbrev_list_by_raw_abbrev (unsigned char *raw
)
884 for (list
= abbrev_lists
; list
!= NULL
; list
= list
->next
)
885 if (list
->raw
== raw
)
891 /* Find the abbreviation map for the CU that includes OFFSET.
892 OFFSET is an absolute offset from the start of the .debug_info section. */
893 /* FIXME: This function is going to slow down readelf & objdump.
894 Not caching abbrevs is likely the answer. */
897 find_abbrev_map_by_offset (uint64_t offset
)
901 for (i
= 0; i
< next_free_abbrev_map_entry
; i
++)
902 if (cu_abbrev_map
[i
].start
<= offset
903 && cu_abbrev_map
[i
].end
> offset
)
904 return cu_abbrev_map
+ i
;
910 add_abbrev (unsigned long number
,
915 abbrev_entry
* entry
;
917 entry
= (abbrev_entry
*) xmalloc (sizeof (*entry
));
919 entry
->number
= number
;
921 entry
->children
= children
;
922 entry
->first_attr
= NULL
;
923 entry
->last_attr
= NULL
;
926 assert (list
!= NULL
);
928 if (list
->first_abbrev
== NULL
)
929 list
->first_abbrev
= entry
;
931 list
->last_abbrev
->next
= entry
;
933 list
->last_abbrev
= entry
;
937 add_abbrev_attr (unsigned long attribute
,
939 int64_t implicit_const
,
944 attr
= (abbrev_attr
*) xmalloc (sizeof (*attr
));
946 attr
->attribute
= attribute
;
948 attr
->implicit_const
= implicit_const
;
951 assert (list
!= NULL
&& list
->last_abbrev
!= NULL
);
953 if (list
->last_abbrev
->first_attr
== NULL
)
954 list
->last_abbrev
->first_attr
= attr
;
956 list
->last_abbrev
->last_attr
->next
= attr
;
958 list
->last_abbrev
->last_attr
= attr
;
961 /* Return processed (partial) contents of a .debug_abbrev section.
962 Returns NULL on errors. */
965 process_abbrev_set (struct dwarf_section
*section
,
966 unsigned char *start
,
969 abbrev_list
*list
= xmalloc (sizeof (*list
));
970 list
->first_abbrev
= NULL
;
971 list
->last_abbrev
= NULL
;
979 unsigned long attribute
;
982 READ_ULEB (entry
, start
, end
);
984 /* A single zero is supposed to end the set according
985 to the standard. If there's more, then signal that to
987 if (start
== end
|| entry
== 0)
989 list
->start_of_next_abbrevs
= start
!= end
? start
: NULL
;
993 READ_ULEB (tag
, start
, end
);
995 return free_abbrev_list (list
);
999 add_abbrev (entry
, tag
, children
, list
);
1004 /* Initialize it due to a false compiler warning. */
1005 int64_t implicit_const
= -1;
1007 READ_ULEB (attribute
, start
, end
);
1011 READ_ULEB (form
, start
, end
);
1015 if (form
== DW_FORM_implicit_const
)
1017 READ_SLEB (implicit_const
, start
, end
);
1022 add_abbrev_attr (attribute
, form
, implicit_const
, list
);
1024 while (attribute
!= 0);
1027 /* Report the missing single zero which ends the section. */
1028 error (_("%s section not zero terminated\n"), section
->name
);
1030 return free_abbrev_list (list
);
1033 /* Return a sequence of abbrevs in SECTION starting at ABBREV_BASE
1034 plus ABBREV_OFFSET and finishing at ABBREV_BASE + ABBREV_SIZE.
1035 If FREE_LIST is non-NULL search the already decoded abbrevs on
1036 abbrev_lists first and if found set *FREE_LIST to NULL. If
1037 searching doesn't find a matching abbrev, set *FREE_LIST to the
1038 newly allocated list. If FREE_LIST is NULL, no search is done and
1039 the returned abbrev_list is always newly allocated. */
1041 static abbrev_list
*
1042 find_and_process_abbrev_set (struct dwarf_section
*section
,
1043 uint64_t abbrev_base
,
1044 uint64_t abbrev_size
,
1045 uint64_t abbrev_offset
,
1046 abbrev_list
**free_list
)
1051 if (abbrev_base
>= section
->size
1052 || abbrev_size
> section
->size
- abbrev_base
)
1054 /* PR 17531: file:4bcd9ce9. */
1055 warn (_("Debug info is corrupted, abbrev size (%#" PRIx64
")"
1056 " is larger than abbrev section size (%#" PRIx64
")\n"),
1057 abbrev_base
+ abbrev_size
, section
->size
);
1060 if (abbrev_offset
>= abbrev_size
)
1062 warn (_("Debug info is corrupted, abbrev offset (%#" PRIx64
")"
1063 " is larger than abbrev section size (%#" PRIx64
")\n"),
1064 abbrev_offset
, abbrev_size
);
1068 unsigned char *start
= section
->start
+ abbrev_base
+ abbrev_offset
;
1069 unsigned char *end
= section
->start
+ abbrev_base
+ abbrev_size
;
1070 abbrev_list
*list
= NULL
;
1072 list
= find_abbrev_list_by_raw_abbrev (start
);
1075 list
= process_abbrev_set (section
, start
, end
);
1083 get_TAG_name (uint64_t tag
)
1085 const char *name
= NULL
;
1087 if ((unsigned int) tag
== tag
)
1088 name
= get_DW_TAG_name ((unsigned int) tag
);
1091 static char buffer
[100];
1093 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1094 snprintf (buffer
, sizeof (buffer
),
1095 _("User TAG value: %#" PRIx64
), tag
);
1097 snprintf (buffer
, sizeof (buffer
),
1098 _("Unknown TAG value: %#" PRIx64
), tag
);
1106 get_FORM_name (unsigned long form
)
1108 const char *name
= NULL
;
1111 return "DW_FORM value: 0";
1113 if ((unsigned int) form
== form
)
1114 name
= get_DW_FORM_name ((unsigned int) form
);
1117 static char buffer
[100];
1119 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1127 get_IDX_name (unsigned long idx
)
1129 const char *name
= NULL
;
1131 if ((unsigned int) idx
== idx
)
1132 name
= get_DW_IDX_name ((unsigned int) idx
);
1135 static char buffer
[100];
1137 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1144 static unsigned char *
1145 display_block (unsigned char *data
,
1147 const unsigned char * const end
, char delimiter
)
1151 printf (_("%c%" PRIu64
" byte block: "), delimiter
, length
);
1153 return (unsigned char *) end
;
1155 maxlen
= end
- data
;
1156 length
= length
> maxlen
? maxlen
: length
;
1159 printf ("%" PRIx64
" ", byte_get (data
++, 1));
1165 decode_location_expression (unsigned char * data
,
1166 unsigned int pointer_size
,
1167 unsigned int offset_size
,
1171 struct dwarf_section
* section
)
1176 unsigned char *end
= data
+ length
;
1177 int need_frame_base
= 0;
1186 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1187 printf ("DW_OP_addr: %" PRIx64
, uvalue
);
1190 printf ("DW_OP_deref");
1193 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1194 printf ("DW_OP_const1u: %" PRIu64
, uvalue
);
1197 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1198 printf ("DW_OP_const1s: %" PRId64
, svalue
);
1201 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1202 printf ("DW_OP_const2u: %" PRIu64
, uvalue
);
1205 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1206 printf ("DW_OP_const2s: %" PRId64
, svalue
);
1209 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1210 printf ("DW_OP_const4u: %" PRIu64
, uvalue
);
1213 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1214 printf ("DW_OP_const4s: %" PRId64
, svalue
);
1217 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
1218 printf ("DW_OP_const8u: %" PRIu64
, uvalue
);
1221 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 8, end
);
1222 printf ("DW_OP_const8s: %" PRId64
, svalue
);
1225 READ_ULEB (uvalue
, data
, end
);
1226 printf ("DW_OP_constu: %" PRIu64
, uvalue
);
1229 READ_SLEB (svalue
, data
, end
);
1230 printf ("DW_OP_consts: %" PRId64
, svalue
);
1233 printf ("DW_OP_dup");
1236 printf ("DW_OP_drop");
1239 printf ("DW_OP_over");
1242 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1243 printf ("DW_OP_pick: %" PRIu64
, uvalue
);
1246 printf ("DW_OP_swap");
1249 printf ("DW_OP_rot");
1252 printf ("DW_OP_xderef");
1255 printf ("DW_OP_abs");
1258 printf ("DW_OP_and");
1261 printf ("DW_OP_div");
1264 printf ("DW_OP_minus");
1267 printf ("DW_OP_mod");
1270 printf ("DW_OP_mul");
1273 printf ("DW_OP_neg");
1276 printf ("DW_OP_not");
1279 printf ("DW_OP_or");
1282 printf ("DW_OP_plus");
1284 case DW_OP_plus_uconst
:
1285 READ_ULEB (uvalue
, data
, end
);
1286 printf ("DW_OP_plus_uconst: %" PRIu64
, uvalue
);
1289 printf ("DW_OP_shl");
1292 printf ("DW_OP_shr");
1295 printf ("DW_OP_shra");
1298 printf ("DW_OP_xor");
1301 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1302 printf ("DW_OP_bra: %" PRId64
, svalue
);
1305 printf ("DW_OP_eq");
1308 printf ("DW_OP_ge");
1311 printf ("DW_OP_gt");
1314 printf ("DW_OP_le");
1317 printf ("DW_OP_lt");
1320 printf ("DW_OP_ne");
1323 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1324 printf ("DW_OP_skip: %" PRId64
, svalue
);
1359 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1394 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1395 regname (op
- DW_OP_reg0
, 1));
1430 READ_SLEB (svalue
, data
, end
);
1431 printf ("DW_OP_breg%d (%s): %" PRId64
,
1432 op
- DW_OP_breg0
, regname (op
- DW_OP_breg0
, 1), svalue
);
1436 READ_ULEB (uvalue
, data
, end
);
1437 printf ("DW_OP_regx: %" PRIu64
" (%s)",
1438 uvalue
, regname (uvalue
, 1));
1441 need_frame_base
= 1;
1442 READ_SLEB (svalue
, data
, end
);
1443 printf ("DW_OP_fbreg: %" PRId64
, svalue
);
1446 READ_ULEB (uvalue
, data
, end
);
1447 READ_SLEB (svalue
, data
, end
);
1448 printf ("DW_OP_bregx: %" PRIu64
" (%s) %" PRId64
,
1449 uvalue
, regname (uvalue
, 1), svalue
);
1452 READ_ULEB (uvalue
, data
, end
);
1453 printf ("DW_OP_piece: %" PRIu64
, uvalue
);
1455 case DW_OP_deref_size
:
1456 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1457 printf ("DW_OP_deref_size: %" PRIu64
, uvalue
);
1459 case DW_OP_xderef_size
:
1460 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1461 printf ("DW_OP_xderef_size: %" PRIu64
, uvalue
);
1464 printf ("DW_OP_nop");
1467 /* DWARF 3 extensions. */
1468 case DW_OP_push_object_address
:
1469 printf ("DW_OP_push_object_address");
1472 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1473 this ought to be an 8-byte wide computation. */
1474 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1475 printf ("DW_OP_call2: <%#" PRIx64
">", svalue
+ cu_offset
);
1478 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1479 this ought to be an 8-byte wide computation. */
1480 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1481 printf ("DW_OP_call4: <%#" PRIx64
">", svalue
+ cu_offset
);
1483 case DW_OP_call_ref
:
1484 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1485 this ought to be an 8-byte wide computation. */
1486 if (dwarf_version
== -1)
1488 printf (_("(DW_OP_call_ref in frame info)"));
1489 /* No way to tell where the next op is, so just bail. */
1490 return need_frame_base
;
1492 if (dwarf_version
== 2)
1494 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1498 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1500 printf ("DW_OP_call_ref: <%#" PRIx64
">", uvalue
);
1502 case DW_OP_form_tls_address
:
1503 printf ("DW_OP_form_tls_address");
1505 case DW_OP_call_frame_cfa
:
1506 printf ("DW_OP_call_frame_cfa");
1508 case DW_OP_bit_piece
:
1509 printf ("DW_OP_bit_piece: ");
1510 READ_ULEB (uvalue
, data
, end
);
1511 printf (_("size: %" PRIu64
" "), uvalue
);
1512 READ_ULEB (uvalue
, data
, end
);
1513 printf (_("offset: %" PRIu64
" "), uvalue
);
1516 /* DWARF 4 extensions. */
1517 case DW_OP_stack_value
:
1518 printf ("DW_OP_stack_value");
1521 case DW_OP_implicit_value
:
1522 printf ("DW_OP_implicit_value");
1523 READ_ULEB (uvalue
, data
, end
);
1524 data
= display_block (data
, uvalue
, end
, ' ');
1527 /* GNU extensions. */
1528 case DW_OP_GNU_push_tls_address
:
1529 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1531 case DW_OP_GNU_uninit
:
1532 printf ("DW_OP_GNU_uninit");
1533 /* FIXME: Is there data associated with this OP ? */
1535 case DW_OP_GNU_encoded_addr
:
1542 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1544 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1545 print_hex_ns (addr
, pointer_size
);
1548 case DW_OP_implicit_pointer
:
1549 case DW_OP_GNU_implicit_pointer
:
1550 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1551 this ought to be an 8-byte wide computation. */
1552 if (dwarf_version
== -1)
1554 printf (_("(%s in frame info)"),
1555 (op
== DW_OP_implicit_pointer
1556 ? "DW_OP_implicit_pointer"
1557 : "DW_OP_GNU_implicit_pointer"));
1558 /* No way to tell where the next op is, so just bail. */
1559 return need_frame_base
;
1561 if (dwarf_version
== 2)
1563 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1567 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1569 READ_SLEB (svalue
, data
, end
);
1570 printf ("%s: <%#" PRIx64
"> %" PRId64
,
1571 (op
== DW_OP_implicit_pointer
1572 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1575 case DW_OP_entry_value
:
1576 case DW_OP_GNU_entry_value
:
1577 READ_ULEB (uvalue
, data
, end
);
1578 /* PR 17531: file: 0cc9cd00. */
1579 if (uvalue
> (size_t) (end
- data
))
1580 uvalue
= end
- data
;
1581 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1582 : "DW_OP_GNU_entry_value"));
1583 if (decode_location_expression (data
, pointer_size
, offset_size
,
1584 dwarf_version
, uvalue
,
1585 cu_offset
, section
))
1586 need_frame_base
= 1;
1590 case DW_OP_const_type
:
1591 case DW_OP_GNU_const_type
:
1592 READ_ULEB (uvalue
, data
, end
);
1593 printf ("%s: <%#" PRIx64
"> ",
1594 (op
== DW_OP_const_type
? "DW_OP_const_type"
1595 : "DW_OP_GNU_const_type"),
1596 cu_offset
+ uvalue
);
1597 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1598 data
= display_block (data
, uvalue
, end
, ' ');
1600 case DW_OP_regval_type
:
1601 case DW_OP_GNU_regval_type
:
1602 READ_ULEB (uvalue
, data
, end
);
1603 printf ("%s: %" PRIu64
" (%s)",
1604 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1605 : "DW_OP_GNU_regval_type"),
1606 uvalue
, regname (uvalue
, 1));
1607 READ_ULEB (uvalue
, data
, end
);
1608 printf (" <%#" PRIx64
">", cu_offset
+ uvalue
);
1610 case DW_OP_deref_type
:
1611 case DW_OP_GNU_deref_type
:
1612 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1613 printf ("%s: %" PRId64
,
1614 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1615 : "DW_OP_GNU_deref_type"),
1617 READ_ULEB (uvalue
, data
, end
);
1618 printf (" <%#" PRIx64
">", cu_offset
+ uvalue
);
1621 case DW_OP_GNU_convert
:
1622 READ_ULEB (uvalue
, data
, end
);
1623 printf ("%s <%#" PRIx64
">",
1624 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1625 uvalue
? cu_offset
+ uvalue
: uvalue
);
1627 case DW_OP_reinterpret
:
1628 case DW_OP_GNU_reinterpret
:
1629 READ_ULEB (uvalue
, data
, end
);
1630 printf ("%s <%#" PRIx64
">",
1631 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1632 : "DW_OP_GNU_reinterpret"),
1633 uvalue
? cu_offset
+ uvalue
: uvalue
);
1635 case DW_OP_GNU_parameter_ref
:
1636 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1637 printf ("DW_OP_GNU_parameter_ref: <%#" PRIx64
">",
1638 cu_offset
+ uvalue
);
1641 READ_ULEB (uvalue
, data
, end
);
1642 printf ("DW_OP_addrx <%#" PRIx64
">", uvalue
);
1644 case DW_OP_GNU_addr_index
:
1645 READ_ULEB (uvalue
, data
, end
);
1646 printf ("DW_OP_GNU_addr_index <%#" PRIx64
">", uvalue
);
1648 case DW_OP_GNU_const_index
:
1649 READ_ULEB (uvalue
, data
, end
);
1650 printf ("DW_OP_GNU_const_index <%#" PRIx64
">", uvalue
);
1652 case DW_OP_GNU_variable_value
:
1653 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1654 this ought to be an 8-byte wide computation. */
1655 if (dwarf_version
== -1)
1657 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1658 /* No way to tell where the next op is, so just bail. */
1659 return need_frame_base
;
1661 if (dwarf_version
== 2)
1663 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1667 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1669 printf ("DW_OP_GNU_variable_value: <%#" PRIx64
">", uvalue
);
1672 /* HP extensions. */
1673 case DW_OP_HP_is_value
:
1674 printf ("DW_OP_HP_is_value");
1675 /* FIXME: Is there data associated with this OP ? */
1677 case DW_OP_HP_fltconst4
:
1678 printf ("DW_OP_HP_fltconst4");
1679 /* FIXME: Is there data associated with this OP ? */
1681 case DW_OP_HP_fltconst8
:
1682 printf ("DW_OP_HP_fltconst8");
1683 /* FIXME: Is there data associated with this OP ? */
1685 case DW_OP_HP_mod_range
:
1686 printf ("DW_OP_HP_mod_range");
1687 /* FIXME: Is there data associated with this OP ? */
1689 case DW_OP_HP_unmod_range
:
1690 printf ("DW_OP_HP_unmod_range");
1691 /* FIXME: Is there data associated with this OP ? */
1694 printf ("DW_OP_HP_tls");
1695 /* FIXME: Is there data associated with this OP ? */
1698 /* PGI (STMicroelectronics) extensions. */
1699 case DW_OP_PGI_omp_thread_num
:
1700 /* Pushes the thread number for the current thread as it would be
1701 returned by the standard OpenMP library function:
1702 omp_get_thread_num(). The "current thread" is the thread for
1703 which the expression is being evaluated. */
1704 printf ("DW_OP_PGI_omp_thread_num");
1708 if (op
>= DW_OP_lo_user
1709 && op
<= DW_OP_hi_user
)
1710 printf (_("(User defined location op %#x)"), op
);
1712 printf (_("(Unknown location op %#x)"), op
);
1713 /* No way to tell where the next op is, so just bail. */
1714 return need_frame_base
;
1717 /* Separate the ops. */
1722 return need_frame_base
;
1725 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1726 This is used for DWARF package files. */
1728 static struct cu_tu_set
*
1729 find_cu_tu_set_v2 (uint64_t cu_offset
, int do_types
)
1731 struct cu_tu_set
*p
;
1733 unsigned int dw_sect
;
1739 dw_sect
= DW_SECT_TYPES
;
1745 dw_sect
= DW_SECT_INFO
;
1749 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1758 fetch_alt_indirect_string (uint64_t offset
)
1762 if (! do_follow_links
)
1765 if (first_separate_info
== NULL
)
1766 return _("<no links available>");
1768 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1770 struct dwarf_section
* section
;
1773 if (! load_debug_section (separate_debug_str
, i
->handle
))
1776 section
= &debug_displays
[separate_debug_str
].section
;
1778 if (section
->start
== NULL
)
1781 if (offset
>= section
->size
)
1784 ret
= (const char *) (section
->start
+ offset
);
1785 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1786 NUL byte. Since our caller is expecting to receive a well formed C
1787 string we test for the lack of a terminating byte here. */
1788 if (strnlen ((const char *) ret
, section
->size
- offset
)
1789 == section
->size
- offset
)
1790 return _("<no NUL byte at end of alt .debug_str section>");
1795 warn (_("DW_FORM_GNU_strp_alt offset (%#" PRIx64
")"
1796 " too big or no string sections available\n"), offset
);
1797 return _("<offset is too big>");
1801 get_AT_name (unsigned long attribute
)
1806 return "DW_AT value: 0";
1808 /* One value is shared by the MIPS and HP extensions: */
1809 if (attribute
== DW_AT_MIPS_fde
)
1810 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1812 name
= get_DW_AT_name (attribute
);
1816 static char buffer
[100];
1818 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1827 add_dwo_info (const char * value
, uint64_t cu_offset
, dwo_type type
)
1829 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1831 dwinfo
->type
= type
;
1832 dwinfo
->value
= value
;
1833 dwinfo
->cu_offset
= cu_offset
;
1834 dwinfo
->next
= first_dwo_info
;
1835 first_dwo_info
= dwinfo
;
1839 add_dwo_name (const char * name
, uint64_t cu_offset
)
1841 add_dwo_info (name
, cu_offset
, DWO_NAME
);
1845 add_dwo_dir (const char * dir
, uint64_t cu_offset
)
1847 add_dwo_info (dir
, cu_offset
, DWO_DIR
);
1851 add_dwo_id (const char * id
, uint64_t cu_offset
)
1853 add_dwo_info (id
, cu_offset
, DWO_ID
);
1857 free_dwo_info (void)
1862 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1864 next
= dwinfo
->next
;
1867 first_dwo_info
= NULL
;
1870 /* Ensure that START + UVALUE is less than END.
1871 Return an adjusted UVALUE if necessary to ensure this relationship. */
1873 static inline uint64_t
1874 check_uvalue (const unsigned char *start
,
1876 const unsigned char *end
)
1878 uint64_t max_uvalue
= end
- start
;
1880 /* See PR 17512: file: 008-103549-0.001:0.1.
1881 and PR 24829 for examples of where these tests are triggered. */
1882 if (uvalue
> max_uvalue
)
1884 warn (_("Corrupt attribute block length: %#" PRIx64
"\n"), uvalue
);
1885 uvalue
= max_uvalue
;
1891 static unsigned char *
1892 skip_attr_bytes (unsigned long form
,
1893 unsigned char *data
,
1895 uint64_t pointer_size
,
1896 uint64_t offset_size
,
1898 uint64_t *value_return
)
1901 uint64_t uvalue
= 0;
1908 case DW_FORM_ref_addr
:
1909 if (dwarf_version
== 2)
1910 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1911 else if (dwarf_version
> 2)
1912 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1918 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1922 case DW_FORM_line_strp
:
1923 case DW_FORM_sec_offset
:
1924 case DW_FORM_GNU_ref_alt
:
1925 case DW_FORM_GNU_strp_alt
:
1926 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1929 case DW_FORM_flag_present
:
1937 case DW_FORM_addrx1
:
1938 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1942 case DW_FORM_addrx3
:
1943 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
1949 case DW_FORM_addrx2
:
1950 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1956 case DW_FORM_addrx4
:
1957 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1961 READ_SLEB (svalue
, data
, end
);
1965 case DW_FORM_ref_udata
:
1967 case DW_FORM_GNU_str_index
:
1969 case DW_FORM_GNU_addr_index
:
1971 case DW_FORM_loclistx
:
1972 case DW_FORM_rnglistx
:
1973 READ_ULEB (uvalue
, data
, end
);
1977 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
1981 case DW_FORM_ref_sig8
:
1985 case DW_FORM_data16
:
1989 case DW_FORM_string
:
1990 inc
= strnlen ((char *) data
, end
- data
) + 1;
1994 case DW_FORM_exprloc
:
1995 READ_ULEB (uvalue
, data
, end
);
1999 case DW_FORM_block1
:
2000 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2004 case DW_FORM_block2
:
2005 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2009 case DW_FORM_block4
:
2010 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2014 case DW_FORM_indirect
:
2015 READ_ULEB (form
, data
, end
);
2016 if (form
== DW_FORM_implicit_const
)
2017 SKIP_ULEB (data
, end
);
2018 return skip_attr_bytes (form
, data
, end
, pointer_size
, offset_size
,
2019 dwarf_version
, value_return
);
2025 * value_return
= uvalue
;
2026 if (inc
<= (size_t) (end
- data
))
2033 /* Given form FORM with value UVALUE, locate and return the abbreviation
2034 associated with it. */
2036 static abbrev_entry
*
2037 get_type_abbrev_from_form (unsigned long form
,
2038 unsigned long uvalue
,
2040 unsigned char *cu_end
,
2041 const struct dwarf_section
*section
,
2042 unsigned long *abbrev_num_return
,
2043 unsigned char **data_return
,
2044 abbrev_map
**map_return
)
2046 unsigned long abbrev_number
;
2048 abbrev_entry
* entry
;
2049 unsigned char * data
;
2051 if (abbrev_num_return
!= NULL
)
2052 * abbrev_num_return
= 0;
2053 if (data_return
!= NULL
)
2054 * data_return
= NULL
;
2058 case DW_FORM_GNU_ref_alt
:
2059 case DW_FORM_ref_sig8
:
2060 /* FIXME: We are unable to handle this form at the moment. */
2063 case DW_FORM_ref_addr
:
2064 if (uvalue
>= section
->size
)
2066 warn (_("Unable to resolve ref_addr form: uvalue %lx "
2067 "> section size %" PRIx64
" (%s)\n"),
2068 uvalue
, section
->size
, section
->name
);
2073 case DW_FORM_ref_sup4
:
2074 case DW_FORM_ref_sup8
:
2081 case DW_FORM_ref_udata
:
2082 if (uvalue
+ cu_offset
< uvalue
2083 || uvalue
+ cu_offset
> (size_t) (cu_end
- section
->start
))
2085 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %" PRIx64
2086 " > CU size %tx\n"),
2087 uvalue
, cu_offset
, cu_end
- section
->start
);
2090 uvalue
+= cu_offset
;
2093 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2096 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2100 data
= (unsigned char *) section
->start
+ uvalue
;
2101 map
= find_abbrev_map_by_offset (uvalue
);
2105 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2108 if (map
->list
== NULL
)
2110 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2114 if (map_return
!= NULL
)
2116 if (form
== DW_FORM_ref_addr
)
2122 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2124 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2125 if (entry
->number
== abbrev_number
)
2128 if (abbrev_num_return
!= NULL
)
2129 * abbrev_num_return
= abbrev_number
;
2131 if (data_return
!= NULL
)
2132 * data_return
= data
;
2135 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2140 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2141 can be determined to be a signed type. The data for ENTRY can be
2142 found starting at DATA. */
2145 get_type_signedness (abbrev_entry
*entry
,
2146 const struct dwarf_section
*section
,
2147 unsigned char *data
,
2150 uint64_t pointer_size
,
2151 uint64_t offset_size
,
2154 unsigned int nesting
)
2158 * is_signed
= false;
2160 #define MAX_NESTING 20
2161 if (nesting
> MAX_NESTING
)
2163 /* FIXME: Warn - or is this expected ?
2164 NB/ We need to avoid infinite recursion. */
2168 for (attr
= entry
->first_attr
;
2169 attr
!= NULL
&& attr
->attribute
;
2172 unsigned char * orig_data
= data
;
2173 uint64_t uvalue
= 0;
2175 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2176 offset_size
, dwarf_version
, & uvalue
);
2180 switch (attr
->attribute
)
2182 case DW_AT_linkage_name
:
2186 if (attr
->form
== DW_FORM_strp
)
2187 printf (", %s", fetch_indirect_string (uvalue
));
2188 else if (attr
->form
== DW_FORM_string
)
2189 printf (", %.*s", (int) (end
- orig_data
), orig_data
);
2196 abbrev_entry
*type_abbrev
;
2197 unsigned char *type_data
;
2200 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2205 NULL
/* abbrev num return */,
2208 if (type_abbrev
== NULL
)
2211 get_type_signedness (type_abbrev
, section
, type_data
,
2212 map
? section
->start
+ map
->end
: end
,
2213 map
? map
->start
: cu_offset
,
2214 pointer_size
, offset_size
, dwarf_version
,
2215 is_signed
, nesting
+ 1);
2219 case DW_AT_encoding
:
2220 /* Determine signness. */
2223 case DW_ATE_address
:
2224 /* FIXME - some architectures have signed addresses. */
2225 case DW_ATE_boolean
:
2226 case DW_ATE_unsigned
:
2227 case DW_ATE_unsigned_char
:
2228 case DW_ATE_unsigned_fixed
:
2229 * is_signed
= false;
2233 case DW_ATE_complex_float
:
2236 case DW_ATE_signed_char
:
2237 case DW_ATE_imaginary_float
:
2238 case DW_ATE_decimal_float
:
2239 case DW_ATE_signed_fixed
:
2249 read_and_print_leb128 (unsigned char *data
,
2250 unsigned int *bytes_read
,
2251 unsigned const char *end
,
2255 uint64_t val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2257 report_leb_status (status
);
2259 printf ("%" PRId64
, val
);
2261 printf ("%" PRIu64
, val
);
2265 display_discr_list (unsigned long form
,
2267 unsigned char *data
,
2270 unsigned char *end
= data
;
2274 printf ("[default]");
2281 case DW_FORM_block1
:
2282 case DW_FORM_block2
:
2283 case DW_FORM_block4
:
2284 /* Move data pointer back to the start of the byte array. */
2288 printf ("<corrupt>\n");
2289 warn (_("corrupt discr_list - not using a block form\n"));
2295 printf ("<corrupt>\n");
2296 warn (_("corrupt discr_list - block not long enough\n"));
2300 bool is_signed
= (level
> 0 && level
<= MAX_CU_NESTING
2301 ? level_type_signed
[level
- 1] : false);
2306 unsigned char discriminant
;
2307 unsigned int bytes_read
;
2309 SAFE_BYTE_GET_AND_INC (discriminant
, data
, 1, end
);
2311 switch (discriminant
)
2315 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2321 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2325 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2330 printf ("<corrupt>\n");
2331 warn (_("corrupt discr_list - unrecognized discriminant byte %#x\n"),
2341 printf (")(signed)");
2343 printf (")(unsigned)");
2347 display_lang (uint64_t uvalue
)
2351 /* Ordered by the numeric value of these constants. */
2352 case DW_LANG_C89
: printf ("ANSI C"); break;
2353 case DW_LANG_C
: printf ("non-ANSI C"); break;
2354 case DW_LANG_Ada83
: printf ("Ada"); break;
2355 case DW_LANG_C_plus_plus
: printf ("C++"); break;
2356 case DW_LANG_Cobol74
: printf ("Cobol 74"); break;
2357 case DW_LANG_Cobol85
: printf ("Cobol 85"); break;
2358 case DW_LANG_Fortran77
: printf ("FORTRAN 77"); break;
2359 case DW_LANG_Fortran90
: printf ("Fortran 90"); break;
2360 case DW_LANG_Pascal83
: printf ("ANSI Pascal"); break;
2361 case DW_LANG_Modula2
: printf ("Modula 2"); break;
2363 /* DWARF 2.1 values. */
2364 case DW_LANG_Java
: printf ("Java"); break;
2365 case DW_LANG_C99
: printf ("ANSI C99"); break;
2366 case DW_LANG_Ada95
: printf ("ADA 95"); break;
2367 case DW_LANG_Fortran95
: printf ("Fortran 95"); break;
2369 /* DWARF 3 values. */
2370 case DW_LANG_PLI
: printf ("PLI"); break;
2371 case DW_LANG_ObjC
: printf ("Objective C"); break;
2372 case DW_LANG_ObjC_plus_plus
: printf ("Objective C++"); break;
2373 case DW_LANG_UPC
: printf ("Unified Parallel C"); break;
2374 case DW_LANG_D
: printf ("D"); break;
2376 /* DWARF 4 values. */
2377 case DW_LANG_Python
: printf ("Python"); break;
2379 /* DWARF 5 values. */
2380 case DW_LANG_OpenCL
: printf ("OpenCL"); break;
2381 case DW_LANG_Go
: printf ("Go"); break;
2382 case DW_LANG_Modula3
: printf ("Modula 3"); break;
2383 case DW_LANG_Haskell
: printf ("Haskell"); break;
2384 case DW_LANG_C_plus_plus_03
: printf ("C++03"); break;
2385 case DW_LANG_C_plus_plus_11
: printf ("C++11"); break;
2386 case DW_LANG_OCaml
: printf ("OCaml"); break;
2387 case DW_LANG_Rust
: printf ("Rust"); break;
2388 case DW_LANG_C11
: printf ("C11"); break;
2389 case DW_LANG_Swift
: printf ("Swift"); break;
2390 case DW_LANG_Julia
: printf ("Julia"); break;
2391 case DW_LANG_Dylan
: printf ("Dylan"); break;
2392 case DW_LANG_C_plus_plus_14
: printf ("C++14"); break;
2393 case DW_LANG_Fortran03
: printf ("Fortran 03"); break;
2394 case DW_LANG_Fortran08
: printf ("Fortran 08"); break;
2395 case DW_LANG_RenderScript
: printf ("RenderScript"); break;
2397 /* MIPS extension. */
2398 case DW_LANG_Mips_Assembler
: printf ("MIPS assembler"); break;
2400 /* UPC extension. */
2401 case DW_LANG_Upc
: printf ("Unified Parallel C"); break;
2404 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2405 printf (_("implementation defined: %#" PRIx64
""), uvalue
);
2407 printf (_("unknown: %#" PRIx64
""), uvalue
);
2412 static unsigned char *
2413 read_and_display_attr_value (unsigned long attribute
,
2415 int64_t implicit_const
,
2416 unsigned char *start
,
2417 unsigned char *data
,
2420 uint64_t pointer_size
,
2421 uint64_t offset_size
,
2423 debug_info
*debug_info_p
,
2425 struct dwarf_section
*section
,
2426 struct cu_tu_set
*this_set
,
2431 uint64_t uvalue
= 0;
2432 uint64_t uvalue_hi
= 0;
2433 unsigned char *block_start
= NULL
;
2434 unsigned char *orig_data
= data
;
2436 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2438 warn (_("Corrupt attribute\n"));
2442 if (do_wide
&& ! do_loc
)
2444 /* PR 26847: Display the name of the form. */
2445 const char * name
= get_FORM_name (form
);
2447 /* For convenience we skip the DW_FORM_ prefix to the name. */
2449 name
+= 8; /* strlen ("DW_FORM_") */
2450 printf ("%c(%s)", delimiter
, name
);
2455 case DW_FORM_ref_addr
:
2456 if (dwarf_version
== 2)
2457 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2458 else if (dwarf_version
> 2)
2459 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2461 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2465 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2468 case DW_FORM_strp_sup
:
2470 case DW_FORM_line_strp
:
2471 case DW_FORM_sec_offset
:
2472 case DW_FORM_GNU_ref_alt
:
2473 case DW_FORM_GNU_strp_alt
:
2474 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2477 case DW_FORM_flag_present
:
2485 case DW_FORM_addrx1
:
2486 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2492 case DW_FORM_addrx2
:
2493 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2497 case DW_FORM_addrx3
:
2498 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2501 case DW_FORM_ref_sup4
:
2505 case DW_FORM_addrx4
:
2506 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2509 case DW_FORM_ref_sup8
:
2512 case DW_FORM_ref_sig8
:
2513 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2516 case DW_FORM_data16
:
2517 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2518 SAFE_BYTE_GET_AND_INC (uvalue_hi
, data
, 8, end
);
2519 if (byte_get
!= byte_get_little_endian
)
2521 uint64_t utmp
= uvalue
;
2528 READ_SLEB (svalue
, data
, end
);
2532 case DW_FORM_GNU_str_index
:
2534 case DW_FORM_ref_udata
:
2536 case DW_FORM_GNU_addr_index
:
2538 case DW_FORM_loclistx
:
2539 case DW_FORM_rnglistx
:
2540 READ_ULEB (uvalue
, data
, end
);
2543 case DW_FORM_indirect
:
2544 READ_ULEB (form
, data
, end
);
2546 printf ("%c%s", delimiter
, get_FORM_name (form
));
2547 if (form
== DW_FORM_implicit_const
)
2548 READ_SLEB (implicit_const
, data
, end
);
2549 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2551 cu_offset
, pointer_size
,
2552 offset_size
, dwarf_version
,
2553 debug_info_p
, do_loc
,
2554 section
, this_set
, delimiter
, level
);
2556 case DW_FORM_implicit_const
:
2557 uvalue
= implicit_const
;
2566 case DW_FORM_ref_addr
:
2568 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
);
2571 case DW_FORM_GNU_ref_alt
:
2575 /* We have already printed the form name. */
2576 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
);
2578 printf ("%c<alt %#" PRIx64
">", delimiter
, uvalue
);
2580 /* FIXME: Follow the reference... */
2586 case DW_FORM_ref_sup4
:
2587 case DW_FORM_ref_udata
:
2589 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
+ cu_offset
);
2594 case DW_FORM_sec_offset
:
2596 printf ("%c%#" PRIx64
, delimiter
, uvalue
);
2599 case DW_FORM_flag_present
:
2605 printf ("%c%" PRId64
, delimiter
, uvalue
);
2610 printf ("%c%" PRIu64
, delimiter
, uvalue
);
2613 case DW_FORM_implicit_const
:
2615 printf ("%c%" PRId64
, delimiter
, implicit_const
);
2618 case DW_FORM_ref_sup8
:
2623 uint64_t utmp
= uvalue
;
2624 if (form
== DW_FORM_ref8
)
2626 printf ("%c%#" PRIx64
, delimiter
, utmp
);
2630 case DW_FORM_data16
:
2634 printf (" %#" PRIx64
, uvalue
);
2636 printf (" %#" PRIx64
"%016" PRIx64
, uvalue_hi
, uvalue
);
2640 case DW_FORM_string
:
2642 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2643 data
+= strnlen ((char *) data
, end
- data
);
2649 case DW_FORM_exprloc
:
2650 READ_ULEB (uvalue
, data
, end
);
2653 if (block_start
>= end
)
2655 warn (_("Block ends prematurely\n"));
2660 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2662 data
= block_start
+ uvalue
;
2667 SAFE_BYTE_GET (op
, block_start
, sizeof (op
), end
);
2668 if (op
!= DW_OP_addrx
)
2669 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2673 case DW_FORM_block1
:
2674 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2677 case DW_FORM_block2
:
2678 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2681 case DW_FORM_block4
:
2682 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2689 /* We have already displayed the form name. */
2690 printf (_("%c(offset: %#" PRIx64
"): %s"),
2691 delimiter
, uvalue
, fetch_indirect_string (uvalue
));
2693 printf (_("%c(indirect string, offset: %#" PRIx64
"): %s"),
2694 delimiter
, uvalue
, fetch_indirect_string (uvalue
));
2698 case DW_FORM_line_strp
:
2702 /* We have already displayed the form name. */
2703 printf (_("%c(offset: %#" PRIx64
"): %s"),
2704 delimiter
, uvalue
, fetch_indirect_line_string (uvalue
));
2706 printf (_("%c(indirect line string, offset: %#" PRIx64
"): %s"),
2707 delimiter
, uvalue
, fetch_indirect_line_string (uvalue
));
2711 case DW_FORM_GNU_str_index
:
2719 const char *suffix
= section
? strrchr (section
->name
, '.') : NULL
;
2720 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2723 strng
= fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
,
2724 debug_info_p
? debug_info_p
->str_offsets_base
: 0);
2726 /* We have already displayed the form name. */
2727 printf (_("%c(offset: %#" PRIx64
"): %s"),
2728 delimiter
, uvalue
, strng
);
2730 printf (_("%c(indexed string: %#" PRIx64
"): %s"),
2731 delimiter
, uvalue
, strng
);
2735 case DW_FORM_GNU_strp_alt
:
2739 /* We have already displayed the form name. */
2740 printf (_("%c(offset: %#" PRIx64
") %s"),
2741 delimiter
, uvalue
, fetch_alt_indirect_string (uvalue
));
2743 printf (_("%c(alt indirect string, offset: %#" PRIx64
") %s"),
2744 delimiter
, uvalue
, fetch_alt_indirect_string (uvalue
));
2748 case DW_FORM_indirect
:
2749 /* Handled above. */
2752 case DW_FORM_ref_sig8
:
2754 printf ("%c%s: %#" PRIx64
, delimiter
, do_wide
? "" : "signature",
2758 case DW_FORM_GNU_addr_index
:
2760 case DW_FORM_addrx1
:
2761 case DW_FORM_addrx2
:
2762 case DW_FORM_addrx3
:
2763 case DW_FORM_addrx4
:
2764 case DW_FORM_loclistx
:
2765 case DW_FORM_rnglistx
:
2769 const char *suffix
= strrchr (section
->name
, '.');
2770 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2772 if (form
== DW_FORM_loclistx
)
2776 idx
= fetch_indexed_offset (uvalue
, loclists_dwo
,
2777 debug_info_p
->loclists_base
,
2778 debug_info_p
->offset_size
);
2779 if (idx
!= (uint64_t) -1)
2780 idx
+= (offset_size
== 8) ? 20 : 12;
2782 else if (debug_info_p
== NULL
|| dwarf_version
> 4)
2784 idx
= fetch_indexed_offset (uvalue
, loclists
,
2785 debug_info_p
->loclists_base
,
2786 debug_info_p
->offset_size
);
2790 /* We want to compute:
2791 idx = fetch_indexed_value (uvalue, loclists,
2792 debug_info_p->loclists_base);
2793 idx += debug_info_p->loclists_base;
2794 Fortunately we already have that sum cached in the
2795 loc_offsets array. */
2796 if (uvalue
< debug_info_p
->num_loc_offsets
)
2797 idx
= debug_info_p
->loc_offsets
[uvalue
];
2800 warn (_("loc_offset %" PRIu64
" too big\n"), uvalue
);
2805 else if (form
== DW_FORM_rnglistx
)
2809 idx
= fetch_indexed_offset (uvalue
, rnglists
,
2810 debug_info_p
->rnglists_base
,
2811 debug_info_p
->offset_size
);
2815 if (debug_info_p
== NULL
)
2818 base
= debug_info_p
->rnglists_base
;
2819 idx
= fetch_indexed_offset (uvalue
, rnglists
, base
,
2820 debug_info_p
->offset_size
);
2825 if (debug_info_p
== NULL
)
2827 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2830 base
= debug_info_p
->addr_base
;
2832 base
+= uvalue
* pointer_size
;
2833 idx
= fetch_indexed_addr (base
, pointer_size
);
2836 /* We have already displayed the form name. */
2837 if (idx
!= (uint64_t) -1)
2838 printf (_("%c(index: %#" PRIx64
"): %#" PRIx64
),
2839 delimiter
, uvalue
, idx
);
2843 case DW_FORM_strp_sup
:
2845 printf ("%c<%#" PRIx64
">", delimiter
, uvalue
+ cu_offset
);
2849 warn (_("Unrecognized form: %#lx"), form
);
2850 /* What to do? Consume a byte maybe? */
2855 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
2856 && num_debug_info_entries
== 0
2857 && debug_info_p
!= NULL
)
2861 case DW_AT_loclists_base
:
2862 if (debug_info_p
->loclists_base
)
2863 warn (_("CU @ %#" PRIx64
" has multiple loclists_base values "
2864 "(%#" PRIx64
" and %#" PRIx64
")"),
2865 debug_info_p
->cu_offset
,
2866 debug_info_p
->loclists_base
, uvalue
);
2870 warn (_("CU @ %#" PRIx64
" has has a negative loclists_base "
2871 "value of %#" PRIx64
" - treating as zero"),
2872 debug_info_p
->cu_offset
, svalue
);
2875 debug_info_p
->loclists_base
= uvalue
;
2878 case DW_AT_rnglists_base
:
2879 /* Assignment to debug_info_p->rnglists_base is now elsewhere. */
2882 case DW_AT_str_offsets_base
:
2883 if (debug_info_p
->str_offsets_base
)
2884 warn (_("CU @ %#" PRIx64
" has multiple str_offsets_base values "
2885 "%#" PRIx64
" and %#" PRIx64
")"),
2886 debug_info_p
->cu_offset
,
2887 debug_info_p
->str_offsets_base
, uvalue
);
2891 warn (_("CU @ %#" PRIx64
" has has a negative stroffsets_base "
2892 "value of %#" PRIx64
" - treating as zero"),
2893 debug_info_p
->cu_offset
, svalue
);
2896 debug_info_p
->str_offsets_base
= uvalue
;
2899 case DW_AT_frame_base
:
2900 /* This is crude; the have_frame_base is reset on the next
2901 subprogram, not at the end of the current topmost one. */
2902 have_frame_base
= 1;
2903 frame_base_level
= level
;
2905 case DW_AT_location
:
2906 case DW_AT_GNU_locviews
:
2907 case DW_AT_string_length
:
2908 case DW_AT_return_addr
:
2909 case DW_AT_data_member_location
:
2910 case DW_AT_vtable_elem_location
:
2912 case DW_AT_static_link
:
2913 case DW_AT_use_location
:
2914 case DW_AT_call_value
:
2915 case DW_AT_GNU_call_site_value
:
2916 case DW_AT_call_data_value
:
2917 case DW_AT_GNU_call_site_data_value
:
2918 case DW_AT_call_target
:
2919 case DW_AT_GNU_call_site_target
:
2920 case DW_AT_call_target_clobbered
:
2921 case DW_AT_GNU_call_site_target_clobbered
:
2922 if ((dwarf_version
< 4
2923 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2924 || form
== DW_FORM_sec_offset
2925 || form
== DW_FORM_loclistx
)
2927 /* Process location list. */
2928 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2929 unsigned int num
= debug_info_p
->num_loc_offsets
;
2931 if (lmax
== 0 || num
>= lmax
)
2934 debug_info_p
->loc_offsets
= (uint64_t *)
2935 xcrealloc (debug_info_p
->loc_offsets
,
2936 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2937 debug_info_p
->loc_views
= (uint64_t *)
2938 xcrealloc (debug_info_p
->loc_views
,
2939 lmax
, sizeof (*debug_info_p
->loc_views
));
2940 debug_info_p
->have_frame_base
= (int *)
2941 xcrealloc (debug_info_p
->have_frame_base
,
2942 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2943 debug_info_p
->max_loc_offsets
= lmax
;
2945 if (form
== DW_FORM_loclistx
)
2946 uvalue
= fetch_indexed_offset (num
, loclists
,
2947 debug_info_p
->loclists_base
,
2948 debug_info_p
->offset_size
);
2949 else if (this_set
!= NULL
)
2950 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2952 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2953 if (attribute
!= DW_AT_GNU_locviews
)
2955 /* Corrupt DWARF info can produce more offsets than views.
2956 See PR 23062 for an example. */
2957 if (debug_info_p
->num_loc_offsets
2958 > debug_info_p
->num_loc_views
)
2959 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2962 debug_info_p
->loc_offsets
[num
] = uvalue
;
2963 debug_info_p
->num_loc_offsets
++;
2968 if (debug_info_p
->num_loc_views
> num
)
2970 warn (_("The number of views (%u) is greater than the number of locations (%u)\n"),
2971 debug_info_p
->num_loc_views
, num
);
2972 debug_info_p
->num_loc_views
= num
;
2975 num
= debug_info_p
->num_loc_views
;
2976 if (num
> debug_info_p
->num_loc_offsets
)
2977 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2980 debug_info_p
->loc_views
[num
] = uvalue
;
2981 debug_info_p
->num_loc_views
++;
2988 if (need_base_address
)
2990 if (form
== DW_FORM_addrx
)
2991 uvalue
= fetch_indexed_addr (debug_info_p
->addr_base
2992 + uvalue
* pointer_size
,
2995 debug_info_p
->base_address
= uvalue
;
2999 case DW_AT_GNU_addr_base
:
3000 case DW_AT_addr_base
:
3001 debug_info_p
->addr_base
= uvalue
;
3002 /* Retrieved elsewhere so that it is in
3003 place by the time we read low_pc. */
3006 case DW_AT_GNU_ranges_base
:
3007 debug_info_p
->ranges_base
= uvalue
;
3011 if ((dwarf_version
< 4
3012 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3013 || form
== DW_FORM_sec_offset
3014 || form
== DW_FORM_rnglistx
)
3016 /* Process range list. */
3017 unsigned int lmax
= debug_info_p
->max_range_lists
;
3018 unsigned int num
= debug_info_p
->num_range_lists
;
3020 if (lmax
== 0 || num
>= lmax
)
3023 debug_info_p
->range_lists
= (uint64_t *)
3024 xcrealloc (debug_info_p
->range_lists
,
3025 lmax
, sizeof (*debug_info_p
->range_lists
));
3026 debug_info_p
->max_range_lists
= lmax
;
3029 if (form
== DW_FORM_rnglistx
)
3030 uvalue
= fetch_indexed_offset (uvalue
, rnglists
,
3031 debug_info_p
->rnglists_base
,
3032 debug_info_p
->offset_size
);
3034 debug_info_p
->range_lists
[num
] = uvalue
;
3035 debug_info_p
->num_range_lists
++;
3039 case DW_AT_GNU_dwo_name
:
3040 case DW_AT_dwo_name
:
3045 add_dwo_name ((const char *) fetch_indirect_string (uvalue
),
3048 case DW_FORM_GNU_strp_alt
:
3049 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
3051 case DW_FORM_GNU_str_index
:
3057 add_dwo_name (fetch_indexed_string (uvalue
, this_set
,
3059 debug_info_p
->str_offsets_base
),
3062 case DW_FORM_string
:
3063 add_dwo_name ((const char *) orig_data
, cu_offset
);
3066 warn (_("Unsupported form (%s) for attribute %s\n"),
3067 get_FORM_name (form
), get_AT_name (attribute
));
3072 case DW_AT_comp_dir
:
3073 /* FIXME: Also extract a build-id in a CU/TU. */
3078 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
3080 case DW_FORM_GNU_strp_alt
:
3081 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
3083 case DW_FORM_line_strp
:
3084 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
3086 case DW_FORM_GNU_str_index
:
3092 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false,
3093 debug_info_p
->str_offsets_base
),
3096 case DW_FORM_string
:
3097 add_dwo_dir ((const char *) orig_data
, cu_offset
);
3100 warn (_("Unsupported form (%s) for attribute %s\n"),
3101 get_FORM_name (form
), get_AT_name (attribute
));
3106 case DW_AT_GNU_dwo_id
:
3111 /* FIXME: Record the length of the ID as well ? */
3112 add_dwo_id ((const char *) (data
- 8), cu_offset
);
3115 warn (_("Unsupported form (%s) for attribute %s\n"),
3116 get_FORM_name (form
), get_AT_name (attribute
));
3126 if (do_loc
|| attribute
== 0)
3129 /* For some attributes we can display further information. */
3133 if (level
>= 0 && level
< MAX_CU_NESTING
3134 && uvalue
< (size_t) (end
- start
))
3136 bool is_signed
= false;
3137 abbrev_entry
*type_abbrev
;
3138 unsigned char *type_data
;
3141 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
,
3145 if (type_abbrev
!= NULL
)
3147 get_type_signedness (type_abbrev
, section
, type_data
,
3148 map
? section
->start
+ map
->end
: end
,
3149 map
? map
->start
: cu_offset
,
3150 pointer_size
, offset_size
, dwarf_version
,
3153 level_type_signed
[level
] = is_signed
;
3161 case DW_INL_not_inlined
:
3162 printf (_("(not inlined)"));
3164 case DW_INL_inlined
:
3165 printf (_("(inlined)"));
3167 case DW_INL_declared_not_inlined
:
3168 printf (_("(declared as inline but ignored)"));
3170 case DW_INL_declared_inlined
:
3171 printf (_("(declared as inline and inlined)"));
3174 printf (_(" (Unknown inline attribute value: %#" PRIx64
")"),
3180 case DW_AT_language
:
3182 display_lang (uvalue
);
3186 case DW_AT_encoding
:
3190 case DW_ATE_void
: printf ("(void)"); break;
3191 case DW_ATE_address
: printf ("(machine address)"); break;
3192 case DW_ATE_boolean
: printf ("(boolean)"); break;
3193 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3194 case DW_ATE_float
: printf ("(float)"); break;
3195 case DW_ATE_signed
: printf ("(signed)"); break;
3196 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3197 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3198 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3199 /* DWARF 2.1 values: */
3200 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3201 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3202 /* DWARF 3 values: */
3203 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3204 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3205 case DW_ATE_edited
: printf ("(edited)"); break;
3206 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3207 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3208 /* DWARF 4 values: */
3209 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3210 /* DWARF 5 values: */
3211 case DW_ATE_UCS
: printf ("(UCS)"); break;
3212 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3214 /* HP extensions: */
3215 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3216 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3217 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3218 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3219 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3220 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3221 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3224 if (uvalue
>= DW_ATE_lo_user
3225 && uvalue
<= DW_ATE_hi_user
)
3226 printf (_("(user defined type)"));
3228 printf (_("(unknown type)"));
3233 case DW_AT_accessibility
:
3237 case DW_ACCESS_public
: printf ("(public)"); break;
3238 case DW_ACCESS_protected
: printf ("(protected)"); break;
3239 case DW_ACCESS_private
: printf ("(private)"); break;
3241 printf (_("(unknown accessibility)"));
3246 case DW_AT_visibility
:
3250 case DW_VIS_local
: printf ("(local)"); break;
3251 case DW_VIS_exported
: printf ("(exported)"); break;
3252 case DW_VIS_qualified
: printf ("(qualified)"); break;
3253 default: printf (_("(unknown visibility)")); break;
3257 case DW_AT_endianity
:
3261 case DW_END_default
: printf ("(default)"); break;
3262 case DW_END_big
: printf ("(big)"); break;
3263 case DW_END_little
: printf ("(little)"); break;
3265 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3266 printf (_("(user specified)"));
3268 printf (_("(unknown endianity)"));
3273 case DW_AT_virtuality
:
3277 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3278 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3279 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3280 default: printf (_("(unknown virtuality)")); break;
3284 case DW_AT_identifier_case
:
3288 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3289 case DW_ID_up_case
: printf ("(up_case)"); break;
3290 case DW_ID_down_case
: printf ("(down_case)"); break;
3291 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3292 default: printf (_("(unknown case)")); break;
3296 case DW_AT_calling_convention
:
3300 case DW_CC_normal
: printf ("(normal)"); break;
3301 case DW_CC_program
: printf ("(program)"); break;
3302 case DW_CC_nocall
: printf ("(nocall)"); break;
3303 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3304 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3305 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3306 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3308 if (uvalue
>= DW_CC_lo_user
3309 && uvalue
<= DW_CC_hi_user
)
3310 printf (_("(user defined)"));
3312 printf (_("(unknown convention)"));
3316 case DW_AT_ordering
:
3321 case -1: printf (_("(undefined)")); break;
3322 case 0: printf ("(row major)"); break;
3323 case 1: printf ("(column major)"); break;
3327 case DW_AT_decimal_sign
:
3331 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3332 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3333 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3334 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3335 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3336 default: printf (_("(unrecognised)")); break;
3340 case DW_AT_defaulted
:
3344 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3345 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3346 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3347 default: printf (_("(unrecognised)")); break;
3351 case DW_AT_discr_list
:
3353 display_discr_list (form
, uvalue
, data
, level
);
3356 case DW_AT_frame_base
:
3357 have_frame_base
= 1;
3359 case DW_AT_location
:
3360 case DW_AT_loclists_base
:
3361 case DW_AT_rnglists_base
:
3362 case DW_AT_str_offsets_base
:
3363 case DW_AT_string_length
:
3364 case DW_AT_return_addr
:
3365 case DW_AT_data_member_location
:
3366 case DW_AT_vtable_elem_location
:
3368 case DW_AT_static_link
:
3369 case DW_AT_use_location
:
3370 case DW_AT_call_value
:
3371 case DW_AT_GNU_call_site_value
:
3372 case DW_AT_call_data_value
:
3373 case DW_AT_GNU_call_site_data_value
:
3374 case DW_AT_call_target
:
3375 case DW_AT_GNU_call_site_target
:
3376 case DW_AT_call_target_clobbered
:
3377 case DW_AT_GNU_call_site_target_clobbered
:
3378 if ((dwarf_version
< 4
3379 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3380 || form
== DW_FORM_sec_offset
3381 || form
== DW_FORM_loclistx
)
3383 if (attribute
!= DW_AT_rnglists_base
3384 && attribute
!= DW_AT_str_offsets_base
)
3385 printf (_(" (location list)"));
3388 case DW_AT_allocated
:
3389 case DW_AT_associated
:
3390 case DW_AT_data_location
:
3392 case DW_AT_upper_bound
:
3393 case DW_AT_lower_bound
:
3397 int need_frame_base
;
3400 need_frame_base
= decode_location_expression (block_start
,
3405 cu_offset
, section
);
3407 if (need_frame_base
&& !have_frame_base
)
3408 printf (_(" [without DW_AT_frame_base]"));
3412 case DW_AT_data_bit_offset
:
3413 case DW_AT_byte_size
:
3414 case DW_AT_bit_size
:
3415 case DW_AT_string_length_byte_size
:
3416 case DW_AT_string_length_bit_size
:
3417 case DW_AT_bit_stride
:
3418 if (form
== DW_FORM_exprloc
)
3421 (void) decode_location_expression (block_start
, pointer_size
,
3422 offset_size
, dwarf_version
,
3423 uvalue
, cu_offset
, section
);
3430 unsigned long abbrev_number
;
3431 abbrev_entry
*entry
;
3433 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
, end
,
3434 section
, & abbrev_number
, NULL
, NULL
);
3437 if (form
!= DW_FORM_GNU_ref_alt
)
3438 warn (_("Offset %#" PRIx64
" used as value for DW_AT_import attribute of DIE at offset %#tx is too big.\n"),
3440 orig_data
- section
->start
);
3444 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3445 printf (" (%s)", get_TAG_name (entry
->tag
));
3458 static unsigned char *
3459 read_and_display_attr (unsigned long attribute
,
3461 int64_t implicit_const
,
3462 unsigned char *start
,
3463 unsigned char *data
,
3466 uint64_t pointer_size
,
3467 uint64_t offset_size
,
3469 debug_info
*debug_info_p
,
3471 struct dwarf_section
*section
,
3472 struct cu_tu_set
*this_set
,
3476 printf (" %-18s:", get_AT_name (attribute
));
3477 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3479 cu_offset
, pointer_size
, offset_size
,
3480 dwarf_version
, debug_info_p
,
3481 do_loc
, section
, this_set
, ' ', level
);
3487 /* Like load_debug_section, but if the ordinary call fails, and we are
3488 following debug links, then attempt to load the requested section
3489 from one of the separate debug info files. */
3492 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3495 if (load_debug_section (sec_enum
, handle
))
3497 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3499 /* See if we can associate a filename with this section. */
3502 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3503 if (i
->handle
== handle
)
3505 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3513 if (do_follow_links
)
3517 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3519 if (load_debug_section (sec_enum
, i
->handle
))
3521 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3523 /* FIXME: We should check to see if any of the remaining debug info
3524 files also contain this section, and, umm, do something about it. */
3534 introduce (struct dwarf_section
* section
, bool raw
)
3538 if (do_follow_links
&& section
->filename
)
3539 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3540 section
->name
, section
->filename
);
3542 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3546 if (do_follow_links
&& section
->filename
)
3547 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3548 section
->name
, section
->filename
);
3550 printf (_("Contents of the %s section:\n\n"), section
->name
);
3554 /* Free memory allocated for one unit in debug_information. */
3557 free_debug_information (debug_info
*ent
)
3559 if (ent
->max_loc_offsets
)
3561 free (ent
->loc_offsets
);
3562 free (ent
->loc_views
);
3563 free (ent
->have_frame_base
);
3565 if (ent
->max_range_lists
)
3567 free (ent
->range_lists
);
3571 /* For look-ahead in attributes. When you want to scan a DIE for one specific
3572 attribute and ignore the rest. */
3574 static unsigned char *
3575 skip_attribute (unsigned long form
,
3576 unsigned char * data
,
3577 unsigned char * end
,
3578 uint64_t pointer_size
,
3579 uint64_t offset_size
,
3587 case DW_FORM_ref_addr
:
3588 data
+= dwarf_version
== 2 ? pointer_size
: offset_size
;
3591 data
+= pointer_size
;
3593 case DW_FORM_strp_sup
:
3595 case DW_FORM_line_strp
:
3596 case DW_FORM_sec_offset
:
3597 case DW_FORM_GNU_ref_alt
:
3598 case DW_FORM_GNU_strp_alt
:
3599 data
+= offset_size
;
3605 case DW_FORM_addrx1
:
3611 case DW_FORM_addrx2
:
3615 case DW_FORM_addrx3
:
3618 case DW_FORM_ref_sup4
:
3622 case DW_FORM_addrx4
:
3625 case DW_FORM_ref_sup8
:
3628 case DW_FORM_ref_sig8
:
3631 case DW_FORM_data16
:
3635 READ_SLEB (stemp
, data
, end
);
3637 case DW_FORM_GNU_str_index
:
3639 case DW_FORM_ref_udata
:
3641 case DW_FORM_GNU_addr_index
:
3643 case DW_FORM_loclistx
:
3644 case DW_FORM_rnglistx
:
3645 READ_ULEB (temp
, data
, end
);
3648 case DW_FORM_indirect
:
3649 while (form
== DW_FORM_indirect
)
3650 READ_ULEB (form
, data
, end
);
3651 return skip_attribute (form
, data
, end
, pointer_size
, offset_size
, dwarf_version
);
3653 case DW_FORM_string
:
3654 data
+= strnlen ((char *) data
, end
- data
);
3657 case DW_FORM_exprloc
:
3658 READ_ULEB (temp
, data
, end
);
3661 case DW_FORM_block1
:
3662 SAFE_BYTE_GET_AND_INC (temp
, data
, 1, end
);
3665 case DW_FORM_block2
:
3666 SAFE_BYTE_GET_AND_INC (temp
, data
, 2, end
);
3669 case DW_FORM_block4
:
3670 SAFE_BYTE_GET_AND_INC (temp
, data
, 4, end
);
3673 case DW_FORM_implicit_const
:
3674 case DW_FORM_flag_present
:
3677 warn (_("Unexpected form in top DIE\n"));
3684 read_bases (abbrev_entry
* entry
,
3685 unsigned char * data
,
3686 unsigned char * end
,
3687 int64_t pointer_size
,
3688 uint64_t offset_size
,
3690 debug_info
* debug_info_p
)
3694 for (attr
= entry
->first_attr
;
3695 attr
&& attr
->attribute
;
3700 if (attr
->attribute
== DW_AT_rnglists_base
)
3702 if (attr
->form
== DW_FORM_sec_offset
)
3704 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
3705 debug_info_p
->rnglists_base
= uvalue
;
3708 warn (_("Unexpected form of DW_AT_rnglists_base in the top DIE\n"));
3710 else if (attr
->attribute
== DW_AT_addr_base
|| attr
->attribute
== DW_AT_GNU_addr_base
)
3712 if (attr
->form
== DW_FORM_sec_offset
)
3714 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
3715 debug_info_p
->addr_base
= uvalue
;
3718 warn (_("Unexpected form of DW_AT_addr_base in the top DIE\n"));
3721 data
= skip_attribute (attr
->form
, data
, end
, pointer_size
,
3722 offset_size
, dwarf_version
);
3726 /* Process the contents of a .debug_info section.
3727 If do_loc is TRUE then we are scanning for location lists and dwo tags
3728 and we do not want to display anything to the user.
3729 If do_types is TRUE, we are processing a .debug_types section instead of
3730 a .debug_info section.
3731 The information displayed is restricted by the values in DWARF_START_DIE
3732 and DWARF_CUTOFF_LEVEL.
3733 Returns TRUE upon success. Otherwise an error or warning message is
3734 printed and FALSE is returned. */
3737 process_debug_info (struct dwarf_section
* section
,
3739 enum dwarf_section_display_enum abbrev_sec
,
3743 unsigned char *start
= section
->start
;
3744 unsigned char *end
= start
+ section
->size
;
3745 unsigned char *section_begin
;
3747 unsigned int num_units
= 0;
3749 /* First scan the section to get the number of comp units.
3750 Length sanity checks are done here. */
3751 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3756 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3757 will be the length. For a 64-bit DWARF section, it'll be
3758 the escape code 0xffffffff followed by an 8 byte length. */
3759 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3761 if (length
== 0xffffffff)
3762 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3763 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3765 warn (_("Reserved length value (%#" PRIx64
") found in section %s\n"),
3766 length
, section
->name
);
3770 /* Negative values are illegal, they may even cause infinite
3771 looping. This can happen if we can't accurately apply
3772 relocations to an object file, or if the file is corrupt. */
3773 if (length
> (size_t) (end
- section_begin
))
3775 warn (_("Corrupt unit length (got %#" PRIx64
3776 " expected at most %#tx) in section %s\n"),
3777 length
, end
- section_begin
, section
->name
);
3780 section_begin
+= length
;
3785 error (_("No comp units in %s section ?\n"), section
->name
);
3789 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
3790 && num_debug_info_entries
== 0
3794 /* Then allocate an array to hold the information. */
3795 debug_information
= (debug_info
*) cmalloc (num_units
,
3796 sizeof (* debug_information
));
3797 if (debug_information
== NULL
)
3799 error (_("Not enough memory for a debug info array of %u entries\n"),
3801 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3805 /* PR 17531: file: 92ca3797.
3806 We cannot rely upon the debug_information array being initialised
3807 before it is used. A corrupt file could easily contain references
3808 to a unit for which information has not been made available. So
3809 we ensure that the array is zeroed here. */
3810 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3812 alloc_num_debug_info_entries
= num_units
;
3817 load_debug_section_with_follow (str
, file
);
3818 load_debug_section_with_follow (line_str
, file
);
3819 load_debug_section_with_follow (str_dwo
, file
);
3820 load_debug_section_with_follow (str_index
, file
);
3821 load_debug_section_with_follow (str_index_dwo
, file
);
3822 load_debug_section_with_follow (debug_addr
, file
);
3825 load_debug_section_with_follow (abbrev_sec
, file
);
3826 load_debug_section_with_follow (loclists
, file
);
3827 load_debug_section_with_follow (rnglists
, file
);
3828 load_debug_section_with_follow (loclists_dwo
, file
);
3829 load_debug_section_with_follow (rnglists_dwo
, file
);
3831 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3833 warn (_("Unable to locate %s section!\n"),
3834 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3838 if (!do_loc
&& dwarf_start_die
== 0)
3839 introduce (section
, false);
3841 free_all_abbrevs ();
3843 /* In order to be able to resolve DW_FORM_ref_addr forms we need
3844 to load *all* of the abbrevs for all CUs in this .debug_info
3845 section. This does effectively mean that we (partially) read
3846 every CU header twice. */
3847 for (section_begin
= start
; start
< end
;)
3849 DWARF2_Internal_CompUnit compunit
;
3850 unsigned char *hdrptr
;
3851 uint64_t abbrev_base
;
3854 unsigned int offset_size
;
3855 struct cu_tu_set
*this_set
;
3856 unsigned char *end_cu
;
3859 cu_offset
= start
- section_begin
;
3861 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3863 if (compunit
.cu_length
== 0xffffffff)
3865 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3870 end_cu
= hdrptr
+ compunit
.cu_length
;
3872 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3874 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3876 if (compunit
.cu_version
< 5)
3878 compunit
.cu_unit_type
= DW_UT_compile
;
3879 /* Initialize it due to a false compiler warning. */
3880 compunit
.cu_pointer_size
= -1;
3884 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3885 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3887 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3890 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3893 if (compunit
.cu_unit_type
== DW_UT_split_compile
3894 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3897 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3900 if (this_set
== NULL
)
3903 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3907 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3908 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3912 abbrev_list
*free_list
;
3913 list
= find_and_process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3914 abbrev_base
, abbrev_size
,
3915 compunit
.cu_abbrev_offset
,
3918 if (list
!= NULL
&& list
->first_abbrev
!= NULL
)
3919 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
,
3921 else if (free_list
!= NULL
)
3922 free_abbrev_list (free_list
);
3925 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3927 DWARF2_Internal_CompUnit compunit
;
3928 unsigned char *hdrptr
;
3929 unsigned char *tags
;
3930 int level
, last_level
, saved_level
;
3932 unsigned int offset_size
;
3933 uint64_t signature
= 0;
3934 uint64_t type_offset
= 0;
3935 struct cu_tu_set
*this_set
;
3936 uint64_t abbrev_base
;
3938 unsigned char *end_cu
;
3941 cu_offset
= start
- section_begin
;
3943 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3945 if (compunit
.cu_length
== 0xffffffff)
3947 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3952 end_cu
= hdrptr
+ compunit
.cu_length
;
3954 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3956 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3958 if (compunit
.cu_version
< 5)
3960 compunit
.cu_unit_type
= DW_UT_compile
;
3961 /* Initialize it due to a false compiler warning. */
3962 compunit
.cu_pointer_size
= -1;
3966 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3967 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3969 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3972 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3974 if (this_set
== NULL
)
3977 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3981 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3982 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3985 if (compunit
.cu_version
< 5)
3986 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3988 bool do_dwo_id
= false;
3989 uint64_t dwo_id
= 0;
3990 if (compunit
.cu_unit_type
== DW_UT_split_compile
3991 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3993 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3997 /* PR 17512: file: 001-108546-0.001:0.1. */
3998 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
4000 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
4001 compunit
.cu_pointer_size
, offset_size
);
4002 compunit
.cu_pointer_size
= offset_size
;
4007 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
4008 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
4011 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
4017 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
4018 && num_debug_info_entries
== 0
4019 && alloc_num_debug_info_entries
> unit
4022 free_debug_information (&debug_information
[unit
]);
4023 memset (&debug_information
[unit
], 0, sizeof (*debug_information
));
4024 debug_information
[unit
].pointer_size
= compunit
.cu_pointer_size
;
4025 debug_information
[unit
].offset_size
= offset_size
;
4026 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
4027 debug_information
[unit
].cu_offset
= cu_offset
;
4028 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
4029 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
4032 if (!do_loc
&& dwarf_start_die
== 0)
4034 printf (_(" Compilation Unit @ offset %#" PRIx64
":\n"),
4036 printf (_(" Length: %#" PRIx64
" (%s)\n"),
4038 offset_size
== 8 ? "64-bit" : "32-bit");
4039 printf (_(" Version: %d\n"), compunit
.cu_version
);
4040 if (compunit
.cu_version
>= 5)
4042 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
4044 printf (_(" Unit Type: %s (%x)\n"),
4046 compunit
.cu_unit_type
);
4048 printf (_(" Abbrev Offset: %#" PRIx64
"\n"),
4049 compunit
.cu_abbrev_offset
);
4050 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
4053 printf (_(" Signature: %#" PRIx64
"\n"), signature
);
4054 printf (_(" Type Offset: %#" PRIx64
"\n"), type_offset
);
4057 printf (_(" DWO ID: %#" PRIx64
"\n"), dwo_id
);
4058 if (this_set
!= NULL
)
4060 uint64_t *offsets
= this_set
->section_offsets
;
4061 size_t *sizes
= this_set
->section_sizes
;
4063 printf (_(" Section contributions:\n"));
4064 printf (_(" .debug_abbrev.dwo: %#" PRIx64
" %#zx\n"),
4065 offsets
[DW_SECT_ABBREV
], sizes
[DW_SECT_ABBREV
]);
4066 printf (_(" .debug_line.dwo: %#" PRIx64
" %#zx\n"),
4067 offsets
[DW_SECT_LINE
], sizes
[DW_SECT_LINE
]);
4068 printf (_(" .debug_loc.dwo: %#" PRIx64
" %#zx\n"),
4069 offsets
[DW_SECT_LOC
], sizes
[DW_SECT_LOC
]);
4070 printf (_(" .debug_str_offsets.dwo: %#" PRIx64
" %#zx\n"),
4071 offsets
[DW_SECT_STR_OFFSETS
], sizes
[DW_SECT_STR_OFFSETS
]);
4078 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
4080 warn (_("CU at offset %#" PRIx64
" contains corrupt or "
4081 "unsupported version number: %d.\n"),
4082 cu_offset
, compunit
.cu_version
);
4086 if (compunit
.cu_unit_type
!= DW_UT_compile
4087 && compunit
.cu_unit_type
!= DW_UT_partial
4088 && compunit
.cu_unit_type
!= DW_UT_type
4089 && compunit
.cu_unit_type
!= DW_UT_split_compile
4090 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
4092 warn (_("CU at offset %#" PRIx64
" contains corrupt or "
4093 "unsupported unit type: %d.\n"),
4094 cu_offset
, compunit
.cu_unit_type
);
4098 /* Process the abbrevs used by this compilation unit. */
4100 list
= find_and_process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
4101 abbrev_base
, abbrev_size
,
4102 compunit
.cu_abbrev_offset
, NULL
);
4106 while (tags
< start
)
4108 unsigned long abbrev_number
;
4109 unsigned long die_offset
;
4110 abbrev_entry
*entry
;
4112 int do_printing
= 1;
4114 die_offset
= tags
- section_begin
;
4116 READ_ULEB (abbrev_number
, tags
, start
);
4118 /* A null DIE marks the end of a list of siblings or it may also be
4119 a section padding. */
4120 if (abbrev_number
== 0)
4122 /* Check if it can be a section padding for the last CU. */
4123 if (level
== 0 && start
== end
)
4127 for (chk
= tags
; chk
< start
; chk
++)
4134 if (!do_loc
&& die_offset
>= dwarf_start_die
4135 && (dwarf_cutoff_level
== -1
4136 || level
< dwarf_cutoff_level
))
4137 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
4143 static unsigned num_bogus_warns
= 0;
4145 if (num_bogus_warns
< 3)
4147 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
4148 die_offset
, section
->name
);
4150 if (num_bogus_warns
== 3)
4151 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
4154 if (dwarf_start_die
!= 0 && level
< saved_level
)
4157 free_abbrev_list (list
);
4165 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
4169 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
4170 saved_level
= level
;
4171 do_printing
= (dwarf_cutoff_level
== -1
4172 || level
< dwarf_cutoff_level
);
4174 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
4175 level
, die_offset
, abbrev_number
);
4176 else if (dwarf_cutoff_level
== -1
4177 || last_level
< dwarf_cutoff_level
)
4178 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
4183 /* Scan through the abbreviation list until we reach the
4187 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
4188 if (entry
->number
== abbrev_number
)
4193 if (!do_loc
&& do_printing
)
4198 warn (_("DIE at offset %#lx refers to abbreviation number %lu which does not exist\n"),
4199 die_offset
, abbrev_number
);
4201 free_abbrev_list (list
);
4205 if (!do_loc
&& do_printing
)
4206 printf (" (%s)\n", get_TAG_name (entry
->tag
));
4211 need_base_address
= 0;
4213 case DW_TAG_compile_unit
:
4214 case DW_TAG_skeleton_unit
:
4215 need_base_address
= 1;
4216 need_dwo_info
= do_loc
;
4218 case DW_TAG_entry_point
:
4219 need_base_address
= 0;
4220 /* Assuming that there is no DW_AT_frame_base. */
4221 have_frame_base
= 0;
4223 case DW_TAG_subprogram
:
4224 need_base_address
= 0;
4225 if (level
<= frame_base_level
)
4226 /* Don't reset that for nested subprogram. */
4227 have_frame_base
= 0;
4231 debug_info
*debug_info_p
=
4232 (debug_information
&& unit
< alloc_num_debug_info_entries
)
4233 ? debug_information
+ unit
: NULL
;
4235 assert (!debug_info_p
4236 || (debug_info_p
->num_loc_offsets
4237 == debug_info_p
->num_loc_views
));
4239 /* Look ahead so that the values of DW_AT_rnglists_base,
4240 DW_AT_[GNU_]addr_base are available before attributes that
4241 reference them are parsed in the same DIE.
4242 Only needed for the top DIE on DWARFv5+.
4243 No simiar treatment for loclists_base because there should
4244 be no loclist attributes in top DIE. */
4245 if (compunit
.cu_version
>= 5 && level
== 0)
4252 compunit
.cu_pointer_size
,
4254 compunit
.cu_version
,
4257 /* This check was in place before, keep it. */
4258 stemp
= debug_info_p
->rnglists_base
;
4261 warn (_("CU @ %#" PRIx64
" has has a negative rnglists_base "
4262 "value of %#" PRIx64
" - treating as zero"),
4263 debug_info_p
->cu_offset
, stemp
);
4264 debug_info_p
->rnglists_base
= 0;
4268 for (attr
= entry
->first_attr
;
4269 attr
&& attr
->attribute
;
4272 if (! do_loc
&& do_printing
)
4273 /* Show the offset from where the tag was extracted. */
4274 printf (" <%tx>", tags
- section_begin
);
4275 tags
= read_and_display_attr (attr
->attribute
,
4277 attr
->implicit_const
,
4282 compunit
.cu_pointer_size
,
4284 compunit
.cu_version
,
4286 do_loc
|| ! do_printing
,
4292 /* If a locview attribute appears before a location one,
4293 make sure we don't associate it with an earlier
4296 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
4299 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = -1;
4300 debug_info_p
->num_loc_views
++;
4301 assert (debug_info_p
->num_loc_views
4302 == debug_info_p
->num_loc_offsets
);
4309 warn (_("DIE has locviews without loclist\n"));
4310 debug_info_p
->num_loc_views
--;
4317 if (entry
->children
)
4321 free_abbrev_list (list
);
4324 /* Set num_debug_info_entries here so that it can be used to check if
4325 we need to process .debug_loc and .debug_ranges sections. */
4326 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
|| do_debug_info
)
4327 && num_debug_info_entries
== 0
4330 if (num_units
> alloc_num_debug_info_entries
)
4331 num_debug_info_entries
= alloc_num_debug_info_entries
;
4333 num_debug_info_entries
= num_units
;
4342 /* Locate and scan the .debug_info section in the file and record the pointer
4343 sizes and offsets for the compilation units in it. Usually an executable
4344 will have just one pointer size, but this is not guaranteed, and so we try
4345 not to make any assumptions. Returns zero upon failure, or the number of
4346 compilation units upon success. */
4349 load_debug_info (void * file
)
4351 /* If we have already tried and failed to load the .debug_info
4352 section then do not bother to repeat the task. */
4353 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4356 /* If we already have the information there is nothing else to do. */
4357 if (num_debug_info_entries
> 0)
4358 return num_debug_info_entries
;
4360 /* If this is a DWARF package file, load the CU and TU indexes. */
4361 (void) load_cu_tu_indexes (file
);
4363 if (load_debug_section_with_follow (info
, file
)
4364 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4365 return num_debug_info_entries
;
4367 if (load_debug_section_with_follow (info_dwo
, file
)
4368 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4369 abbrev_dwo
, true, false))
4370 return num_debug_info_entries
;
4372 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4376 /* Read a DWARF .debug_line section header starting at DATA.
4377 Upon success returns an updated DATA pointer and the LINFO
4378 structure and the END_OF_SEQUENCE pointer will be filled in.
4379 Otherwise returns NULL. */
4381 static unsigned char *
4382 read_debug_line_header (struct dwarf_section
* section
,
4383 unsigned char * data
,
4384 unsigned char * end
,
4385 DWARF2_Internal_LineInfo
* linfo
,
4386 unsigned char ** end_of_sequence
)
4388 unsigned char *hdrptr
;
4390 /* Extract information from the Line Number Program Header.
4391 (section 6.2.4 in the Dwarf3 doc). */
4394 /* Get and check the length of the block. */
4395 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4397 if (linfo
->li_length
== 0xffffffff)
4399 /* This section is 64-bit DWARF 3. */
4400 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4401 linfo
->li_offset_size
= 8;
4404 linfo
->li_offset_size
= 4;
4406 if (linfo
->li_length
> (size_t) (end
- hdrptr
))
4408 /* If the length field has a relocation against it, then we should
4409 not complain if it is inaccurate (and probably negative). This
4410 happens in object files when the .debug_line section is actually
4411 comprised of several different .debug_line.* sections, (some of
4412 which may be removed by linker garbage collection), and a relocation
4413 is used to compute the correct length once that is done. */
4414 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4416 linfo
->li_length
= end
- hdrptr
;
4420 warn (_("The length field (%#" PRIx64
")"
4421 " in the debug_line header is wrong"
4422 " - the section is too small\n"),
4427 end
= hdrptr
+ linfo
->li_length
;
4429 /* Get and check the version number. */
4430 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4432 if (linfo
->li_version
!= 2
4433 && linfo
->li_version
!= 3
4434 && linfo
->li_version
!= 4
4435 && linfo
->li_version
!= 5)
4437 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4438 "is currently supported.\n"));
4442 if (linfo
->li_version
>= 5)
4444 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4446 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4447 if (linfo
->li_segment_size
!= 0)
4449 warn (_("The %s section contains "
4450 "unsupported segment selector size: %d.\n"),
4451 section
->name
, linfo
->li_segment_size
);
4456 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4457 linfo
->li_offset_size
, end
);
4458 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4460 if (linfo
->li_version
>= 4)
4462 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4464 if (linfo
->li_max_ops_per_insn
== 0)
4466 warn (_("Invalid maximum operations per insn.\n"));
4471 linfo
->li_max_ops_per_insn
= 1;
4473 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4474 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4475 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4476 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4478 *end_of_sequence
= end
;
4482 static unsigned char *
4483 display_formatted_table (unsigned char *data
,
4484 unsigned char *start
,
4486 const DWARF2_Internal_LineInfo
*linfo
,
4487 struct dwarf_section
*section
,
4490 unsigned char *format_start
, format_count
, *format
, formati
;
4491 uint64_t data_count
, datai
;
4492 unsigned int namepass
, last_entry
= 0;
4493 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4495 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4496 if (do_checks
&& format_count
> 5)
4497 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4498 table_name
, format_count
);
4500 format_start
= data
;
4501 for (formati
= 0; formati
< format_count
; formati
++)
4503 SKIP_ULEB (data
, end
);
4504 SKIP_ULEB (data
, end
);
4507 warn (_("%s: Corrupt format description entry\n"), table_name
);
4512 READ_ULEB (data_count
, data
, end
);
4513 if (data_count
== 0)
4515 printf (_("\n The %s is empty.\n"), table_name
);
4518 else if (data
>= end
4519 || data_count
> (size_t) (end
- data
))
4521 warn (_("%s: Corrupt entry count %#" PRIx64
"\n"), table_name
, data_count
);
4525 else if (format_count
== 0)
4527 warn (_("%s: format count is zero, but the table is not empty\n"),
4532 printf (_("\n The %s (offset %#tx, lines %" PRIu64
", columns %u):\n"),
4533 table_name
, data
- start
, data_count
, format_count
);
4535 printf (_(" Entry"));
4536 /* Delay displaying name as the last entry for better screen layout. */
4537 for (namepass
= 0; namepass
< 2; namepass
++)
4539 format
= format_start
;
4540 for (formati
= 0; formati
< format_count
; formati
++)
4542 uint64_t content_type
;
4544 READ_ULEB (content_type
, format
, end
);
4545 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4546 switch (content_type
)
4549 printf (_("\tName"));
4551 case DW_LNCT_directory_index
:
4552 printf (_("\tDir"));
4554 case DW_LNCT_timestamp
:
4555 printf (_("\tTime"));
4558 printf (_("\tSize"));
4561 printf (_("\tMD5\t\t\t"));
4564 printf (_("\t(Unknown format content type %" PRIu64
")"),
4567 SKIP_ULEB (format
, end
);
4572 for (datai
= 0; datai
< data_count
; datai
++)
4574 unsigned char *datapass
= data
;
4576 printf (" %d", last_entry
++);
4577 /* Delay displaying name as the last entry for better screen layout. */
4578 for (namepass
= 0; namepass
< 2; namepass
++)
4580 format
= format_start
;
4582 for (formati
= 0; formati
< format_count
; formati
++)
4584 uint64_t content_type
, form
;
4586 READ_ULEB (content_type
, format
, end
);
4587 READ_ULEB (form
, format
, end
);
4588 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4589 0, 0, linfo
->li_offset_size
,
4590 linfo
->li_version
, NULL
,
4591 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4592 section
, NULL
, '\t', -1);
4596 if (data
>= end
&& (datai
< data_count
- 1))
4598 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4607 display_debug_sup (struct dwarf_section
* section
,
4608 void * file ATTRIBUTE_UNUSED
)
4610 unsigned char * start
= section
->start
;
4611 unsigned char * end
= section
->start
+ section
->size
;
4612 unsigned int version
;
4613 char is_supplementary
;
4614 const unsigned char * sup_filename
;
4615 size_t sup_filename_len
;
4616 unsigned int num_read
;
4618 uint64_t checksum_len
;
4621 introduce (section
, true);
4622 if (section
->size
< 4)
4624 error (_("corrupt .debug_sup section: size is too small\n"));
4628 /* Read the data. */
4629 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4631 warn (_("corrupt .debug_sup section: version < 5"));
4633 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4634 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4635 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4637 sup_filename
= start
;
4638 if (is_supplementary
&& sup_filename
[0] != 0)
4639 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4641 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4642 if (sup_filename_len
== (size_t) (end
- start
))
4644 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4647 start
+= sup_filename_len
+ 1;
4649 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4652 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4656 if (checksum_len
> (size_t) (end
- start
))
4658 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4659 checksum_len
= end
- start
;
4661 else if (checksum_len
< (size_t) (end
- start
))
4663 warn (_("corrupt .debug_sup section: there are %#" PRIx64
4664 " extra, unused bytes at the end of the section\n"),
4665 (end
- start
) - checksum_len
);
4668 printf (_(" Version: %u\n"), version
);
4669 printf (_(" Is Supp: %u\n"), is_supplementary
);
4670 printf (_(" Filename: %s\n"), sup_filename
);
4671 printf (_(" Checksum Len: %" PRIu64
"\n"), checksum_len
);
4672 if (checksum_len
> 0)
4674 printf (_(" Checksum: "));
4675 while (checksum_len
--)
4676 printf ("0x%x ", * start
++ );
4683 display_debug_lines_raw (struct dwarf_section
* section
,
4684 unsigned char * data
,
4685 unsigned char * end
,
4688 unsigned char *start
= section
->start
;
4689 int verbose_view
= 0;
4691 introduce (section
, true);
4695 static DWARF2_Internal_LineInfo saved_linfo
;
4696 DWARF2_Internal_LineInfo linfo
;
4697 unsigned char *standard_opcodes
;
4698 unsigned char *end_of_sequence
;
4701 if (startswith (section
->name
, ".debug_line.")
4702 /* Note: the following does not apply to .debug_line.dwo sections.
4703 These are full debug_line sections. */
4704 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4706 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4707 section containing just the Line Number Statements. They are
4708 created by the assembler and intended to be used alongside gcc's
4709 -ffunction-sections command line option. When the linker's
4710 garbage collection decides to discard a .text.<foo> section it
4711 can then also discard the line number information in .debug_line.<foo>.
4713 Since the section is a fragment it does not have the details
4714 needed to fill out a LineInfo structure, so instead we use the
4715 details from the last full debug_line section that we processed. */
4716 end_of_sequence
= end
;
4717 standard_opcodes
= NULL
;
4718 linfo
= saved_linfo
;
4719 /* PR 17531: file: 0522b371. */
4720 if (linfo
.li_line_range
== 0)
4722 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4725 reset_state_machine (linfo
.li_default_is_stmt
);
4729 unsigned char * hdrptr
;
4731 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4732 & end_of_sequence
)) == NULL
)
4735 printf (_(" Offset: %#tx\n"), data
- start
);
4736 printf (_(" Length: %" PRId64
"\n"), linfo
.li_length
);
4737 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4738 if (linfo
.li_version
>= 5)
4740 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4741 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4743 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4744 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4745 if (linfo
.li_version
>= 4)
4746 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4747 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4748 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4749 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4750 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4752 /* PR 17512: file: 1665-6428-0.004. */
4753 if (linfo
.li_line_range
== 0)
4755 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4756 linfo
.li_line_range
= 1;
4759 reset_state_machine (linfo
.li_default_is_stmt
);
4761 /* Display the contents of the Opcodes table. */
4762 standard_opcodes
= hdrptr
;
4764 /* PR 17512: file: 002-417945-0.004. */
4765 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4767 warn (_("Line Base extends beyond end of section\n"));
4771 printf (_("\n Opcodes:\n"));
4773 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4774 printf (ngettext (" Opcode %d has %d arg\n",
4775 " Opcode %d has %d args\n",
4776 standard_opcodes
[i
- 1]),
4777 i
, standard_opcodes
[i
- 1]);
4779 /* Display the contents of the Directory table. */
4780 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4782 if (linfo
.li_version
>= 5)
4784 load_debug_section_with_follow (line_str
, file
);
4786 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4788 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4794 printf (_("\n The Directory Table is empty.\n"));
4797 unsigned int last_dir_entry
= 0;
4799 printf (_("\n The Directory Table (offset %#tx):\n"),
4802 while (data
< end
&& *data
!= 0)
4804 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4806 data
+= strnlen ((char *) data
, end
- data
);
4811 /* PR 17512: file: 002-132094-0.004. */
4812 if (data
>= end
- 1)
4816 /* Skip the NUL at the end of the table. */
4820 /* Display the contents of the File Name table. */
4821 if (data
>= end
|| *data
== 0)
4822 printf (_("\n The File Name Table is empty.\n"));
4825 printf (_("\n The File Name Table (offset %#tx):\n"),
4827 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4829 while (data
< end
&& *data
!= 0)
4831 unsigned char *name
;
4834 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4836 data
+= strnlen ((char *) data
, end
- data
);
4840 READ_ULEB (val
, data
, end
);
4841 printf ("%" PRIu64
"\t", val
);
4842 READ_ULEB (val
, data
, end
);
4843 printf ("%" PRIu64
"\t", val
);
4844 READ_ULEB (val
, data
, end
);
4845 printf ("%" PRIu64
"\t", val
);
4846 printf ("%.*s\n", (int)(end
- name
), name
);
4850 warn (_("Corrupt file name table entry\n"));
4856 /* Skip the NUL at the end of the table. */
4862 saved_linfo
= linfo
;
4865 /* Now display the statements. */
4866 if (data
>= end_of_sequence
)
4867 printf (_(" No Line Number Statements.\n"));
4870 printf (_(" Line Number Statements:\n"));
4872 while (data
< end_of_sequence
)
4874 unsigned char op_code
;
4878 printf (" [0x%08tx]", data
- start
);
4882 if (op_code
>= linfo
.li_opcode_base
)
4884 op_code
-= linfo
.li_opcode_base
;
4885 uladv
= (op_code
/ linfo
.li_line_range
);
4886 if (linfo
.li_max_ops_per_insn
== 1)
4888 uladv
*= linfo
.li_min_insn_length
;
4889 state_machine_regs
.address
+= uladv
;
4891 state_machine_regs
.view
= 0;
4892 printf (_(" Special opcode %d: "
4893 "advance Address by %" PRIu64
4894 " to %#" PRIx64
"%s"),
4895 op_code
, uladv
, state_machine_regs
.address
,
4896 verbose_view
&& uladv
4897 ? _(" (reset view)") : "");
4902 = ((state_machine_regs
.op_index
+ uladv
)
4903 / linfo
.li_max_ops_per_insn
)
4904 * linfo
.li_min_insn_length
;
4906 state_machine_regs
.address
+= addrdelta
;
4907 state_machine_regs
.op_index
4908 = (state_machine_regs
.op_index
+ uladv
)
4909 % linfo
.li_max_ops_per_insn
;
4911 state_machine_regs
.view
= 0;
4912 printf (_(" Special opcode %d: "
4913 "advance Address by %" PRIu64
4914 " to %#" PRIx64
"[%d]%s"),
4915 op_code
, uladv
, state_machine_regs
.address
,
4916 state_machine_regs
.op_index
,
4917 verbose_view
&& addrdelta
4918 ? _(" (reset view)") : "");
4920 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4921 state_machine_regs
.line
+= adv
;
4922 printf (_(" and Line by %d to %d"),
4923 adv
, state_machine_regs
.line
);
4924 if (verbose_view
|| state_machine_regs
.view
)
4925 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4928 state_machine_regs
.view
++;
4933 case DW_LNS_extended_op
:
4934 data
+= process_extended_line_op (data
,
4935 linfo
.li_default_is_stmt
,
4940 printf (_(" Copy"));
4941 if (verbose_view
|| state_machine_regs
.view
)
4942 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4945 state_machine_regs
.view
++;
4948 case DW_LNS_advance_pc
:
4949 READ_ULEB (uladv
, data
, end
);
4950 if (linfo
.li_max_ops_per_insn
== 1)
4952 uladv
*= linfo
.li_min_insn_length
;
4953 state_machine_regs
.address
+= uladv
;
4955 state_machine_regs
.view
= 0;
4956 printf (_(" Advance PC by %" PRIu64
4957 " to %#" PRIx64
"%s\n"),
4958 uladv
, state_machine_regs
.address
,
4959 verbose_view
&& uladv
4960 ? _(" (reset view)") : "");
4965 = ((state_machine_regs
.op_index
+ uladv
)
4966 / linfo
.li_max_ops_per_insn
)
4967 * linfo
.li_min_insn_length
;
4968 state_machine_regs
.address
4970 state_machine_regs
.op_index
4971 = (state_machine_regs
.op_index
+ uladv
)
4972 % linfo
.li_max_ops_per_insn
;
4974 state_machine_regs
.view
= 0;
4975 printf (_(" Advance PC by %" PRIu64
4976 " to %#" PRIx64
"[%d]%s\n"),
4977 uladv
, state_machine_regs
.address
,
4978 state_machine_regs
.op_index
,
4979 verbose_view
&& addrdelta
4980 ? _(" (reset view)") : "");
4984 case DW_LNS_advance_line
:
4985 READ_SLEB (adv
, data
, end
);
4986 state_machine_regs
.line
+= adv
;
4987 printf (_(" Advance Line by %d to %d\n"),
4988 adv
, state_machine_regs
.line
);
4991 case DW_LNS_set_file
:
4992 READ_ULEB (uladv
, data
, end
);
4993 printf (_(" Set File Name to entry %" PRIu64
4994 " in the File Name Table\n"), uladv
);
4995 state_machine_regs
.file
= uladv
;
4998 case DW_LNS_set_column
:
4999 READ_ULEB (uladv
, data
, end
);
5000 printf (_(" Set column to %" PRIu64
"\n"), uladv
);
5001 state_machine_regs
.column
= uladv
;
5004 case DW_LNS_negate_stmt
:
5005 adv
= state_machine_regs
.is_stmt
;
5007 printf (_(" Set is_stmt to %d\n"), adv
);
5008 state_machine_regs
.is_stmt
= adv
;
5011 case DW_LNS_set_basic_block
:
5012 printf (_(" Set basic block\n"));
5013 state_machine_regs
.basic_block
= 1;
5016 case DW_LNS_const_add_pc
:
5017 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5018 if (linfo
.li_max_ops_per_insn
)
5020 uladv
*= linfo
.li_min_insn_length
;
5021 state_machine_regs
.address
+= uladv
;
5023 state_machine_regs
.view
= 0;
5024 printf (_(" Advance PC by constant %" PRIu64
5025 " to %#" PRIx64
"%s\n"),
5026 uladv
, state_machine_regs
.address
,
5027 verbose_view
&& uladv
5028 ? _(" (reset view)") : "");
5033 = ((state_machine_regs
.op_index
+ uladv
)
5034 / linfo
.li_max_ops_per_insn
)
5035 * linfo
.li_min_insn_length
;
5036 state_machine_regs
.address
5038 state_machine_regs
.op_index
5039 = (state_machine_regs
.op_index
+ uladv
)
5040 % linfo
.li_max_ops_per_insn
;
5042 state_machine_regs
.view
= 0;
5043 printf (_(" Advance PC by constant %" PRIu64
5044 " to %#" PRIx64
"[%d]%s\n"),
5045 uladv
, state_machine_regs
.address
,
5046 state_machine_regs
.op_index
,
5047 verbose_view
&& addrdelta
5048 ? _(" (reset view)") : "");
5052 case DW_LNS_fixed_advance_pc
:
5053 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5054 state_machine_regs
.address
+= uladv
;
5055 state_machine_regs
.op_index
= 0;
5056 printf (_(" Advance PC by fixed size amount %" PRIu64
5057 " to %#" PRIx64
"\n"),
5058 uladv
, state_machine_regs
.address
);
5059 /* Do NOT reset view. */
5062 case DW_LNS_set_prologue_end
:
5063 printf (_(" Set prologue_end to true\n"));
5066 case DW_LNS_set_epilogue_begin
:
5067 printf (_(" Set epilogue_begin to true\n"));
5070 case DW_LNS_set_isa
:
5071 READ_ULEB (uladv
, data
, end
);
5072 printf (_(" Set ISA to %" PRIu64
"\n"), uladv
);
5076 printf (_(" Unknown opcode %d with operands: "), op_code
);
5078 if (standard_opcodes
!= NULL
)
5079 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5081 READ_ULEB (uladv
, data
, end
);
5082 printf ("%#" PRIx64
"%s", uladv
, i
== 1 ? "" : ", ");
5098 unsigned int directory_index
;
5099 unsigned int modification_date
;
5100 unsigned int length
;
5103 /* Output a decoded representation of the .debug_line section. */
5106 display_debug_lines_decoded (struct dwarf_section
* section
,
5107 unsigned char * start
,
5108 unsigned char * data
,
5109 unsigned char * end
,
5112 static DWARF2_Internal_LineInfo saved_linfo
;
5114 introduce (section
, false);
5118 /* This loop amounts to one iteration per compilation unit. */
5119 DWARF2_Internal_LineInfo linfo
;
5120 unsigned char *standard_opcodes
;
5121 unsigned char *end_of_sequence
;
5123 File_Entry
*file_table
= NULL
;
5124 unsigned int n_files
= 0;
5125 char **directory_table
= NULL
;
5126 unsigned int n_directories
= 0;
5128 if (startswith (section
->name
, ".debug_line.")
5129 /* Note: the following does not apply to .debug_line.dwo sections.
5130 These are full debug_line sections. */
5131 && strcmp (section
->name
, ".debug_line.dwo") != 0)
5133 /* See comment in display_debug_lines_raw(). */
5134 end_of_sequence
= end
;
5135 standard_opcodes
= NULL
;
5136 linfo
= saved_linfo
;
5137 /* PR 17531: file: 0522b371. */
5138 if (linfo
.li_line_range
== 0)
5140 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
5143 reset_state_machine (linfo
.li_default_is_stmt
);
5147 unsigned char *hdrptr
;
5149 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
5150 & end_of_sequence
)) == NULL
)
5153 /* PR 17531: file: 0522b371. */
5154 if (linfo
.li_line_range
== 0)
5156 warn (_("Line range of 0 is invalid, using 1 instead\n"));
5157 linfo
.li_line_range
= 1;
5159 reset_state_machine (linfo
.li_default_is_stmt
);
5161 /* Save a pointer to the contents of the Opcodes table. */
5162 standard_opcodes
= hdrptr
;
5164 /* Traverse the Directory table just to count entries. */
5165 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
5169 warn (_("opcode base of %d extends beyond end of section\n"),
5170 linfo
.li_opcode_base
);
5174 if (linfo
.li_version
>= 5)
5176 unsigned char *format_start
, *format
;
5177 unsigned int format_count
, formati
, entryi
;
5179 load_debug_section_with_follow (line_str
, fileptr
);
5181 /* Skip directories format. */
5182 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
5183 if (do_checks
&& format_count
> 1)
5184 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
5186 format_start
= data
;
5187 for (formati
= 0; formati
< format_count
; formati
++)
5189 SKIP_ULEB (data
, end
);
5190 SKIP_ULEB (data
, end
);
5193 READ_ULEB (n_directories
, data
, end
);
5196 warn (_("Corrupt directories list\n"));
5200 if (n_directories
== 0)
5201 directory_table
= NULL
;
5202 else if (n_directories
> section
->size
)
5204 warn (_("number of directories (0x%x) exceeds size of section %s\n"),
5205 n_directories
, section
->name
);
5209 directory_table
= (char **)
5210 xcalloc (n_directories
, sizeof (unsigned char *));
5212 for (entryi
= 0; entryi
< n_directories
; entryi
++)
5214 char **pathp
= &directory_table
[entryi
];
5216 format
= format_start
;
5217 for (formati
= 0; formati
< format_count
; formati
++)
5219 uint64_t content_type
, form
;
5222 READ_ULEB (content_type
, format
, end
);
5223 READ_ULEB (form
, format
, end
);
5226 warn (_("Corrupt directories list\n"));
5229 switch (content_type
)
5234 case DW_FORM_string
:
5235 *pathp
= (char *) data
;
5237 case DW_FORM_line_strp
:
5238 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
5240 /* Remove const by the cast. */
5242 fetch_indirect_line_string (uvalue
);
5247 data
= read_and_display_attr_value (0, form
, 0, start
,
5249 linfo
.li_offset_size
,
5256 warn (_("Corrupt directories list\n"));
5261 /* Skip files format. */
5262 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
5263 if (do_checks
&& format_count
> 5)
5264 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
5267 format_start
= data
;
5268 for (formati
= 0; formati
< format_count
; formati
++)
5270 SKIP_ULEB (data
, end
);
5271 SKIP_ULEB (data
, end
);
5274 READ_ULEB (n_files
, data
, end
);
5275 if (data
>= end
&& n_files
> 0)
5277 warn (_("Corrupt file name list\n"));
5283 else if (n_files
> section
->size
)
5285 warn (_("number of files (0x%x) exceeds size of section %s\n"),
5286 n_files
, section
->name
);
5290 file_table
= (File_Entry
*) xcalloc (n_files
,
5291 sizeof (File_Entry
));
5293 for (entryi
= 0; entryi
< n_files
; entryi
++)
5295 File_Entry
*file
= &file_table
[entryi
];
5297 format
= format_start
;
5298 for (formati
= 0; formati
< format_count
; formati
++)
5300 uint64_t content_type
, form
;
5304 READ_ULEB (content_type
, format
, end
);
5305 READ_ULEB (form
, format
, end
);
5308 warn (_("Corrupt file name list\n"));
5311 switch (content_type
)
5316 case DW_FORM_string
:
5317 file
->name
= (char *) data
;
5319 case DW_FORM_line_strp
:
5320 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
5322 /* Remove const by the cast. */
5323 file
->name
= (char *)
5324 fetch_indirect_line_string (uvalue
);
5328 case DW_LNCT_directory_index
:
5332 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5336 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5341 READ_ULEB (file
->directory_index
, tmp
, end
);
5346 data
= read_and_display_attr_value (0, form
, 0, start
,
5348 linfo
.li_offset_size
,
5355 warn (_("Corrupt file name list\n"));
5364 char *ptr_directory_table
= (char *) data
;
5366 while (data
< end
&& *data
!= 0)
5368 data
+= strnlen ((char *) data
, end
- data
);
5377 warn (_("directory table ends unexpectedly\n"));
5382 /* Go through the directory table again to save the directories. */
5383 directory_table
= (char **)
5384 xmalloc (n_directories
* sizeof (unsigned char *));
5387 while (*ptr_directory_table
!= 0)
5389 directory_table
[i
] = ptr_directory_table
;
5390 ptr_directory_table
+= strlen (ptr_directory_table
) + 1;
5394 /* Skip the NUL at the end of the table. */
5397 /* Traverse the File Name table just to count the entries. */
5398 if (data
< end
&& *data
!= 0)
5400 unsigned char *ptr_file_name_table
= data
;
5402 while (data
< end
&& *data
!= 0)
5404 /* Skip Name, directory index, last modification
5405 time and length of file. */
5406 data
+= strnlen ((char *) data
, end
- data
);
5409 SKIP_ULEB (data
, end
);
5410 SKIP_ULEB (data
, end
);
5411 SKIP_ULEB (data
, end
);
5417 warn (_("file table ends unexpectedly\n"));
5422 /* Go through the file table again to save the strings. */
5423 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5426 while (*ptr_file_name_table
!= 0)
5428 file_table
[i
].name
= (char *) ptr_file_name_table
;
5430 += strlen ((char *) ptr_file_name_table
) + 1;
5432 /* We are not interested in directory, time or size. */
5433 READ_ULEB (file_table
[i
].directory_index
,
5434 ptr_file_name_table
, end
);
5435 READ_ULEB (file_table
[i
].modification_date
,
5436 ptr_file_name_table
, end
);
5437 READ_ULEB (file_table
[i
].length
,
5438 ptr_file_name_table
, end
);
5444 /* Skip the NUL at the end of the table. */
5448 /* Print the Compilation Unit's name and a header. */
5449 if (file_table
== NULL
)
5450 printf (_("CU: No directory table\n"));
5451 else if (directory_table
== NULL
)
5452 printf (_("CU: %s:\n"), null_name (file_table
[0].name
));
5455 unsigned int ix
= file_table
[0].directory_index
;
5456 const char *directory
;
5458 if (ix
== 0 && linfo
.li_version
< 5)
5461 else if (n_directories
== 0)
5462 directory
= _("<unknown>");
5465 if (linfo
.li_version
< 5)
5467 if (ix
>= n_directories
)
5469 warn (_("directory index %u "
5470 ">= number of directories %u\n"),
5472 directory
= _("<corrupt>");
5475 directory
= directory_table
[ix
];
5478 printf (_("CU: %s/%s:\n"),
5479 null_name (directory
),
5480 null_name (file_table
[0].name
));
5482 printf ("%s:\n", null_name (file_table
[0].name
));
5488 printf (_("File name Line number Starting address View Stmt\n"));
5490 printf (_("File name Line number Starting address View Stmt\n"));
5493 printf (_("CU: Empty file name table\n"));
5494 saved_linfo
= linfo
;
5497 /* This loop iterates through the Dwarf Line Number Program. */
5498 while (data
< end_of_sequence
)
5500 unsigned char op_code
;
5503 unsigned long int uladv
;
5504 int is_special_opcode
= 0;
5509 if (op_code
>= linfo
.li_opcode_base
)
5511 op_code
-= linfo
.li_opcode_base
;
5512 uladv
= (op_code
/ linfo
.li_line_range
);
5513 if (linfo
.li_max_ops_per_insn
== 1)
5515 uladv
*= linfo
.li_min_insn_length
;
5516 state_machine_regs
.address
+= uladv
;
5518 state_machine_regs
.view
= 0;
5523 = ((state_machine_regs
.op_index
+ uladv
)
5524 / linfo
.li_max_ops_per_insn
)
5525 * linfo
.li_min_insn_length
;
5526 state_machine_regs
.address
5528 state_machine_regs
.op_index
5529 = (state_machine_regs
.op_index
+ uladv
)
5530 % linfo
.li_max_ops_per_insn
;
5532 state_machine_regs
.view
= 0;
5535 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5536 state_machine_regs
.line
+= adv
;
5537 is_special_opcode
= 1;
5538 /* Increment view after printing this row. */
5543 case DW_LNS_extended_op
:
5545 unsigned int ext_op_code_len
;
5546 unsigned char ext_op_code
;
5547 unsigned char *op_code_end
;
5548 unsigned char *op_code_data
= data
;
5550 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5551 op_code_end
= op_code_data
+ ext_op_code_len
;
5552 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5554 warn (_("Badly formed extended line op encountered!\n"));
5557 ext_op_code
= *op_code_data
++;
5561 switch (ext_op_code
)
5563 case DW_LNE_end_sequence
:
5564 /* Reset stuff after printing this row. */
5566 case DW_LNE_set_address
:
5567 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5569 op_code_end
- op_code_data
,
5571 state_machine_regs
.op_index
= 0;
5572 state_machine_regs
.view
= 0;
5574 case DW_LNE_define_file
:
5575 file_table
= (File_Entry
*) xrealloc
5576 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5578 ++state_machine_regs
.last_file_entry
;
5579 /* Source file name. */
5580 file_table
[n_files
].name
= (char *) op_code_data
;
5581 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5582 /* Directory index. */
5583 READ_ULEB (file_table
[n_files
].directory_index
,
5584 op_code_data
, op_code_end
);
5585 /* Last modification time. */
5586 READ_ULEB (file_table
[n_files
].modification_date
,
5587 op_code_data
, op_code_end
);
5589 READ_ULEB (file_table
[n_files
].length
,
5590 op_code_data
, op_code_end
);
5594 case DW_LNE_set_discriminator
:
5595 case DW_LNE_HP_set_sequence
:
5596 /* Simply ignored. */
5600 printf (_("UNKNOWN (%u): length %ld\n"),
5601 ext_op_code
, (long int) (op_code_data
- data
));
5608 /* Increment view after printing this row. */
5611 case DW_LNS_advance_pc
:
5612 READ_ULEB (uladv
, data
, end
);
5613 if (linfo
.li_max_ops_per_insn
== 1)
5615 uladv
*= linfo
.li_min_insn_length
;
5616 state_machine_regs
.address
+= uladv
;
5618 state_machine_regs
.view
= 0;
5623 = ((state_machine_regs
.op_index
+ uladv
)
5624 / linfo
.li_max_ops_per_insn
)
5625 * linfo
.li_min_insn_length
;
5626 state_machine_regs
.address
5628 state_machine_regs
.op_index
5629 = (state_machine_regs
.op_index
+ uladv
)
5630 % linfo
.li_max_ops_per_insn
;
5632 state_machine_regs
.view
= 0;
5636 case DW_LNS_advance_line
:
5637 READ_SLEB (adv
, data
, end
);
5638 state_machine_regs
.line
+= adv
;
5641 case DW_LNS_set_file
:
5642 READ_ULEB (uladv
, data
, end
);
5643 state_machine_regs
.file
= uladv
;
5645 unsigned file
= state_machine_regs
.file
;
5646 if (linfo
.li_version
< 5)
5649 if (file_table
== NULL
|| n_files
== 0)
5650 printf (_("\n [Use file table entry %d]\n"), file
);
5652 else if (file
>= n_files
)
5654 warn (_("file index %u >= number of files %u\n"),
5656 printf (_("\n <over large file table index %u>"), file
);
5660 unsigned dir
= file_table
[file
].directory_index
;
5661 if (dir
== 0 && linfo
.li_version
< 5)
5662 /* If directory index is 0, that means compilation
5663 current directory. bfd/dwarf2.c shows
5664 DW_AT_comp_dir here but in keeping with the
5665 readelf practice of minimal interpretation of
5666 file data, we show "./". */
5667 printf ("\n./%s:[++]\n",
5668 null_name (file_table
[file
].name
));
5669 else if (directory_table
== NULL
|| n_directories
== 0)
5670 printf (_("\n [Use file %s "
5671 "in directory table entry %d]\n"),
5672 null_name (file_table
[file
].name
), dir
);
5675 if (linfo
.li_version
< 5)
5678 if (dir
>= n_directories
)
5680 warn (_("directory index %u "
5681 ">= number of directories %u\n"),
5682 dir
, n_directories
);
5683 printf (_("\n <over large directory table entry "
5687 printf ("\n%s/%s:\n",
5688 null_name (directory_table
[dir
]),
5689 null_name (file_table
[file
].name
));
5694 case DW_LNS_set_column
:
5695 READ_ULEB (uladv
, data
, end
);
5696 state_machine_regs
.column
= uladv
;
5699 case DW_LNS_negate_stmt
:
5700 adv
= state_machine_regs
.is_stmt
;
5702 state_machine_regs
.is_stmt
= adv
;
5705 case DW_LNS_set_basic_block
:
5706 state_machine_regs
.basic_block
= 1;
5709 case DW_LNS_const_add_pc
:
5710 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5711 if (linfo
.li_max_ops_per_insn
== 1)
5713 uladv
*= linfo
.li_min_insn_length
;
5714 state_machine_regs
.address
+= uladv
;
5716 state_machine_regs
.view
= 0;
5721 = ((state_machine_regs
.op_index
+ uladv
)
5722 / linfo
.li_max_ops_per_insn
)
5723 * linfo
.li_min_insn_length
;
5724 state_machine_regs
.address
5726 state_machine_regs
.op_index
5727 = (state_machine_regs
.op_index
+ uladv
)
5728 % linfo
.li_max_ops_per_insn
;
5730 state_machine_regs
.view
= 0;
5734 case DW_LNS_fixed_advance_pc
:
5735 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5736 state_machine_regs
.address
+= uladv
;
5737 state_machine_regs
.op_index
= 0;
5738 /* Do NOT reset view. */
5741 case DW_LNS_set_prologue_end
:
5744 case DW_LNS_set_epilogue_begin
:
5747 case DW_LNS_set_isa
:
5748 READ_ULEB (uladv
, data
, end
);
5749 printf (_(" Set ISA to %lu\n"), uladv
);
5753 printf (_(" Unknown opcode %d with operands: "), op_code
);
5755 if (standard_opcodes
!= NULL
)
5756 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5760 READ_ULEB (val
, data
, end
);
5761 printf ("%#" PRIx64
"%s", val
, i
== 1 ? "" : ", ");
5767 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5768 to the DWARF address/line matrix. */
5769 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5770 || (xop
== DW_LNS_copy
))
5772 const unsigned int MAX_FILENAME_LENGTH
= 35;
5773 char *fileName
= NULL
;
5774 char *newFileName
= NULL
;
5775 size_t fileNameLength
;
5779 unsigned indx
= state_machine_regs
.file
;
5781 if (linfo
.li_version
< 5)
5784 if (indx
>= n_files
)
5786 warn (_("file index %u >= number of files %u\n"),
5788 fileName
= _("<corrupt>");
5791 fileName
= (char *) file_table
[indx
].name
;
5794 fileName
= _("<unknown>");
5796 fileNameLength
= strlen (fileName
);
5797 newFileName
= fileName
;
5798 if (fileNameLength
> MAX_FILENAME_LENGTH
&& !do_wide
)
5800 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5801 /* Truncate file name */
5802 memcpy (newFileName
,
5803 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5804 MAX_FILENAME_LENGTH
);
5805 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5808 /* A row with end_seq set to true has a meaningful address, but
5809 the other information in the same row is not significant.
5810 In such a row, print line as "-", and don't print
5812 if (!do_wide
|| fileNameLength
<= MAX_FILENAME_LENGTH
)
5814 if (linfo
.li_max_ops_per_insn
== 1)
5816 if (xop
== -DW_LNE_end_sequence
)
5817 printf ("%-31s %11s %#18" PRIx64
,
5819 state_machine_regs
.address
);
5821 printf ("%-31s %11d %#18" PRIx64
,
5822 newFileName
, state_machine_regs
.line
,
5823 state_machine_regs
.address
);
5827 if (xop
== -DW_LNE_end_sequence
)
5828 printf ("%-31s %11s %#18" PRIx64
"[%d]",
5830 state_machine_regs
.address
,
5831 state_machine_regs
.op_index
);
5833 printf ("%-31s %11d %#18" PRIx64
"[%d]",
5834 newFileName
, state_machine_regs
.line
,
5835 state_machine_regs
.address
,
5836 state_machine_regs
.op_index
);
5841 if (linfo
.li_max_ops_per_insn
== 1)
5843 if (xop
== -DW_LNE_end_sequence
)
5844 printf ("%s %11s %#18" PRIx64
,
5846 state_machine_regs
.address
);
5848 printf ("%s %11d %#18" PRIx64
,
5849 newFileName
, state_machine_regs
.line
,
5850 state_machine_regs
.address
);
5854 if (xop
== -DW_LNE_end_sequence
)
5855 printf ("%s %11s %#18" PRIx64
"[%d]",
5857 state_machine_regs
.address
,
5858 state_machine_regs
.op_index
);
5860 printf ("%s %11d %#18" PRIx64
"[%d]",
5861 newFileName
, state_machine_regs
.line
,
5862 state_machine_regs
.address
,
5863 state_machine_regs
.op_index
);
5867 if (xop
!= -DW_LNE_end_sequence
)
5869 if (state_machine_regs
.view
)
5870 printf (" %6u", state_machine_regs
.view
);
5874 if (state_machine_regs
.is_stmt
)
5879 state_machine_regs
.view
++;
5881 if (xop
== -DW_LNE_end_sequence
)
5883 reset_state_machine (linfo
.li_default_is_stmt
);
5887 if (newFileName
!= fileName
)
5899 if (directory_table
)
5901 free (directory_table
);
5902 directory_table
= NULL
;
5913 display_debug_lines (struct dwarf_section
*section
, void *file
)
5915 unsigned char *data
= section
->start
;
5916 unsigned char *end
= data
+ section
->size
;
5918 int retValDecoded
= 1;
5920 if (do_debug_lines
== 0)
5921 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5923 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5924 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5926 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5927 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5929 if (!retValRaw
|| !retValDecoded
)
5936 find_debug_info_for_offset (uint64_t offset
)
5940 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5943 for (i
= 0; i
< num_debug_info_entries
; i
++)
5944 if (debug_information
[i
].cu_offset
== offset
)
5945 return debug_information
+ i
;
5951 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5953 /* See gdb/gdb-index.h. */
5954 static const char * const kinds
[] =
5966 return _ (kinds
[kind
]);
5970 display_debug_pubnames_worker (struct dwarf_section
*section
,
5971 void *file ATTRIBUTE_UNUSED
,
5974 DWARF2_Internal_PubNames names
;
5975 unsigned char *start
= section
->start
;
5976 unsigned char *end
= start
+ section
->size
;
5978 /* It does not matter if this load fails,
5979 we test for that later on. */
5980 load_debug_info (file
);
5982 introduce (section
, false);
5986 unsigned char *data
;
5987 unsigned long sec_off
= start
- section
->start
;
5988 unsigned int offset_size
;
5990 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5991 if (names
.pn_length
== 0xffffffff)
5993 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5999 if (names
.pn_length
> (size_t) (end
- start
))
6001 warn (_("Debug info is corrupted, "
6002 "%s header at %#lx has length %#" PRIx64
"\n"),
6003 section
->name
, sec_off
, names
.pn_length
);
6008 start
+= names
.pn_length
;
6010 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
6011 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
6013 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6014 && num_debug_info_entries
> 0
6015 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
6016 warn (_(".debug_info offset of %#" PRIx64
6017 " in %s section does not point to a CU header.\n"),
6018 names
.pn_offset
, section
->name
);
6020 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
6022 printf (_(" Length: %" PRId64
"\n"),
6024 printf (_(" Version: %d\n"),
6026 printf (_(" Offset into .debug_info section: %#" PRIx64
"\n"),
6028 printf (_(" Size of area in .debug_info section: %" PRId64
"\n"),
6031 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
6033 static int warned
= 0;
6037 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
6045 printf (_("\n Offset Kind Name\n"));
6047 printf (_("\n Offset\tName\n"));
6054 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
6061 maxprint
= (start
- data
) - 1;
6065 unsigned int kind_data
;
6066 gdb_index_symbol_kind kind
;
6067 const char *kind_name
;
6070 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
6072 /* GCC computes the kind as the upper byte in the CU index
6073 word, and then right shifts it by the CU index size.
6074 Left shift KIND to where the gdb-index.h accessor macros
6076 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
6077 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
6078 kind_name
= get_gdb_index_symbol_kind_name (kind
);
6079 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
6080 printf (" %-6" PRIx64
" %s,%-10s %.*s\n",
6081 offset
, is_static
? _("s") : _("g"),
6082 kind_name
, (int) maxprint
, data
);
6085 printf (" %-6" PRIx64
"\t%.*s\n",
6086 offset
, (int) maxprint
, data
);
6088 data
+= strnlen ((char *) data
, maxprint
);
6101 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
6103 return display_debug_pubnames_worker (section
, file
, 0);
6107 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
6109 return display_debug_pubnames_worker (section
, file
, 1);
6113 display_debug_macinfo (struct dwarf_section
*section
,
6114 void *file ATTRIBUTE_UNUSED
)
6116 unsigned char *start
= section
->start
;
6117 unsigned char *end
= start
+ section
->size
;
6118 unsigned char *curr
= start
;
6119 enum dwarf_macinfo_record_type op
;
6121 introduce (section
, false);
6125 unsigned int lineno
;
6126 const unsigned char *string
;
6128 op
= (enum dwarf_macinfo_record_type
) *curr
;
6133 case DW_MACINFO_start_file
:
6135 unsigned int filenum
;
6137 READ_ULEB (lineno
, curr
, end
);
6138 READ_ULEB (filenum
, curr
, end
);
6139 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
6144 case DW_MACINFO_end_file
:
6145 printf (_(" DW_MACINFO_end_file\n"));
6148 case DW_MACINFO_define
:
6149 READ_ULEB (lineno
, curr
, end
);
6151 curr
+= strnlen ((char *) string
, end
- string
);
6152 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
6153 lineno
, (int) (curr
- string
), string
);
6158 case DW_MACINFO_undef
:
6159 READ_ULEB (lineno
, curr
, end
);
6161 curr
+= strnlen ((char *) string
, end
- string
);
6162 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
6163 lineno
, (int) (curr
- string
), string
);
6168 case DW_MACINFO_vendor_ext
:
6170 unsigned int constant
;
6172 READ_ULEB (constant
, curr
, end
);
6174 curr
+= strnlen ((char *) string
, end
- string
);
6175 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
6176 constant
, (int) (curr
- string
), string
);
6187 /* Given LINE_OFFSET into the .debug_line section, attempt to return
6188 filename and dirname corresponding to file name table entry with index
6189 FILEIDX. Return NULL on failure. */
6191 static unsigned char *
6192 get_line_filename_and_dirname (uint64_t line_offset
,
6194 unsigned char **dir_name
)
6196 struct dwarf_section
*section
= &debug_displays
[line
].section
;
6197 unsigned char *hdrptr
, *dirtable
, *file_name
;
6198 unsigned int offset_size
;
6199 unsigned int version
, opcode_base
;
6200 uint64_t length
, diridx
;
6201 const unsigned char * end
;
6204 if (section
->start
== NULL
6205 || line_offset
>= section
->size
6209 hdrptr
= section
->start
+ line_offset
;
6210 end
= section
->start
+ section
->size
;
6212 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
6213 if (length
== 0xffffffff)
6215 /* This section is 64-bit DWARF 3. */
6216 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
6222 if (length
> (size_t) (end
- hdrptr
)
6223 || length
< 2 + offset_size
+ 1 + 3 + 1)
6225 end
= hdrptr
+ length
;
6227 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
6228 if (version
!= 2 && version
!= 3 && version
!= 4)
6230 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
6232 hdrptr
++; /* Skip max_ops_per_insn. */
6233 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
6235 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
6236 if (opcode_base
== 0
6237 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
6240 hdrptr
+= opcode_base
- 1;
6243 /* Skip over dirname table. */
6244 while (*hdrptr
!= '\0')
6246 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
6252 hdrptr
++; /* Skip the NUL at the end of the table. */
6254 /* Now skip over preceding filename table entries. */
6255 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
6257 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
6260 SKIP_ULEB (hdrptr
, end
);
6261 SKIP_ULEB (hdrptr
, end
);
6262 SKIP_ULEB (hdrptr
, end
);
6264 if (hdrptr
>= end
|| *hdrptr
== '\0')
6268 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
6273 READ_ULEB (diridx
, hdrptr
, end
);
6276 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
6278 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
6282 if (dirtable
>= end
|| *dirtable
== '\0')
6284 *dir_name
= dirtable
;
6289 display_debug_macro (struct dwarf_section
*section
,
6292 unsigned char *start
= section
->start
;
6293 unsigned char *end
= start
+ section
->size
;
6294 unsigned char *curr
= start
;
6295 unsigned char *extended_op_buf
[256];
6296 bool is_dwo
= false;
6297 const char *suffix
= strrchr (section
->name
, '.');
6299 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6302 load_debug_section_with_follow (str
, file
);
6303 load_debug_section_with_follow (line
, file
);
6304 load_debug_section_with_follow (str_index
, file
);
6306 introduce (section
, false);
6310 unsigned int lineno
, version
, flags
;
6311 unsigned int offset_size
;
6312 const unsigned char *string
;
6313 uint64_t line_offset
= 0, sec_offset
= curr
- start
, offset
;
6314 unsigned char **extended_ops
= NULL
;
6316 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6317 if (version
!= 4 && version
!= 5)
6319 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
6320 section
->name
, version
);
6324 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
6325 offset_size
= (flags
& 1) ? 8 : 4;
6326 printf (_(" Offset: %#" PRIx64
"\n"), sec_offset
);
6327 printf (_(" Version: %d\n"), version
);
6328 printf (_(" Offset size: %d\n"), offset_size
);
6331 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
6332 printf (_(" Offset into .debug_line: %#" PRIx64
"\n"),
6337 unsigned int i
, count
, op
;
6340 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
6342 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
6343 extended_ops
= extended_op_buf
;
6346 printf (_(" Extension opcode arguments:\n"));
6347 for (i
= 0; i
< count
; i
++)
6349 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6350 extended_ops
[op
] = curr
;
6351 READ_ULEB (nargs
, curr
, end
);
6353 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
6356 printf (_(" DW_MACRO_%02x arguments: "), op
);
6357 for (n
= 0; n
< nargs
; n
++)
6361 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6362 printf ("%s%s", get_FORM_name (form
),
6363 n
== nargs
- 1 ? "\n" : ", ");
6373 case DW_FORM_block1
:
6374 case DW_FORM_block2
:
6375 case DW_FORM_block4
:
6377 case DW_FORM_string
:
6379 case DW_FORM_sec_offset
:
6382 error (_("Invalid extension opcode form %s\n"),
6383 get_FORM_name (form
));
6399 error (_(".debug_macro section not zero terminated\n"));
6403 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6409 case DW_MACRO_define
:
6410 READ_ULEB (lineno
, curr
, end
);
6412 curr
+= strnlen ((char *) string
, end
- string
);
6413 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6414 lineno
, (int) (curr
- string
), string
);
6419 case DW_MACRO_undef
:
6420 READ_ULEB (lineno
, curr
, end
);
6422 curr
+= strnlen ((char *) string
, end
- string
);
6423 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6424 lineno
, (int) (curr
- string
), string
);
6429 case DW_MACRO_start_file
:
6431 unsigned int filenum
;
6432 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6434 READ_ULEB (lineno
, curr
, end
);
6435 READ_ULEB (filenum
, curr
, end
);
6437 if ((flags
& 2) == 0)
6438 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6441 = get_line_filename_and_dirname (line_offset
, filenum
,
6443 if (file_name
== NULL
)
6444 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6447 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6449 dir_name
!= NULL
? (const char *) dir_name
: "",
6450 dir_name
!= NULL
? "/" : "", file_name
);
6454 case DW_MACRO_end_file
:
6455 printf (_(" DW_MACRO_end_file\n"));
6458 case DW_MACRO_define_strp
:
6459 READ_ULEB (lineno
, curr
, end
);
6460 if (version
== 4 && is_dwo
)
6461 READ_ULEB (offset
, curr
, end
);
6463 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6464 string
= fetch_indirect_string (offset
);
6465 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6469 case DW_MACRO_undef_strp
:
6470 READ_ULEB (lineno
, curr
, end
);
6471 if (version
== 4 && is_dwo
)
6472 READ_ULEB (offset
, curr
, end
);
6474 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6475 string
= fetch_indirect_string (offset
);
6476 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6480 case DW_MACRO_import
:
6481 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6482 printf (_(" DW_MACRO_import - offset : %#" PRIx64
"\n"),
6486 case DW_MACRO_define_sup
:
6487 READ_ULEB (lineno
, curr
, end
);
6488 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6489 printf (_(" DW_MACRO_define_sup - lineno : %d"
6490 " macro offset : %#" PRIx64
"\n"),
6494 case DW_MACRO_undef_sup
:
6495 READ_ULEB (lineno
, curr
, end
);
6496 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6497 printf (_(" DW_MACRO_undef_sup - lineno : %d"
6498 " macro offset : %#" PRIx64
"\n"),
6502 case DW_MACRO_import_sup
:
6503 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6504 printf (_(" DW_MACRO_import_sup - offset : %#" PRIx64
"\n"),
6508 case DW_MACRO_define_strx
:
6509 case DW_MACRO_undef_strx
:
6510 READ_ULEB (lineno
, curr
, end
);
6511 READ_ULEB (offset
, curr
, end
);
6512 string
= (const unsigned char *)
6513 fetch_indexed_string (offset
, NULL
, offset_size
, false, 0);
6514 if (op
== DW_MACRO_define_strx
)
6515 printf (" DW_MACRO_define_strx ");
6517 printf (" DW_MACRO_undef_strx ");
6519 printf (_("(with offset %#" PRIx64
") "), offset
);
6520 printf (_("lineno : %d macro : %s\n"),
6525 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6527 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6531 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6533 error (_(" Unknown macro opcode %02x seen\n"), op
);
6538 /* Skip over unhandled opcodes. */
6540 unsigned char *desc
= extended_ops
[op
];
6541 READ_ULEB (nargs
, desc
, end
);
6544 printf (_(" DW_MACRO_%02x\n"), op
);
6547 printf (_(" DW_MACRO_%02x -"), op
);
6548 for (n
= 0; n
< nargs
; n
++)
6552 /* DW_FORM_implicit_const is not expected here. */
6553 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6555 = read_and_display_attr_value (0, val
, 0,
6556 start
, curr
, end
, 0, 0,
6557 offset_size
, version
,
6576 display_debug_abbrev (struct dwarf_section
*section
,
6577 void *file ATTRIBUTE_UNUSED
)
6579 abbrev_entry
*entry
;
6580 unsigned char *start
= section
->start
;
6582 introduce (section
, false);
6586 uint64_t offset
= start
- section
->start
;
6587 abbrev_list
*list
= find_and_process_abbrev_set (section
, 0,
6588 section
->size
, offset
,
6593 if (list
->first_abbrev
)
6594 printf (_(" Number TAG (%#" PRIx64
")\n"), offset
);
6596 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6600 printf (" %ld %s [%s]\n",
6602 get_TAG_name (entry
->tag
),
6603 entry
->children
? _("has children") : _("no children"));
6605 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6607 printf (" %-18s %s",
6608 get_AT_name (attr
->attribute
),
6609 get_FORM_name (attr
->form
));
6610 if (attr
->form
== DW_FORM_implicit_const
)
6611 printf (": %" PRId64
, attr
->implicit_const
);
6615 start
= list
->start_of_next_abbrevs
;
6616 free_abbrev_list (list
);
6625 /* Return true when ADDR is the maximum address, when addresses are
6626 POINTER_SIZE bytes long. */
6629 is_max_address (uint64_t addr
, unsigned int pointer_size
)
6631 uint64_t mask
= ~(~(uint64_t) 0 << 1 << (pointer_size
* 8 - 1));
6632 return ((addr
& mask
) == mask
);
6635 /* Display a view pair list starting at *VSTART_PTR and ending at
6636 VLISTEND within SECTION. */
6639 display_view_pair_list (struct dwarf_section
*section
,
6640 unsigned char **vstart_ptr
,
6641 unsigned int debug_info_entry
,
6642 unsigned char *vlistend
)
6644 unsigned char *vstart
= *vstart_ptr
;
6645 unsigned char *section_end
= section
->start
+ section
->size
;
6646 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6648 if (vlistend
< section_end
)
6649 section_end
= vlistend
;
6653 while (vstart
< section_end
)
6655 uint64_t off
= vstart
- section
->start
;
6656 uint64_t vbegin
, vend
;
6658 READ_ULEB (vbegin
, vstart
, section_end
);
6659 if (vstart
== section_end
)
6662 READ_ULEB (vend
, vstart
, section_end
);
6663 printf (" %8.8" PRIx64
" ", off
);
6665 print_view (vbegin
, pointer_size
);
6666 print_view (vend
, pointer_size
);
6667 printf (_("location view pair\n"));
6671 *vstart_ptr
= vstart
;
6674 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6677 display_loc_list (struct dwarf_section
*section
,
6678 unsigned char **start_ptr
,
6679 unsigned int debug_info_entry
,
6681 uint64_t base_address
,
6682 unsigned char **vstart_ptr
,
6685 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6686 unsigned char *section_end
= section
->start
+ section
->size
;
6688 unsigned int pointer_size
;
6689 unsigned int offset_size
;
6693 unsigned short length
;
6694 int need_frame_base
;
6696 if (debug_info_entry
>= num_debug_info_entries
)
6698 warn (_("No debug information available for loc lists of entry: %u\n"),
6703 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6704 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6705 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6706 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6708 if (pointer_size
< 2 || pointer_size
> 8)
6710 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6711 pointer_size
, debug_info_entry
);
6717 uint64_t off
= offset
+ (start
- *start_ptr
);
6718 uint64_t vbegin
= -1, vend
= -1;
6720 if (2 * pointer_size
> (size_t) (section_end
- start
))
6722 warn (_("Location list starting at offset %#" PRIx64
6723 " is not terminated.\n"), offset
);
6730 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6731 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6733 if (begin
== 0 && end
== 0)
6735 /* PR 18374: In a object file we can have a location list that
6736 starts with a begin and end of 0 because there are relocations
6737 that need to be applied to the addresses. Actually applying
6738 the relocations now does not help as they will probably resolve
6739 to 0, since the object file has not been fully linked. Real
6740 end of list markers will not have any relocations against them. */
6741 if (! reloc_at (section
, off
)
6742 && ! reloc_at (section
, off
+ pointer_size
))
6744 printf (_("<End of list>\n"));
6749 /* Check base address specifiers. */
6750 if (is_max_address (begin
, pointer_size
)
6751 && !is_max_address (end
, pointer_size
))
6754 print_hex (begin
, pointer_size
);
6755 print_hex (end
, pointer_size
);
6756 printf (_("(base address)\n"));
6762 off
= offset
+ (vstart
- *start_ptr
);
6764 READ_ULEB (vbegin
, vstart
, section_end
);
6765 print_view (vbegin
, pointer_size
);
6767 READ_ULEB (vend
, vstart
, section_end
);
6768 print_view (vend
, pointer_size
);
6770 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6773 if (2 > (size_t) (section_end
- start
))
6775 warn (_("Location list starting at offset %#" PRIx64
6776 " is not terminated.\n"), offset
);
6780 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6782 if (length
> (size_t) (section_end
- start
))
6784 warn (_("Location list starting at offset %#" PRIx64
6785 " is not terminated.\n"), offset
);
6789 print_hex (begin
+ base_address
, pointer_size
);
6790 print_hex (end
+ base_address
, pointer_size
);
6793 need_frame_base
= decode_location_expression (start
,
6798 cu_offset
, section
);
6801 if (need_frame_base
&& !has_frame_base
)
6802 printf (_(" [without DW_AT_frame_base]"));
6804 if (begin
== end
&& vbegin
== vend
)
6805 fputs (_(" (start == end)"), stdout
);
6806 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6807 fputs (_(" (start > end)"), stdout
);
6815 *vstart_ptr
= vstart
;
6818 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6821 display_loclists_list (struct dwarf_section
* section
,
6822 unsigned char ** start_ptr
,
6823 debug_info
* debug_info_p
,
6825 uint64_t base_address
,
6826 unsigned char ** vstart_ptr
,
6829 unsigned char *start
= *start_ptr
;
6830 unsigned char *vstart
= *vstart_ptr
;
6831 unsigned char *section_end
= section
->start
+ section
->size
;
6833 unsigned int pointer_size
;
6834 unsigned int offset_size
;
6835 unsigned int dwarf_version
;
6838 /* Initialize it due to a false compiler warning. */
6839 uint64_t begin
= -1, vbegin
= -1;
6840 uint64_t end
= -1, vend
= -1;
6842 int need_frame_base
;
6844 cu_offset
= debug_info_p
->cu_offset
;
6845 pointer_size
= debug_info_p
->pointer_size
;
6846 offset_size
= debug_info_p
->offset_size
;
6847 dwarf_version
= debug_info_p
->dwarf_version
;
6849 if (pointer_size
< 2 || pointer_size
> 8)
6851 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6852 pointer_size
, (int)(debug_info_p
- debug_information
));
6858 uint64_t off
= offset
+ (start
- *start_ptr
);
6859 enum dwarf_location_list_entry_type llet
;
6861 if (start
+ 1 > section_end
)
6863 warn (_("Location list starting at offset %#" PRIx64
6864 " is not terminated.\n"), offset
);
6871 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6873 if (vstart
&& (llet
== DW_LLE_offset_pair
6874 || llet
== DW_LLE_start_end
6875 || llet
== DW_LLE_start_length
))
6877 off
= offset
+ (vstart
- *start_ptr
);
6879 READ_ULEB (vbegin
, vstart
, section_end
);
6880 print_view (vbegin
, pointer_size
);
6882 READ_ULEB (vend
, vstart
, section_end
);
6883 print_view (vend
, pointer_size
);
6885 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
6890 case DW_LLE_end_of_list
:
6891 printf (_("<End of list>\n"));
6894 case DW_LLE_base_addressx
:
6895 READ_ULEB (index
, start
, section_end
);
6896 print_hex (index
, pointer_size
);
6897 printf (_("(index into .debug_addr) "));
6898 base_address
= fetch_indexed_addr
6899 (debug_info_p
->addr_base
+ index
* pointer_size
, pointer_size
);
6900 print_hex (base_address
, pointer_size
);
6901 printf (_("(base address)\n"));
6904 case DW_LLE_startx_endx
:
6905 READ_ULEB (index
, start
, section_end
);
6906 begin
= fetch_indexed_addr
6907 (debug_info_p
->addr_base
+ index
* pointer_size
, pointer_size
);
6908 READ_ULEB (index
, start
, section_end
);
6909 end
= fetch_indexed_addr
6910 (debug_info_p
->addr_base
+ index
* pointer_size
, pointer_size
);
6913 case DW_LLE_startx_length
:
6914 READ_ULEB (index
, start
, section_end
);
6915 begin
= fetch_indexed_addr
6916 (debug_info_p
->addr_base
+ index
* pointer_size
, pointer_size
);
6917 READ_ULEB (end
, start
, section_end
);
6921 case DW_LLE_default_location
:
6925 case DW_LLE_offset_pair
:
6926 READ_ULEB (begin
, start
, section_end
);
6927 begin
+= base_address
;
6928 READ_ULEB (end
, start
, section_end
);
6929 end
+= base_address
;
6932 case DW_LLE_base_address
:
6933 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6935 print_hex (base_address
, pointer_size
);
6936 printf (_("(base address)\n"));
6939 case DW_LLE_start_end
:
6940 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6941 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6944 case DW_LLE_start_length
:
6945 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6946 READ_ULEB (end
, start
, section_end
);
6950 #ifdef DW_LLE_view_pair
6951 case DW_LLE_view_pair
:
6953 printf (_("View pair entry in loclist with locviews attribute\n"));
6954 READ_ULEB (vbegin
, start
, section_end
);
6955 print_view (vbegin
, pointer_size
);
6957 READ_ULEB (vend
, start
, section_end
);
6958 print_view (vend
, pointer_size
);
6960 printf (_("views for:\n"));
6965 error (_("Invalid location list entry type %d\n"), llet
);
6969 if (llet
== DW_LLE_end_of_list
)
6972 if (llet
== DW_LLE_base_address
6973 || llet
== DW_LLE_base_addressx
)
6976 if (start
== section_end
)
6978 warn (_("Location list starting at offset %#" PRIx64
6979 " is not terminated.\n"), offset
);
6982 READ_ULEB (length
, start
, section_end
);
6984 if (length
> (size_t) (section_end
- start
))
6986 warn (_("Location list starting at offset %#" PRIx64
6987 " is not terminated.\n"), offset
);
6991 print_hex (begin
, pointer_size
);
6992 print_hex (end
, pointer_size
);
6995 need_frame_base
= decode_location_expression (start
,
7000 cu_offset
, section
);
7003 if (need_frame_base
&& !has_frame_base
)
7004 printf (_(" [without DW_AT_frame_base]"));
7006 if (begin
== end
&& vbegin
== vend
)
7007 fputs (_(" (start == end)"), stdout
);
7008 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
7009 fputs (_(" (start > end)"), stdout
);
7017 if (vbegin
!= (uint64_t) -1 || vend
!= (uint64_t) -1)
7018 printf (_("Trailing view pair not used in a range"));
7021 *vstart_ptr
= vstart
;
7024 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
7025 right-adjusted in a field of length LEN, and followed by a space. */
7028 print_addr_index (unsigned int idx
, unsigned int len
)
7030 static char buf
[15];
7031 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
7032 printf ("%*s ", len
, buf
);
7035 /* Display a location list from a .dwo section. It uses address indexes rather
7036 than embedded addresses. This code closely follows display_loc_list, but the
7037 two are sufficiently different that combining things is very ugly. */
7040 display_loc_list_dwo (struct dwarf_section
*section
,
7041 unsigned char **start_ptr
,
7042 unsigned int debug_info_entry
,
7044 unsigned char **vstart_ptr
,
7047 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
7048 unsigned char *section_end
= section
->start
+ section
->size
;
7050 unsigned int pointer_size
;
7051 unsigned int offset_size
;
7054 unsigned short length
;
7055 int need_frame_base
;
7058 if (debug_info_entry
>= num_debug_info_entries
)
7060 warn (_("No debug information for loc lists of entry: %u\n"),
7065 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
7066 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
7067 offset_size
= debug_information
[debug_info_entry
].offset_size
;
7068 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
7070 if (pointer_size
< 2 || pointer_size
> 8)
7072 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
7073 pointer_size
, debug_info_entry
);
7080 print_hex (offset
+ (start
- *start_ptr
), 4);
7082 if (start
>= section_end
)
7084 warn (_("Location list starting at offset %#" PRIx64
7085 " is not terminated.\n"), offset
);
7089 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
7102 uint64_t off
= offset
+ (vstart
- *start_ptr
);
7104 READ_ULEB (view
, vstart
, section_end
);
7105 print_view (view
, 8);
7107 READ_ULEB (view
, vstart
, section_end
);
7108 print_view (view
, 8);
7110 printf (_("views at %8.8" PRIx64
" for:\n %*s "), off
, 8, "");
7118 case 0: /* A terminating entry. */
7120 *vstart_ptr
= vstart
;
7121 printf (_("<End of list>\n"));
7123 case 1: /* A base-address entry. */
7124 READ_ULEB (idx
, start
, section_end
);
7125 print_addr_index (idx
, 8);
7126 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
7127 printf (_("(base address selection entry)\n"));
7129 case 2: /* A start/end entry. */
7130 READ_ULEB (idx
, start
, section_end
);
7131 print_addr_index (idx
, 8);
7132 READ_ULEB (idx
, start
, section_end
);
7133 print_addr_index (idx
, 8);
7135 case 3: /* A start/length entry. */
7136 READ_ULEB (idx
, start
, section_end
);
7137 print_addr_index (idx
, 8);
7138 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
7139 printf ("%08x ", idx
);
7141 case 4: /* An offset pair entry. */
7142 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
7143 printf ("%08x ", idx
);
7144 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
7145 printf ("%08x ", idx
);
7148 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
7150 *vstart_ptr
= vstart
;
7154 if (2 > (size_t) (section_end
- start
))
7156 warn (_("Location list starting at offset %#" PRIx64
7157 " is not terminated.\n"), offset
);
7161 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
7162 if (length
> (size_t) (section_end
- start
))
7164 warn (_("Location list starting at offset %#" PRIx64
7165 " is not terminated.\n"), offset
);
7170 need_frame_base
= decode_location_expression (start
,
7175 cu_offset
, section
);
7178 if (need_frame_base
&& !has_frame_base
)
7179 printf (_(" [without DW_AT_frame_base]"));
7187 *vstart_ptr
= vstart
;
7190 /* Sort array of indexes in ascending order of loc_offsets[idx] and
7193 static uint64_t *loc_offsets
, *loc_views
;
7196 loc_offsets_compar (const void *ap
, const void *bp
)
7198 uint64_t a
= loc_offsets
[*(const unsigned int *) ap
];
7199 uint64_t b
= loc_offsets
[*(const unsigned int *) bp
];
7201 int ret
= (a
> b
) - (b
> a
);
7205 a
= loc_views
[*(const unsigned int *) ap
];
7206 b
= loc_views
[*(const unsigned int *) bp
];
7208 ret
= (a
> b
) - (b
> a
);
7213 /* Reads and dumps the DWARFv5 loclists compiler unit header,
7214 including the offset table.
7215 Returns the offset of the next compile unit header. */
7218 display_loclists_unit_header (struct dwarf_section
* section
,
7219 uint64_t header_offset
,
7220 uint32_t * offset_count
,
7221 unsigned char ** loclists_start
)
7224 unsigned char *start
= section
->start
+ header_offset
;
7225 unsigned char *end
= section
->start
+ section
->size
;
7226 unsigned short version
;
7227 unsigned char address_size
;
7228 unsigned char segment_selector_size
;
7232 printf (_("Table at Offset %#" PRIx64
"\n"), header_offset
);
7234 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7235 if (length
== 0xffffffff)
7238 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7243 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
7244 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, end
);
7245 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, end
);
7246 SAFE_BYTE_GET_AND_INC (*offset_count
, start
, 4, end
);
7248 printf (_(" Length: %#" PRIx64
"\n"), length
);
7249 printf (_(" DWARF version: %u\n"), version
);
7250 printf (_(" Address size: %u\n"), address_size
);
7251 printf (_(" Segment size: %u\n"), segment_selector_size
);
7252 printf (_(" Offset entries: %u\n"), *offset_count
);
7254 if (segment_selector_size
!= 0)
7256 warn (_("The %s section contains an "
7257 "unsupported segment selector size: %d.\n"),
7258 section
->name
, segment_selector_size
);
7259 return (uint64_t)-1;
7264 printf (_("\n Offset Entries starting at %#tx:\n"),
7265 start
- section
->start
);
7267 for (i
= 0; i
< *offset_count
; i
++)
7271 SAFE_BYTE_GET_AND_INC (entry
, start
, is_64bit
? 8 : 4, end
);
7272 printf (_(" [%6u] %#" PRIx64
"\n"), i
, entry
);
7277 *loclists_start
= start
;
7279 /* The length field doesn't include the length field itself. */
7280 return header_offset
+ length
+ (is_64bit
? 12 : 4);
7284 display_debug_loc (struct dwarf_section
*section
, void *file
)
7286 unsigned char *start
= section
->start
, *vstart
= NULL
;
7288 unsigned char *section_begin
= start
;
7289 unsigned int num_loc_list
= 0;
7290 uint64_t last_offset
= 0;
7291 uint64_t last_view
= 0;
7292 unsigned int first
= 0;
7295 int seen_first_offset
= 0;
7296 int locs_sorted
= 1;
7297 unsigned char *next
= start
, *vnext
= vstart
;
7298 unsigned int *array
= NULL
;
7299 const char *suffix
= strrchr (section
->name
, '.');
7300 bool is_dwo
= false;
7301 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
7302 uint64_t next_header_offset
= 0;
7304 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
7307 bytes
= section
->size
;
7311 printf (_("\nThe %s section is empty.\n"), section
->name
);
7317 unsigned char *hdrptr
= section_begin
;
7319 unsigned short ll_version
;
7320 unsigned char *end
= section_begin
+ section
->size
;
7321 unsigned char address_size
, segment_selector_size
;
7322 uint32_t offset_entry_count
;
7324 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
7325 if (ll_length
== 0xffffffff)
7326 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
7328 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
7329 if (ll_version
!= 5)
7331 warn (_("The %s section contains corrupt or "
7332 "unsupported version number: %d.\n"),
7333 section
->name
, ll_version
);
7337 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
7339 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
7340 if (segment_selector_size
!= 0)
7342 warn (_("The %s section contains "
7343 "unsupported segment selector size: %d.\n"),
7344 section
->name
, segment_selector_size
);
7348 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
7350 /*if (offset_entry_count != 0)
7351 return display_offset_entry_loclists (section);*/
7353 //header_size = hdrptr - section_begin;
7356 if (load_debug_info (file
) == 0)
7358 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7363 /* Check the order of location list in .debug_info section. If
7364 offsets of location lists are in the ascending order, we can
7365 use `debug_information' directly. */
7366 for (i
= 0; i
< num_debug_info_entries
; i
++)
7370 num
= debug_information
[i
].num_loc_offsets
;
7371 if (num
> num_loc_list
)
7374 /* Check if we can use `debug_information' directly. */
7375 if (locs_sorted
&& num
!= 0)
7377 if (!seen_first_offset
)
7379 /* This is the first location list. */
7380 last_offset
= debug_information
[i
].loc_offsets
[0];
7381 last_view
= debug_information
[i
].loc_views
[0];
7383 seen_first_offset
= 1;
7389 for (; j
< num
; j
++)
7392 debug_information
[i
].loc_offsets
[j
]
7393 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
7394 && last_view
> debug_information
[i
].loc_views
[j
]))
7399 last_offset
= debug_information
[i
].loc_offsets
[j
];
7400 last_view
= debug_information
[i
].loc_views
[j
];
7405 if (!seen_first_offset
)
7406 error (_("No location lists in .debug_info section!\n"));
7409 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
7411 introduce (section
, false);
7413 if (reloc_at (section
, 0))
7414 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
7417 printf (_(" Offset Begin End Expression\n"));
7419 for (i
= first
; i
< num_debug_info_entries
; i
++)
7421 uint64_t offset
= 0, voffset
= 0;
7422 uint64_t base_address
;
7425 debug_info
*debug_info_p
= debug_information
+ i
;
7426 uint32_t offset_count
;
7431 for (k
= 0; k
< debug_info_p
->num_loc_offsets
; k
++)
7433 loc_offsets
= debug_info_p
->loc_offsets
;
7434 loc_views
= debug_info_p
->loc_views
;
7435 qsort (array
, debug_info_p
->num_loc_offsets
,
7436 sizeof (*array
), loc_offsets_compar
);
7439 /* .debug_loclists has a per-unit header.
7440 Update start if we are detecting it. */
7441 if (debug_info_p
->dwarf_version
== 5)
7443 j
= locs_sorted
? 0 : array
[0];
7445 if (debug_info_p
->num_loc_offsets
)
7446 offset
= debug_info_p
->loc_offsets
[j
];
7448 if (debug_info_p
->num_loc_views
)
7449 voffset
= debug_info_p
->loc_views
[j
];
7451 /* Parse and dump unit headers in loclists.
7452 This will misbehave if the order of CUs in debug_info
7453 doesn't match the one in loclists. */
7454 if (next_header_offset
< offset
)
7456 while (next_header_offset
< offset
)
7458 next_header_offset
= display_loclists_unit_header
7459 (section
, next_header_offset
, &offset_count
, &start
);
7461 if (next_header_offset
== (uint64_t)-1)
7462 /* Header parsing error. */
7467 Offset Begin End Expression\n"));
7471 int adjacent_view_loclists
= 1;
7473 for (k
= 0; k
< debug_info_p
->num_loc_offsets
; k
++)
7475 j
= locs_sorted
? k
: array
[k
];
7477 && (debug_info_p
->loc_offsets
[locs_sorted
7478 ? k
- 1 : array
[k
- 1]]
7479 == debug_info_p
->loc_offsets
[j
])
7480 && (debug_info_p
->loc_views
[locs_sorted
7481 ? k
- 1 : array
[k
- 1]]
7482 == debug_info_p
->loc_views
[j
]))
7484 has_frame_base
= debug_info_p
->have_frame_base
[j
];
7485 offset
= debug_info_p
->loc_offsets
[j
];
7486 next
= section_begin
+ offset
;
7487 voffset
= debug_info_p
->loc_views
[j
];
7488 if (voffset
!= (uint64_t) -1)
7489 vnext
= section_begin
+ voffset
;
7492 base_address
= debug_info_p
->base_address
;
7494 if (vnext
&& vnext
< next
)
7497 display_view_pair_list (section
, &vstart
, i
, next
);
7504 if (vnext
&& vnext
< next
)
7505 warn (_("There is a hole [%#tx - %#" PRIx64
"]"
7506 " in %s section.\n"),
7507 start
- section_begin
, voffset
, section
->name
);
7509 warn (_("There is a hole [%#tx - %#" PRIx64
"]"
7510 " in %s section.\n"),
7511 start
- section_begin
, offset
, section
->name
);
7513 else if (start
> next
)
7514 warn (_("There is an overlap [%#tx - %#" PRIx64
"]"
7515 " in %s section.\n"),
7516 start
- section_begin
, offset
, section
->name
);
7520 if (offset
>= bytes
)
7522 warn (_("Offset %#" PRIx64
" is bigger than %s section size.\n"),
7523 offset
, section
->name
);
7527 if (vnext
&& voffset
>= bytes
)
7529 warn (_("View Offset %#" PRIx64
" is bigger than %s section size.\n"),
7530 voffset
, section
->name
);
7537 display_loc_list_dwo (section
, &start
, i
, offset
,
7538 &vstart
, has_frame_base
);
7540 display_loc_list (section
, &start
, i
, offset
, base_address
,
7541 &vstart
, has_frame_base
);
7546 warn (_("DWO is not yet supported.\n"));
7548 display_loclists_list (section
, &start
, debug_info_p
, offset
,
7549 base_address
, &vstart
, has_frame_base
);
7552 /* FIXME: this arrangement is quite simplistic. Nothing
7553 requires locview lists to be adjacent to corresponding
7554 loclists, and a single loclist could be augmented by
7555 different locview lists, and vice-versa, unlikely as it
7556 is that it would make sense to do so. Hopefully we'll
7557 have view pair support built into loclists before we ever
7558 need to address all these possibilities. */
7559 if (adjacent_view_loclists
&& vnext
7560 && vnext
!= start
&& vstart
!= next
)
7562 adjacent_view_loclists
= 0;
7563 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7566 if (vnext
&& vnext
== start
)
7567 display_view_pair_list (section
, &start
, i
, vstart
);
7571 if (start
< section
->start
+ section
->size
)
7572 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7573 "There are %ld unused bytes at the end of section %s\n",
7574 (long) (section
->start
+ section
->size
- start
)),
7575 (long) (section
->start
+ section
->size
- start
), section
->name
);
7582 display_debug_str (struct dwarf_section
*section
,
7583 void *file ATTRIBUTE_UNUSED
)
7585 unsigned char *start
= section
->start
;
7586 uint64_t bytes
= section
->size
;
7587 uint64_t addr
= section
->address
;
7591 printf (_("\nThe %s section is empty.\n"), section
->name
);
7595 introduce (section
, false);
7603 lbytes
= (bytes
> 16 ? 16 : bytes
);
7605 printf (" 0x%8.8" PRIx64
" ", addr
);
7607 for (j
= 0; j
< 16; j
++)
7610 printf ("%2.2x", start
[j
]);
7618 for (j
= 0; j
< lbytes
; j
++)
7621 if (k
>= ' ' && k
< 0x80)
7640 display_debug_info (struct dwarf_section
*section
, void *file
)
7642 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7646 display_debug_types (struct dwarf_section
*section
, void *file
)
7648 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7652 display_trace_info (struct dwarf_section
*section
, void *file
)
7654 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7658 display_debug_aranges (struct dwarf_section
*section
,
7659 void *file ATTRIBUTE_UNUSED
)
7661 unsigned char *start
= section
->start
;
7662 unsigned char *end
= start
+ section
->size
;
7664 introduce (section
, false);
7666 /* It does not matter if this load fails,
7667 we test for that later on. */
7668 load_debug_info (file
);
7672 unsigned char *hdrptr
;
7673 DWARF2_Internal_ARange arange
;
7674 unsigned char *addr_ranges
;
7678 unsigned char address_size
;
7679 unsigned int offset_size
;
7680 unsigned char *end_ranges
;
7683 sec_off
= hdrptr
- section
->start
;
7685 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7686 if (arange
.ar_length
== 0xffffffff)
7688 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7694 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7696 warn (_("Debug info is corrupted, %s header at %#" PRIx64
7697 " has length %#" PRIx64
"\n"),
7698 section
->name
, sec_off
, arange
.ar_length
);
7701 end_ranges
= hdrptr
+ arange
.ar_length
;
7703 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7704 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7707 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7708 && num_debug_info_entries
> 0
7709 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7710 warn (_(".debug_info offset of %#" PRIx64
7711 " in %s section does not point to a CU header.\n"),
7712 arange
.ar_info_offset
, section
->name
);
7714 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7715 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7717 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7719 /* PR 19872: A version number of 0 probably means that there is
7720 padding at the end of the .debug_aranges section. Gold puts
7721 it there when performing an incremental link, for example.
7722 So do not generate a warning in this case. */
7723 if (arange
.ar_version
)
7724 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7728 printf (_(" Length: %" PRId64
"\n"), arange
.ar_length
);
7729 printf (_(" Version: %d\n"), arange
.ar_version
);
7730 printf (_(" Offset into .debug_info: %#" PRIx64
"\n"),
7731 arange
.ar_info_offset
);
7732 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7733 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7735 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7737 /* PR 17512: file: 001-108546-0.001:0.1. */
7738 if (address_size
== 0 || address_size
> 8)
7740 error (_("Invalid address size in %s section!\n"),
7745 /* The DWARF spec does not require that the address size be a power
7746 of two, but we do. This will have to change if we ever encounter
7747 an uneven architecture. */
7748 if ((address_size
& (address_size
- 1)) != 0)
7750 warn (_("Pointer size + Segment size is not a power of two.\n"));
7754 if (address_size
> 4)
7755 printf (_("\n Address Length\n"));
7757 printf (_("\n Address Length\n"));
7759 addr_ranges
= hdrptr
;
7761 /* Must pad to an alignment boundary that is twice the address size. */
7762 addr_ranges
+= (2 * address_size
- 1
7763 - (hdrptr
- start
- 1) % (2 * address_size
));
7765 while (2 * address_size
<= end_ranges
- addr_ranges
)
7767 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
,
7769 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
,
7772 print_hex (address
, address_size
);
7773 print_hex_ns (length
, address_size
);
7785 /* Comparison function for qsort. */
7787 comp_addr_base (const void * v0
, const void * v1
)
7789 debug_info
*info0
= *(debug_info
**) v0
;
7790 debug_info
*info1
= *(debug_info
**) v1
;
7791 return info0
->addr_base
- info1
->addr_base
;
7794 /* Display the debug_addr section. */
7796 display_debug_addr (struct dwarf_section
*section
,
7799 debug_info
**debug_addr_info
;
7800 unsigned char *entry
;
7804 unsigned char * header
;
7806 if (section
->size
== 0)
7808 printf (_("\nThe %s section is empty.\n"), section
->name
);
7812 if (load_debug_info (file
) == 0)
7814 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7819 introduce (section
, false);
7821 /* PR 17531: file: cf38d01b.
7822 We use xcalloc because a corrupt file may not have initialised all of the
7823 fields in the debug_info structure, which means that the sort below might
7824 try to move uninitialised data. */
7825 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7826 sizeof (debug_info
*));
7829 for (i
= 0; i
< num_debug_info_entries
; i
++)
7830 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7832 /* PR 17531: file: cf38d01b. */
7833 if (debug_information
[i
].addr_base
>= section
->size
)
7834 warn (_("Corrupt address base (%#" PRIx64
")"
7835 " found in debug section %u\n"),
7836 debug_information
[i
].addr_base
, i
);
7838 debug_addr_info
[count
++] = debug_information
+ i
;
7841 /* Add a sentinel to make iteration convenient. */
7842 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7843 debug_addr_info
[count
]->addr_base
= section
->size
;
7844 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7846 header
= section
->start
;
7847 for (i
= 0; i
< count
; i
++)
7850 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7852 printf (_(" For compilation unit at offset %#" PRIx64
":\n"),
7853 debug_addr_info
[i
]->cu_offset
);
7855 printf (_("\tIndex\tAddress\n"));
7856 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7857 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7859 size_t header_size
= entry
- header
;
7860 unsigned char *curr_header
= header
;
7863 int segment_selector_size
;
7865 if (header_size
!= 8 && header_size
!= 16)
7867 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %zd instead\n"),
7868 section
->name
, header_size
);
7872 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7873 if (length
== 0xffffffff)
7874 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7875 if (length
> (size_t) (section
->start
+ section
->size
- curr_header
)
7876 || length
< (size_t) (entry
- curr_header
))
7878 warn (_("Corrupt %s section: unit_length field of %#" PRIx64
7879 " is invalid\n"), section
->name
, length
);
7882 end
= curr_header
+ length
;
7883 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7885 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7886 section
->name
, version
);
7888 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7889 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7890 address_size
+= segment_selector_size
;
7893 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7898 if (address_size
< 1 || address_size
> sizeof (uint64_t))
7900 warn (_("Corrupt %s section: address size (%x) is wrong"),
7901 section
->name
, address_size
);
7905 while ((size_t) (end
- entry
) >= address_size
)
7907 uint64_t base
= byte_get (entry
, address_size
);
7908 printf (_("\t%d:\t"), idx
);
7909 print_hex_ns (base
, address_size
);
7911 entry
+= address_size
;
7917 free (debug_addr_info
);
7921 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7924 display_debug_str_offsets (struct dwarf_section
*section
,
7925 void *file ATTRIBUTE_UNUSED
)
7929 if (section
->size
== 0)
7931 printf (_("\nThe %s section is empty.\n"), section
->name
);
7935 unsigned char *start
= section
->start
;
7936 unsigned char *end
= start
+ section
->size
;
7937 unsigned char *curr
= start
;
7938 uint64_t debug_str_offsets_hdr_len
;
7940 const char *suffix
= strrchr (section
->name
, '.');
7941 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7944 load_debug_section_with_follow (str_dwo
, file
);
7946 load_debug_section_with_follow (str
, file
);
7948 introduce (section
, false);
7953 uint64_t entry_length
;
7955 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7956 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7957 if (length
== 0xffffffff)
7959 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7961 debug_str_offsets_hdr_len
= 16;
7966 debug_str_offsets_hdr_len
= 8;
7969 unsigned char *entries_end
;
7972 /* This is probably an old style .debug_str_offset section which
7973 just contains offsets and no header (and the first offset is 0). */
7974 length
= section
->size
;
7975 curr
= section
->start
;
7978 printf (_(" Length: %#" PRIx64
"\n"), length
);
7979 printf (_(" Index Offset [String]\n"));
7983 if (length
<= (size_t) (end
- curr
))
7984 entries_end
= curr
+ length
;
7987 warn (_("Section %s is too small %#" PRIx64
"\n"),
7988 section
->name
, section
->size
);
7993 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7995 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7998 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
8000 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
8002 printf (_(" Length: %#" PRIx64
"\n"), length
);
8003 printf (_(" Version: %#x\n"), version
);
8004 printf (_(" Index Offset [String]\n"));
8007 for (idx
= 0; curr
< entries_end
; idx
++)
8010 const unsigned char * string
;
8012 if ((size_t) (entries_end
- curr
) < entry_length
)
8013 /* Not enough space to read one entry_length, give up. */
8016 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
8018 string
= (const unsigned char *)
8019 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
, debug_str_offsets_hdr_len
);
8021 string
= fetch_indirect_string (offset
);
8023 printf (" %8lu ", idx
);
8024 print_hex (offset
, entry_length
);
8025 printf (" %s\n", string
);
8032 /* Each debug_information[x].range_lists[y] gets this representation for
8033 sorting purposes. */
8037 /* The debug_information[x].range_lists[y] value. */
8038 uint64_t ranges_offset
;
8040 /* Original debug_information to find parameters of the data. */
8041 debug_info
*debug_info_p
;
8044 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
8047 range_entry_compar (const void *ap
, const void *bp
)
8049 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
8050 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
8051 const uint64_t a
= a_re
->ranges_offset
;
8052 const uint64_t b
= b_re
->ranges_offset
;
8054 return (a
> b
) - (b
> a
);
8058 display_debug_ranges_list (unsigned char * start
,
8059 unsigned char * finish
,
8060 unsigned int pointer_size
,
8062 uint64_t base_address
)
8064 while (start
< finish
)
8069 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
8070 if (start
>= finish
)
8072 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
8075 print_hex (offset
, 4);
8077 if (begin
== 0 && end
== 0)
8079 printf (_("<End of list>\n"));
8083 /* Check base address specifiers. */
8084 if (is_max_address (begin
, pointer_size
)
8085 && !is_max_address (end
, pointer_size
))
8088 print_hex (begin
, pointer_size
);
8089 print_hex (end
, pointer_size
);
8090 printf ("(base address)\n");
8094 print_hex (begin
+ base_address
, pointer_size
);
8095 print_hex_ns (end
+ base_address
, pointer_size
);
8098 fputs (_(" (start == end)"), stdout
);
8099 else if (begin
> end
)
8100 fputs (_(" (start > end)"), stdout
);
8106 static unsigned char *
8107 display_debug_rnglists_list (unsigned char * start
,
8108 unsigned char * finish
,
8109 unsigned int pointer_size
,
8111 uint64_t base_address
,
8114 unsigned char *next
= start
;
8118 uint64_t off
= offset
+ (start
- next
);
8119 enum dwarf_range_list_entry rlet
;
8120 /* Initialize it due to a false compiler warning. */
8121 uint64_t begin
= -1, length
, end
= -1;
8123 if (start
>= finish
)
8125 warn (_("Range list starting at offset %#" PRIx64
8126 " is not terminated.\n"), offset
);
8133 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
8137 case DW_RLE_end_of_list
:
8138 printf (_("<End of list>\n"));
8140 case DW_RLE_base_addressx
:
8141 READ_ULEB (base_address
, start
, finish
);
8142 print_hex (base_address
, pointer_size
);
8143 printf (_("(base address index) "));
8144 base_address
= fetch_indexed_addr ((base_address
* pointer_size
) + addr_base
,
8146 print_hex (base_address
, pointer_size
);
8147 printf (_("(base address)\n"));
8149 case DW_RLE_startx_endx
:
8150 READ_ULEB (begin
, start
, finish
);
8151 READ_ULEB (end
, start
, finish
);
8152 begin
= fetch_indexed_addr ((begin
* pointer_size
) + addr_base
,
8154 end
= fetch_indexed_addr ((begin
* pointer_size
) + addr_base
,
8157 case DW_RLE_startx_length
:
8158 READ_ULEB (begin
, start
, finish
);
8159 READ_ULEB (length
, start
, finish
);
8160 begin
= fetch_indexed_addr ((begin
* pointer_size
) + addr_base
,
8162 end
= begin
+ length
;
8164 case DW_RLE_offset_pair
:
8165 READ_ULEB (begin
, start
, finish
);
8166 READ_ULEB (end
, start
, finish
);
8168 case DW_RLE_base_address
:
8169 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
8170 print_hex (base_address
, pointer_size
);
8171 printf (_("(base address)\n"));
8173 case DW_RLE_start_end
:
8174 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
8175 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
8177 case DW_RLE_start_length
:
8178 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
8179 READ_ULEB (length
, start
, finish
);
8180 end
= begin
+ length
;
8183 error (_("Invalid range list entry type %d\n"), rlet
);
8184 rlet
= DW_RLE_end_of_list
;
8188 if (rlet
== DW_RLE_end_of_list
)
8190 if (rlet
== DW_RLE_base_address
|| rlet
== DW_RLE_base_addressx
)
8193 /* Only a DW_RLE_offset_pair needs the base address added. */
8194 if (rlet
== DW_RLE_offset_pair
)
8196 begin
+= base_address
;
8197 end
+= base_address
;
8200 print_hex (begin
, pointer_size
);
8201 print_hex (end
, pointer_size
);
8204 fputs (_(" (start == end)"), stdout
);
8205 else if (begin
> end
)
8206 fputs (_(" (start > end)"), stdout
);
8215 display_debug_rnglists_unit_header (struct dwarf_section
* section
,
8216 uint64_t * unit_offset
,
8217 unsigned char * poffset_size
)
8219 uint64_t start_offset
= *unit_offset
;
8220 unsigned char * p
= section
->start
+ start_offset
;
8221 unsigned char * finish
= section
->start
+ section
->size
;
8222 uint64_t initial_length
;
8223 unsigned char segment_selector_size
;
8224 unsigned int offset_entry_count
;
8226 unsigned short version
;
8227 unsigned char address_size
= 0;
8228 unsigned char offset_size
;
8230 /* Get and check the length of the block. */
8231 SAFE_BYTE_GET_AND_INC (initial_length
, p
, 4, finish
);
8233 if (initial_length
== 0xffffffff)
8235 /* This section is 64-bit DWARF 3. */
8236 SAFE_BYTE_GET_AND_INC (initial_length
, p
, 8, finish
);
8237 *poffset_size
= offset_size
= 8;
8240 *poffset_size
= offset_size
= 4;
8242 if (initial_length
> (size_t) (finish
- p
))
8244 /* If the length field has a relocation against it, then we should
8245 not complain if it is inaccurate (and probably negative).
8246 It is copied from .debug_line handling code. */
8247 if (reloc_at (section
, (p
- section
->start
) - offset_size
))
8248 initial_length
= finish
- p
;
8251 warn (_("The length field (%#" PRIx64
8252 ") in the debug_rnglists header is wrong"
8253 " - the section is too small\n"),
8259 /* Report the next unit offset to the caller. */
8260 *unit_offset
= (p
- section
->start
) + initial_length
;
8262 /* Get the other fields in the header. */
8263 SAFE_BYTE_GET_AND_INC (version
, p
, 2, finish
);
8264 SAFE_BYTE_GET_AND_INC (address_size
, p
, 1, finish
);
8265 SAFE_BYTE_GET_AND_INC (segment_selector_size
, p
, 1, finish
);
8266 SAFE_BYTE_GET_AND_INC (offset_entry_count
, p
, 4, finish
);
8268 printf (_(" Table at Offset: %#" PRIx64
":\n"), start_offset
);
8269 printf (_(" Length: %#" PRIx64
"\n"), initial_length
);
8270 printf (_(" DWARF version: %u\n"), version
);
8271 printf (_(" Address size: %u\n"), address_size
);
8272 printf (_(" Segment size: %u\n"), segment_selector_size
);
8273 printf (_(" Offset entries: %u\n"), offset_entry_count
);
8275 /* Check the fields. */
8276 if (segment_selector_size
!= 0)
8278 warn (_("The %s section contains "
8279 "unsupported segment selector size: %d.\n"),
8280 section
->name
, segment_selector_size
);
8286 warn (_("Only DWARF version 5+ debug_rnglists info "
8287 "is currently supported.\n"));
8291 if (offset_entry_count
!= 0)
8293 printf (_("\n Offsets starting at %#tx:\n"), p
- section
->start
);
8295 for (i
= 0; i
< offset_entry_count
; i
++)
8299 SAFE_BYTE_GET_AND_INC (entry
, p
, offset_size
, finish
);
8300 printf (_(" [%6u] %#" PRIx64
"\n"), i
, entry
);
8308 is_range_list_for_this_section (bool is_rnglists
, unsigned int version
)
8310 if (is_rnglists
&& version
> 4)
8313 if (! is_rnglists
&& version
< 5)
8320 display_debug_ranges (struct dwarf_section
*section
,
8321 void *file ATTRIBUTE_UNUSED
)
8323 unsigned char *start
= section
->start
;
8324 unsigned char *last_start
= start
;
8325 uint64_t bytes
= section
->size
;
8326 unsigned char *section_begin
= start
;
8327 unsigned char *finish
= start
+ bytes
;
8328 unsigned int num_range_list
, i
;
8329 struct range_entry
*range_entries
;
8330 struct range_entry
*range_entry_fill
;
8331 bool is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
8332 uint64_t last_offset
= 0;
8333 uint64_t next_rnglists_cu_offset
= 0;
8334 unsigned char offset_size
;
8338 printf (_("\nThe %s section is empty.\n"), section
->name
);
8342 introduce (section
, false);
8344 if (load_debug_info (file
) == 0)
8346 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
8352 for (i
= 0; i
< num_debug_info_entries
; i
++)
8353 if (is_range_list_for_this_section (is_rnglists
, debug_information
[i
].dwarf_version
))
8354 num_range_list
+= debug_information
[i
].num_range_lists
;
8356 if (num_range_list
== 0)
8358 /* This can happen when the file was compiled with -gsplit-debug
8359 which removes references to range lists from the primary .o file. */
8360 printf (_("No range lists referenced by .debug_info section.\n"));
8364 range_entry_fill
= range_entries
= XNEWVEC (struct range_entry
, num_range_list
);
8366 for (i
= 0; i
< num_debug_info_entries
; i
++)
8368 debug_info
*debug_info_p
= &debug_information
[i
];
8371 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
8373 if (is_range_list_for_this_section (is_rnglists
, debug_info_p
->dwarf_version
))
8375 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
8376 range_entry_fill
->debug_info_p
= debug_info_p
;
8382 assert (range_entry_fill
>= range_entries
);
8383 assert (num_range_list
>= (unsigned int)(range_entry_fill
- range_entries
));
8384 num_range_list
= range_entry_fill
- range_entries
;
8385 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
8386 range_entry_compar
);
8388 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
8389 warn (_("Range lists in %s section start at %#" PRIx64
"\n"),
8390 section
->name
, range_entries
[0].ranges_offset
);
8394 printf (_(" Offset Begin End\n"));
8396 for (i
= 0; i
< num_range_list
; i
++)
8398 struct range_entry
*range_entry
= &range_entries
[i
];
8399 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
8400 unsigned int pointer_size
;
8402 unsigned char *next
;
8403 uint64_t base_address
;
8405 pointer_size
= debug_info_p
->pointer_size
;
8406 offset
= range_entry
->ranges_offset
;
8407 base_address
= debug_info_p
->base_address
;
8409 /* PR 17512: file: 001-101485-0.001:0.1. */
8410 if (pointer_size
< 2 || pointer_size
> 8)
8412 warn (_("Corrupt pointer size (%d) in debug entry at offset %#" PRIx64
"\n"),
8413 pointer_size
, offset
);
8417 if (offset
> (size_t) (finish
- section_begin
))
8419 warn (_("Corrupt offset (%#" PRIx64
") in range entry %u\n"),
8424 /* If we've moved on to the next compile unit in the rnglists section - dump the unit header(s). */
8425 if (is_rnglists
&& next_rnglists_cu_offset
< offset
)
8427 while (next_rnglists_cu_offset
< offset
)
8428 display_debug_rnglists_unit_header (section
, &next_rnglists_cu_offset
, &offset_size
);
8429 printf (_(" Offset Begin End\n"));
8432 next
= section_begin
+ offset
; /* Offset is from the section start, the base has already been added. */
8434 /* If multiple DWARF entities reference the same range then we will
8435 have multiple entries in the `range_entries' list for the same
8436 offset. Thanks to the sort above these will all be consecutive in
8437 the `range_entries' list, so we can easily ignore duplicates
8439 if (i
> 0 && last_offset
== offset
)
8441 last_offset
= offset
;
8443 if (dwarf_check
!= 0 && i
> 0)
8446 warn (_("There is a hole [%#tx - %#tx] in %s section.\n"),
8447 start
- section_begin
, next
- section_begin
, section
->name
);
8448 else if (start
> next
)
8450 if (next
== last_start
)
8452 warn (_("There is an overlap [%#tx - %#tx] in %s section.\n"),
8453 start
- section_begin
, next
- section_begin
, section
->name
);
8461 display_debug_rnglists_list
8462 (start
, finish
, pointer_size
, offset
, base_address
, debug_info_p
->addr_base
);
8464 display_debug_ranges_list
8465 (start
, finish
, pointer_size
, offset
, base_address
);
8468 /* Display trailing empty (or unreferenced) compile units, if any. */
8470 while (next_rnglists_cu_offset
< section
->size
)
8471 display_debug_rnglists_unit_header (section
, &next_rnglists_cu_offset
, &offset_size
);
8475 free (range_entries
);
8480 typedef struct Frame_Chunk
8482 struct Frame_Chunk
*next
;
8483 unsigned char *chunk_start
;
8485 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8486 short int *col_type
;
8487 int64_t *col_offset
;
8489 unsigned int code_factor
;
8493 unsigned int cfa_reg
;
8494 uint64_t cfa_offset
;
8496 unsigned char fde_encoding
;
8497 unsigned char cfa_exp
;
8498 unsigned char ptr_size
;
8499 unsigned char segment_size
;
8503 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
8504 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
8505 static const char *const *dwarf_regnames
;
8506 static unsigned int dwarf_regnames_count
;
8507 static bool is_aarch64
;
8509 /* A marker for a col_type that means this column was never referenced
8510 in the frame info. */
8511 #define DW_CFA_unreferenced (-1)
8513 /* Return 0 if no more space is needed, 1 if more space is needed,
8514 -1 for invalid reg. */
8517 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
8519 unsigned int prev
= fc
->ncols
;
8521 if (reg
< (unsigned int) fc
->ncols
)
8524 if (dwarf_regnames_count
> 0
8525 && reg
> dwarf_regnames_count
)
8528 fc
->ncols
= reg
+ 1;
8529 /* PR 17512: file: 10450-2643-0.004.
8530 If reg == -1 then this can happen... */
8534 /* PR 17512: file: 2844a11d. */
8535 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
8537 error (_("Unfeasibly large register number: %u\n"), reg
);
8539 /* FIXME: 1024 is an arbitrary limit. Increase it if
8540 we ever encounter a valid binary that exceeds it. */
8544 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
,
8545 sizeof (*fc
->col_type
));
8546 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
,
8547 sizeof (*fc
->col_offset
));
8548 /* PR 17512: file:002-10025-0.005. */
8549 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
8551 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
8557 while (prev
< fc
->ncols
)
8559 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8560 fc
->col_offset
[prev
] = 0;
8566 static const char *const dwarf_regnames_i386
[] =
8568 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8569 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8570 "eip", "eflags", NULL
, /* 8 - 10 */
8571 "st0", "st1", "st2", "st3", /* 11 - 14 */
8572 "st4", "st5", "st6", "st7", /* 15 - 18 */
8573 NULL
, NULL
, /* 19 - 20 */
8574 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
8575 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
8576 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
8577 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
8578 "fcw", "fsw", "mxcsr", /* 37 - 39 */
8579 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8580 "tr", "ldtr", /* 48 - 49 */
8581 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8582 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8583 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8584 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8585 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8586 NULL
, NULL
, NULL
, /* 90 - 92 */
8587 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8590 static const char *const dwarf_regnames_iamcu
[] =
8592 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8593 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8594 "eip", "eflags", NULL
, /* 8 - 10 */
8595 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8596 NULL
, NULL
, /* 19 - 20 */
8597 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8598 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8599 NULL
, NULL
, NULL
, /* 37 - 39 */
8600 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8601 "tr", "ldtr", /* 48 - 49 */
8602 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8603 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8604 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8605 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8606 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8607 NULL
, NULL
, NULL
, /* 90 - 92 */
8608 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8612 init_dwarf_regnames_i386 (void)
8614 dwarf_regnames
= dwarf_regnames_i386
;
8615 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8616 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8620 init_dwarf_regnames_iamcu (void)
8622 dwarf_regnames
= dwarf_regnames_iamcu
;
8623 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8624 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8627 static const char *const DW_CFA_GNU_window_save_name
[] =
8629 "DW_CFA_GNU_window_save",
8630 "DW_CFA_AARCH64_negate_ra_state"
8633 static const char *const dwarf_regnames_x86_64
[] =
8635 "rax", "rdx", "rcx", "rbx",
8636 "rsi", "rdi", "rbp", "rsp",
8637 "r8", "r9", "r10", "r11",
8638 "r12", "r13", "r14", "r15",
8640 "xmm0", "xmm1", "xmm2", "xmm3",
8641 "xmm4", "xmm5", "xmm6", "xmm7",
8642 "xmm8", "xmm9", "xmm10", "xmm11",
8643 "xmm12", "xmm13", "xmm14", "xmm15",
8644 "st0", "st1", "st2", "st3",
8645 "st4", "st5", "st6", "st7",
8646 "mm0", "mm1", "mm2", "mm3",
8647 "mm4", "mm5", "mm6", "mm7",
8649 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8650 "fs.base", "gs.base", NULL
, NULL
,
8652 "mxcsr", "fcw", "fsw",
8653 "xmm16", "xmm17", "xmm18", "xmm19",
8654 "xmm20", "xmm21", "xmm22", "xmm23",
8655 "xmm24", "xmm25", "xmm26", "xmm27",
8656 "xmm28", "xmm29", "xmm30", "xmm31",
8657 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8658 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8659 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8660 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8661 NULL
, NULL
, NULL
, /* 115 - 117 */
8662 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8666 init_dwarf_regnames_x86_64 (void)
8668 dwarf_regnames
= dwarf_regnames_x86_64
;
8669 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8670 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8673 static const char *const dwarf_regnames_aarch64
[] =
8675 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8676 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8677 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8678 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8679 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8680 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8681 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8682 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8683 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8684 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8685 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8686 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8687 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8688 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8689 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8690 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8694 init_dwarf_regnames_aarch64 (void)
8696 dwarf_regnames
= dwarf_regnames_aarch64
;
8697 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8698 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8702 static const char *const dwarf_regnames_s390
[] =
8704 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8705 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8706 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8707 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8708 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8709 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8710 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8711 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8712 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8715 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8716 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8720 init_dwarf_regnames_s390 (void)
8722 dwarf_regnames
= dwarf_regnames_s390
;
8723 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8724 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8727 static const char *const dwarf_regnames_riscv
[] =
8729 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8730 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8731 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8732 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8733 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8734 "fs0", "fs1", /* 40 - 41 */
8735 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8736 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8737 "fs10", "fs11", /* 58 - 59 */
8738 "ft8", "ft9", "ft10", "ft11", /* 60 - 63 */
8739 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 64 - 71 */
8740 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 72 - 79 */
8741 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 80 - 87 */
8742 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 88 - 95 */
8743 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", /* 96 - 103 */
8744 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", /* 104 - 111 */
8745 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", /* 112 - 119 */
8746 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", /* 120 - 127 */
8749 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8750 the large number of CSRs. */
8753 regname_internal_riscv (unsigned int regno
)
8755 const char *name
= NULL
;
8757 /* Lookup in the table first, this covers GPR and FPR. */
8758 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8759 name
= dwarf_regnames_riscv
[regno
];
8760 else if (regno
>= 4096 && regno
<= 8191)
8762 /* This might be a CSR, these live in a sparse number space from 4096
8763 to 8191 These numbers are defined in the RISC-V ELF ABI
8767 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8768 case VALUE + 4096: name = #NAME; break;
8769 #include "opcode/riscv-opc.h"
8774 static char csr_name
[10];
8775 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8786 init_dwarf_regnames_riscv (void)
8788 dwarf_regnames
= NULL
;
8789 dwarf_regnames_count
= 8192;
8790 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8794 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8796 dwarf_regnames_lookup_func
= NULL
;
8802 init_dwarf_regnames_i386 ();
8806 init_dwarf_regnames_iamcu ();
8812 init_dwarf_regnames_x86_64 ();
8816 init_dwarf_regnames_aarch64 ();
8820 init_dwarf_regnames_s390 ();
8824 init_dwarf_regnames_riscv ();
8832 /* Initialize the DWARF register name lookup state based on the
8833 architecture and specific machine type of a BFD. */
8836 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8839 dwarf_regnames_lookup_func
= NULL
;
8847 case bfd_mach_x86_64
:
8848 case bfd_mach_x86_64_intel_syntax
:
8849 case bfd_mach_x64_32
:
8850 case bfd_mach_x64_32_intel_syntax
:
8851 init_dwarf_regnames_x86_64 ();
8855 init_dwarf_regnames_i386 ();
8860 case bfd_arch_iamcu
:
8861 init_dwarf_regnames_iamcu ();
8864 case bfd_arch_aarch64
:
8865 init_dwarf_regnames_aarch64();
8869 init_dwarf_regnames_s390 ();
8872 case bfd_arch_riscv
:
8873 init_dwarf_regnames_riscv ();
8882 regname_internal_by_table_only (unsigned int regno
)
8884 if (dwarf_regnames
!= NULL
8885 && regno
< dwarf_regnames_count
8886 && dwarf_regnames
[regno
] != NULL
)
8887 return dwarf_regnames
[regno
];
8893 regname (unsigned int regno
, int name_only_p
)
8895 static char reg
[64];
8897 const char *name
= NULL
;
8899 if (dwarf_regnames_lookup_func
!= NULL
)
8900 name
= dwarf_regnames_lookup_func (regno
);
8906 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8909 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8914 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8919 if (*max_regs
!= fc
->ncols
)
8920 *max_regs
= fc
->ncols
;
8922 if (*need_col_headers
)
8924 *need_col_headers
= 0;
8926 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8928 for (r
= 0; r
< *max_regs
; r
++)
8929 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8934 printf ("%-5s ", regname (r
, 1));
8940 print_hex (fc
->pc_begin
, eh_addr_size
);
8942 strcpy (tmp
, "exp");
8944 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8945 printf ("%-8s ", tmp
);
8947 for (r
= 0; r
< fc
->ncols
; r
++)
8949 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8951 switch (fc
->col_type
[r
])
8953 case DW_CFA_undefined
:
8956 case DW_CFA_same_value
:
8960 sprintf (tmp
, "c%+" PRId64
, fc
->col_offset
[r
]);
8962 case DW_CFA_val_offset
:
8963 sprintf (tmp
, "v%+" PRId64
, fc
->col_offset
[r
]);
8965 case DW_CFA_register
:
8966 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8968 case DW_CFA_expression
:
8969 strcpy (tmp
, "exp");
8971 case DW_CFA_val_expression
:
8972 strcpy (tmp
, "vexp");
8975 strcpy (tmp
, "n/a");
8978 printf ("%-5s ", tmp
);
8984 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8986 static unsigned char *
8987 read_cie (unsigned char *start
, unsigned char *end
,
8988 Frame_Chunk
**p_cie
, int *p_version
,
8989 uint64_t *p_aug_len
, unsigned char **p_aug
)
8993 unsigned char *augmentation_data
= NULL
;
8994 uint64_t augmentation_data_len
= 0;
8997 /* PR 17512: file: 001-228113-0.004. */
9001 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9002 memset (fc
, 0, sizeof (Frame_Chunk
));
9004 fc
->col_type
= xmalloc (sizeof (*fc
->col_type
));
9005 fc
->col_offset
= xmalloc (sizeof (*fc
->col_offset
));
9009 fc
->augmentation
= (char *) start
;
9010 /* PR 17512: file: 001-228113-0.004.
9011 Skip past augmentation name, but avoid running off the end of the data. */
9013 if (* start
++ == '\0')
9017 warn (_("No terminator for augmentation name\n"));
9021 if (strcmp (fc
->augmentation
, "eh") == 0)
9023 if (eh_addr_size
> (size_t) (end
- start
))
9025 start
+= eh_addr_size
;
9030 if (2 > (size_t) (end
- start
))
9032 GET (fc
->ptr_size
, 1);
9033 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
9035 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
9039 GET (fc
->segment_size
, 1);
9040 /* PR 17512: file: e99d2804. */
9041 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
9043 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
9047 eh_addr_size
= fc
->ptr_size
;
9051 fc
->ptr_size
= eh_addr_size
;
9052 fc
->segment_size
= 0;
9055 READ_ULEB (fc
->code_factor
, start
, end
);
9056 READ_SLEB (fc
->data_factor
, start
, end
);
9067 READ_ULEB (fc
->ra
, start
, end
);
9070 if (fc
->augmentation
[0] == 'z')
9074 READ_ULEB (augmentation_data_len
, start
, end
);
9075 augmentation_data
= start
;
9076 /* PR 17512: file: 11042-2589-0.004. */
9077 if (augmentation_data_len
> (size_t) (end
- start
))
9079 warn (_("Augmentation data too long: %#" PRIx64
9080 ", expected at most %#tx\n"),
9081 augmentation_data_len
, end
- start
);
9084 start
+= augmentation_data_len
;
9087 if (augmentation_data_len
)
9091 unsigned char *qend
;
9093 p
= (unsigned char *) fc
->augmentation
+ 1;
9094 q
= augmentation_data
;
9095 qend
= q
+ augmentation_data_len
;
9097 while (p
< end
&& q
< qend
)
9102 q
+= 1 + size_of_encoded_value (*q
);
9104 fc
->fde_encoding
= *q
++;
9113 /* Note - it is OK if this loop terminates with q < qend.
9114 Padding may have been inserted to align the end of the CIE. */
9119 *p_version
= version
;
9122 *p_aug_len
= augmentation_data_len
;
9123 *p_aug
= augmentation_data
;
9128 free (fc
->col_offset
);
9129 free (fc
->col_type
);
9134 /* Prints out the contents on the DATA array formatted as unsigned bytes.
9135 If do_wide is not enabled, then formats the output to fit into 80 columns.
9136 PRINTED contains the number of characters already written to the current
9140 display_data (size_t printed
, const unsigned char *data
, size_t len
)
9142 if (do_wide
|| len
< ((80 - printed
) / 3))
9143 for (printed
= 0; printed
< len
; ++printed
)
9144 printf (" %02x", data
[printed
]);
9147 for (printed
= 0; printed
< len
; ++printed
)
9149 if (printed
% (80 / 3) == 0)
9151 printf (" %02x", data
[printed
]);
9156 /* Prints out the contents on the augmentation data array.
9157 If do_wide is not enabled, then formats the output to fit into 80 columns. */
9160 display_augmentation_data (const unsigned char * data
, uint64_t len
)
9164 i
= printf (_(" Augmentation data: "));
9165 display_data (i
, data
, len
);
9169 display_debug_frames (struct dwarf_section
*section
,
9170 void *file ATTRIBUTE_UNUSED
)
9172 unsigned char *start
= section
->start
;
9173 unsigned char *end
= start
+ section
->size
;
9174 unsigned char *section_start
= start
;
9175 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
9176 Frame_Chunk
*remembered_state
= NULL
;
9178 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
9179 unsigned int max_regs
= 0;
9180 const char *bad_reg
= _("bad register: ");
9181 unsigned int saved_eh_addr_size
= eh_addr_size
;
9183 introduce (section
, false);
9187 unsigned char *saved_start
;
9188 unsigned char *block_end
;
9193 int need_col_headers
= 1;
9194 unsigned char *augmentation_data
= NULL
;
9195 uint64_t augmentation_data_len
= 0;
9196 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
9197 unsigned int offset_size
;
9199 static Frame_Chunk fde_fc
;
9201 saved_start
= start
;
9203 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
9207 printf ("\n%08tx ZERO terminator\n\n",
9208 saved_start
- section_start
);
9209 /* Skip any zero terminators that directly follow.
9210 A corrupt section size could have loaded a whole
9211 slew of zero filled memory bytes. eg
9212 PR 17512: file: 070-19381-0.004. */
9213 while (start
< end
&& * start
== 0)
9218 if (length
== 0xffffffff)
9220 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
9226 if (length
> (size_t) (end
- start
))
9228 warn ("Invalid length %#" PRIx64
" in FDE at %#tx\n",
9229 length
, saved_start
- section_start
);
9233 block_end
= start
+ length
;
9235 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
9237 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
9238 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
9243 start
= read_cie (start
, block_end
, &cie
, &version
,
9244 &augmentation_data_len
, &augmentation_data
);
9245 /* PR 17512: file: 027-135133-0.005. */
9252 fc
->chunk_start
= saved_start
;
9253 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
9256 if (frame_need_space (fc
, mreg
) < 0)
9258 if (fc
->fde_encoding
)
9259 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9261 printf ("\n%08tx ", saved_start
- section_start
);
9262 print_hex (length
, fc
->ptr_size
);
9263 print_hex (cie_id
, offset_size
);
9265 if (do_debug_frames_interp
)
9267 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
9268 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
9273 printf (" Version: %d\n", version
);
9274 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9277 printf (" Pointer Size: %u\n", fc
->ptr_size
);
9278 printf (" Segment Size: %u\n", fc
->segment_size
);
9280 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9281 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9282 printf (" Return address column: %d\n", fc
->ra
);
9284 if (augmentation_data_len
)
9285 display_augmentation_data (augmentation_data
, augmentation_data_len
);
9292 unsigned char *look_for
;
9293 unsigned long segment_selector
;
9299 uint64_t sign
= (uint64_t) 1 << (offset_size
* 8 - 1);
9300 cie_off
= (cie_off
^ sign
) - sign
;
9301 cie_off
= start
- 4 - section_start
- cie_off
;
9304 look_for
= section_start
+ cie_off
;
9305 if (cie_off
<= (size_t) (saved_start
- section_start
))
9307 for (cie
= chunks
; cie
; cie
= cie
->next
)
9308 if (cie
->chunk_start
== look_for
)
9311 else if (cie_off
>= section
->size
)
9315 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
9316 if (cie
->chunk_start
== look_for
)
9320 unsigned int off_size
;
9321 unsigned char *cie_scan
;
9323 cie_scan
= look_for
;
9325 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
9326 if (length
== 0xffffffff)
9328 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
9331 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
9334 unsigned char *cie_end
= cie_scan
+ length
;
9336 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
9340 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
9341 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
9346 read_cie (cie_scan
, cie_end
, &cie
, &version
,
9347 &augmentation_data_len
, &augmentation_data
);
9348 /* PR 17512: file: 3450-2098-0.004. */
9351 warn (_("Failed to read CIE information\n"));
9354 cie
->next
= forward_refs
;
9356 cie
->chunk_start
= look_for
;
9357 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
9360 if (frame_need_space (cie
, mreg
) < 0)
9362 warn (_("Invalid max register\n"));
9365 if (cie
->fde_encoding
)
9367 = size_of_encoded_value (cie
->fde_encoding
);
9374 memset (fc
, 0, sizeof (Frame_Chunk
));
9379 fc
->col_type
= xmalloc (sizeof (*fc
->col_type
));
9380 fc
->col_offset
= xmalloc (sizeof (*fc
->col_offset
));
9381 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
9383 warn (_("Invalid max register\n"));
9387 fc
->augmentation
= "";
9388 fc
->fde_encoding
= 0;
9389 fc
->ptr_size
= eh_addr_size
;
9390 fc
->segment_size
= 0;
9394 fc
->ncols
= cie
->ncols
;
9395 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (*fc
->col_type
));
9396 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (*fc
->col_offset
));
9397 memcpy (fc
->col_type
, cie
->col_type
,
9398 fc
->ncols
* sizeof (*fc
->col_type
));
9399 memcpy (fc
->col_offset
, cie
->col_offset
,
9400 fc
->ncols
* sizeof (*fc
->col_offset
));
9401 fc
->augmentation
= cie
->augmentation
;
9402 fc
->ptr_size
= cie
->ptr_size
;
9403 eh_addr_size
= cie
->ptr_size
;
9404 fc
->segment_size
= cie
->segment_size
;
9405 fc
->code_factor
= cie
->code_factor
;
9406 fc
->data_factor
= cie
->data_factor
;
9407 fc
->cfa_reg
= cie
->cfa_reg
;
9408 fc
->cfa_offset
= cie
->cfa_offset
;
9410 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
9412 warn (_("Invalid max register\n"));
9415 fc
->fde_encoding
= cie
->fde_encoding
;
9418 if (fc
->fde_encoding
)
9419 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9421 segment_selector
= 0;
9422 if (fc
->segment_size
)
9424 if (fc
->segment_size
> sizeof (segment_selector
))
9426 /* PR 17512: file: 9e196b3e. */
9427 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
9428 fc
->segment_size
= 4;
9430 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
9431 fc
->segment_size
, block_end
);
9434 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9437 /* FIXME: It appears that sometimes the final pc_range value is
9438 encoded in less than encoded_ptr_size bytes. See the x86_64
9439 run of the "objcopy on compressed debug sections" test for an
9441 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
9444 if (cie
->augmentation
[0] == 'z')
9446 READ_ULEB (augmentation_data_len
, start
, block_end
);
9447 augmentation_data
= start
;
9448 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
9449 if (augmentation_data_len
> (size_t) (block_end
- start
))
9451 warn (_("Augmentation data too long: %#" PRIx64
", "
9452 "expected at most %#tx\n"),
9453 augmentation_data_len
, block_end
- start
);
9455 augmentation_data
= NULL
;
9456 augmentation_data_len
= 0;
9458 start
+= augmentation_data_len
;
9461 printf ("\n%08tx ", saved_start
- section_start
);
9462 print_hex (length
, fc
->ptr_size
);
9463 print_hex (cie_id
, offset_size
);
9466 if (cie
->chunk_start
)
9467 printf ("cie=%08tx", cie
->chunk_start
- section_start
);
9469 /* Ideally translate "invalid " to 8 chars, trailing space
9471 printf (_("cie=invalid "));
9474 if (fc
->segment_size
)
9475 printf ("%04lx:", segment_selector
);
9477 print_hex_ns (fc
->pc_begin
, fc
->ptr_size
);
9479 print_hex_ns (fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
);
9482 if (! do_debug_frames_interp
&& augmentation_data_len
)
9484 display_augmentation_data (augmentation_data
, augmentation_data_len
);
9489 /* At this point, fc is the current chunk, cie (if any) is set, and
9490 we're about to interpret instructions for the chunk. */
9491 /* ??? At present we need to do this always, since this sizes the
9492 fc->col_type and fc->col_offset arrays, which we write into always.
9493 We should probably split the interpreted and non-interpreted bits
9494 into two different routines, since there's so much that doesn't
9495 really overlap between them. */
9496 if (1 || do_debug_frames_interp
)
9498 /* Start by making a pass over the chunk, allocating storage
9499 and taking note of what registers are used. */
9500 unsigned char *tmp
= start
;
9502 while (start
< block_end
)
9504 unsigned int reg
, op
, opa
;
9512 /* Warning: if you add any more cases to this switch, be
9513 sure to add them to the corresponding switch below. */
9517 case DW_CFA_advance_loc
:
9520 SKIP_ULEB (start
, block_end
);
9523 case DW_CFA_restore
:
9526 case DW_CFA_set_loc
:
9527 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
9530 start
+= encoded_ptr_size
;
9532 case DW_CFA_advance_loc1
:
9533 if ((size_t) (block_end
- start
) < 1)
9538 case DW_CFA_advance_loc2
:
9539 if ((size_t) (block_end
- start
) < 2)
9544 case DW_CFA_advance_loc4
:
9545 if ((size_t) (block_end
- start
) < 4)
9550 case DW_CFA_offset_extended
:
9551 case DW_CFA_val_offset
:
9552 READ_ULEB (reg
, start
, block_end
);
9553 SKIP_ULEB (start
, block_end
);
9555 case DW_CFA_restore_extended
:
9556 READ_ULEB (reg
, start
, block_end
);
9558 case DW_CFA_undefined
:
9559 READ_ULEB (reg
, start
, block_end
);
9561 case DW_CFA_same_value
:
9562 READ_ULEB (reg
, start
, block_end
);
9564 case DW_CFA_register
:
9565 READ_ULEB (reg
, start
, block_end
);
9566 SKIP_ULEB (start
, block_end
);
9568 case DW_CFA_def_cfa
:
9569 SKIP_ULEB (start
, block_end
);
9570 SKIP_ULEB (start
, block_end
);
9572 case DW_CFA_def_cfa_register
:
9573 SKIP_ULEB (start
, block_end
);
9575 case DW_CFA_def_cfa_offset
:
9576 SKIP_ULEB (start
, block_end
);
9578 case DW_CFA_def_cfa_expression
:
9579 READ_ULEB (temp
, start
, block_end
);
9580 if ((size_t) (block_end
- start
) < temp
)
9585 case DW_CFA_expression
:
9586 case DW_CFA_val_expression
:
9587 READ_ULEB (reg
, start
, block_end
);
9588 READ_ULEB (temp
, start
, block_end
);
9589 if ((size_t) (block_end
- start
) < temp
)
9594 case DW_CFA_offset_extended_sf
:
9595 case DW_CFA_val_offset_sf
:
9596 READ_ULEB (reg
, start
, block_end
);
9597 SKIP_SLEB (start
, block_end
);
9599 case DW_CFA_def_cfa_sf
:
9600 SKIP_ULEB (start
, block_end
);
9601 SKIP_SLEB (start
, block_end
);
9603 case DW_CFA_def_cfa_offset_sf
:
9604 SKIP_SLEB (start
, block_end
);
9606 case DW_CFA_MIPS_advance_loc8
:
9607 if ((size_t) (block_end
- start
) < 8)
9612 case DW_CFA_GNU_args_size
:
9613 SKIP_ULEB (start
, block_end
);
9615 case DW_CFA_GNU_negative_offset_extended
:
9616 READ_ULEB (reg
, start
, block_end
);
9617 SKIP_ULEB (start
, block_end
);
9622 if (reg
!= -1u && frame_need_space (fc
, reg
) >= 0)
9624 /* Don't leave any reg as DW_CFA_unreferenced so
9625 that frame_display_row prints name of regs in
9626 header, and all referenced regs in each line. */
9627 if (reg
>= cie
->ncols
9628 || cie
->col_type
[reg
] == DW_CFA_unreferenced
)
9629 fc
->col_type
[reg
] = DW_CFA_undefined
;
9631 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9639 /* Now we know what registers are used, make a second pass over
9640 the chunk, this time actually printing out the info. */
9642 while (start
< block_end
)
9645 /* Note: It is tempting to use an unsigned long for 'reg' but there
9646 are various functions, notably frame_space_needed() that assume that
9647 reg is an unsigned int. */
9651 const char *reg_prefix
= "";
9658 /* Make a note if something other than DW_CFA_nop happens. */
9659 if (op
!= DW_CFA_nop
)
9662 /* Warning: if you add any more cases to this switch, be
9663 sure to add them to the corresponding switch above. */
9666 case DW_CFA_advance_loc
:
9667 opa
*= fc
->code_factor
;
9668 if (do_debug_frames_interp
)
9669 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9672 printf (" DW_CFA_advance_loc: %d to ", opa
);
9673 print_hex_ns (fc
->pc_begin
+ opa
, fc
->ptr_size
);
9676 fc
->pc_begin
+= opa
;
9680 READ_ULEB (ofs
, start
, block_end
);
9681 ofs
*= fc
->data_factor
;
9682 if (opa
>= fc
->ncols
)
9683 reg_prefix
= bad_reg
;
9684 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9685 printf (" DW_CFA_offset: %s%s at cfa%+" PRId64
"\n",
9686 reg_prefix
, regname (opa
, 0), ofs
);
9687 if (*reg_prefix
== '\0')
9689 fc
->col_type
[opa
] = DW_CFA_offset
;
9690 fc
->col_offset
[opa
] = ofs
;
9694 case DW_CFA_restore
:
9695 if (opa
>= fc
->ncols
)
9696 reg_prefix
= bad_reg
;
9697 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9698 printf (" DW_CFA_restore: %s%s\n",
9699 reg_prefix
, regname (opa
, 0));
9700 if (*reg_prefix
!= '\0')
9703 if (opa
>= cie
->ncols
9704 || cie
->col_type
[opa
] == DW_CFA_unreferenced
)
9706 fc
->col_type
[opa
] = DW_CFA_undefined
;
9707 fc
->col_offset
[opa
] = 0;
9711 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9712 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9716 case DW_CFA_set_loc
:
9717 ofs
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9719 if (do_debug_frames_interp
)
9720 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9723 printf (" DW_CFA_set_loc: ");
9724 print_hex_ns (ofs
, fc
->ptr_size
);
9730 case DW_CFA_advance_loc1
:
9731 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9732 ofs
*= fc
->code_factor
;
9733 if (do_debug_frames_interp
)
9734 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9737 printf (" DW_CFA_advance_loc1: %" PRId64
" to ", ofs
);
9738 print_hex_ns (fc
->pc_begin
+ ofs
, fc
->ptr_size
);
9741 fc
->pc_begin
+= ofs
;
9744 case DW_CFA_advance_loc2
:
9745 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9746 ofs
*= fc
->code_factor
;
9747 if (do_debug_frames_interp
)
9748 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9751 printf (" DW_CFA_advance_loc2: %" PRId64
" to ", ofs
);
9752 print_hex_ns (fc
->pc_begin
+ ofs
, fc
->ptr_size
);
9755 fc
->pc_begin
+= ofs
;
9758 case DW_CFA_advance_loc4
:
9759 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9760 ofs
*= fc
->code_factor
;
9761 if (do_debug_frames_interp
)
9762 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9765 printf (" DW_CFA_advance_loc4: %" PRId64
" to ", ofs
);
9766 print_hex_ns (fc
->pc_begin
+ ofs
, fc
->ptr_size
);
9769 fc
->pc_begin
+= ofs
;
9772 case DW_CFA_offset_extended
:
9773 READ_ULEB (reg
, start
, block_end
);
9774 READ_ULEB (ofs
, start
, block_end
);
9775 ofs
*= fc
->data_factor
;
9776 if (reg
>= fc
->ncols
)
9777 reg_prefix
= bad_reg
;
9778 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9779 printf (" DW_CFA_offset_extended: %s%s at cfa%+" PRId64
"\n",
9780 reg_prefix
, regname (reg
, 0), ofs
);
9781 if (*reg_prefix
== '\0')
9783 fc
->col_type
[reg
] = DW_CFA_offset
;
9784 fc
->col_offset
[reg
] = ofs
;
9788 case DW_CFA_val_offset
:
9789 READ_ULEB (reg
, start
, block_end
);
9790 READ_ULEB (ofs
, start
, block_end
);
9791 ofs
*= fc
->data_factor
;
9792 if (reg
>= fc
->ncols
)
9793 reg_prefix
= bad_reg
;
9794 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9795 printf (" DW_CFA_val_offset: %s%s is cfa%+" PRId64
"\n",
9796 reg_prefix
, regname (reg
, 0), ofs
);
9797 if (*reg_prefix
== '\0')
9799 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9800 fc
->col_offset
[reg
] = ofs
;
9804 case DW_CFA_restore_extended
:
9805 READ_ULEB (reg
, start
, block_end
);
9806 if (reg
>= fc
->ncols
)
9807 reg_prefix
= bad_reg
;
9808 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9809 printf (" DW_CFA_restore_extended: %s%s\n",
9810 reg_prefix
, regname (reg
, 0));
9811 if (*reg_prefix
!= '\0')
9814 if (reg
>= cie
->ncols
9815 || cie
->col_type
[reg
] == DW_CFA_unreferenced
)
9817 fc
->col_type
[reg
] = DW_CFA_undefined
;
9818 fc
->col_offset
[reg
] = 0;
9822 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9823 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9827 case DW_CFA_undefined
:
9828 READ_ULEB (reg
, start
, block_end
);
9829 if (reg
>= fc
->ncols
)
9830 reg_prefix
= bad_reg
;
9831 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9832 printf (" DW_CFA_undefined: %s%s\n",
9833 reg_prefix
, regname (reg
, 0));
9834 if (*reg_prefix
== '\0')
9836 fc
->col_type
[reg
] = DW_CFA_undefined
;
9837 fc
->col_offset
[reg
] = 0;
9841 case DW_CFA_same_value
:
9842 READ_ULEB (reg
, start
, block_end
);
9843 if (reg
>= fc
->ncols
)
9844 reg_prefix
= bad_reg
;
9845 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9846 printf (" DW_CFA_same_value: %s%s\n",
9847 reg_prefix
, regname (reg
, 0));
9848 if (*reg_prefix
== '\0')
9850 fc
->col_type
[reg
] = DW_CFA_same_value
;
9851 fc
->col_offset
[reg
] = 0;
9855 case DW_CFA_register
:
9856 READ_ULEB (reg
, start
, block_end
);
9857 READ_ULEB (ofs
, start
, block_end
);
9858 if (reg
>= fc
->ncols
)
9859 reg_prefix
= bad_reg
;
9860 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9862 printf (" DW_CFA_register: %s%s in ",
9863 reg_prefix
, regname (reg
, 0));
9864 puts (regname (ofs
, 0));
9866 if (*reg_prefix
== '\0')
9868 fc
->col_type
[reg
] = DW_CFA_register
;
9869 fc
->col_offset
[reg
] = ofs
;
9873 case DW_CFA_remember_state
:
9874 if (! do_debug_frames_interp
)
9875 printf (" DW_CFA_remember_state\n");
9876 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9877 rs
->cfa_offset
= fc
->cfa_offset
;
9878 rs
->cfa_reg
= fc
->cfa_reg
;
9880 rs
->cfa_exp
= fc
->cfa_exp
;
9881 rs
->ncols
= fc
->ncols
;
9882 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (*rs
->col_type
));
9883 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (*rs
->col_offset
));
9884 memcpy (rs
->col_type
, fc
->col_type
,
9885 rs
->ncols
* sizeof (*fc
->col_type
));
9886 memcpy (rs
->col_offset
, fc
->col_offset
,
9887 rs
->ncols
* sizeof (*fc
->col_offset
));
9888 rs
->next
= remembered_state
;
9889 remembered_state
= rs
;
9892 case DW_CFA_restore_state
:
9893 if (! do_debug_frames_interp
)
9894 printf (" DW_CFA_restore_state\n");
9895 rs
= remembered_state
;
9898 remembered_state
= rs
->next
;
9899 fc
->cfa_offset
= rs
->cfa_offset
;
9900 fc
->cfa_reg
= rs
->cfa_reg
;
9902 fc
->cfa_exp
= rs
->cfa_exp
;
9903 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9905 warn (_("Invalid column number in saved frame state\n"));
9910 memcpy (fc
->col_type
, rs
->col_type
,
9911 rs
->ncols
* sizeof (*rs
->col_type
));
9912 memcpy (fc
->col_offset
, rs
->col_offset
,
9913 rs
->ncols
* sizeof (*rs
->col_offset
));
9915 free (rs
->col_type
);
9916 free (rs
->col_offset
);
9919 else if (do_debug_frames_interp
)
9920 printf ("Mismatched DW_CFA_restore_state\n");
9923 case DW_CFA_def_cfa
:
9924 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9925 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9927 if (! do_debug_frames_interp
)
9928 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9929 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9932 case DW_CFA_def_cfa_register
:
9933 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9935 if (! do_debug_frames_interp
)
9936 printf (" DW_CFA_def_cfa_register: %s\n",
9937 regname (fc
->cfa_reg
, 0));
9940 case DW_CFA_def_cfa_offset
:
9941 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9942 if (! do_debug_frames_interp
)
9943 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9947 if (! do_debug_frames_interp
)
9948 printf (" DW_CFA_nop\n");
9951 case DW_CFA_def_cfa_expression
:
9952 READ_ULEB (ofs
, start
, block_end
);
9953 if (ofs
> (size_t) (block_end
- start
))
9955 printf (_(" %s: <corrupt len %" PRIu64
">\n"),
9956 "DW_CFA_def_cfa_expression", ofs
);
9959 if (! do_debug_frames_interp
)
9961 printf (" DW_CFA_def_cfa_expression (");
9962 decode_location_expression (start
, eh_addr_size
, 0, -1,
9970 case DW_CFA_expression
:
9971 READ_ULEB (reg
, start
, block_end
);
9972 READ_ULEB (ofs
, start
, block_end
);
9973 if (reg
>= fc
->ncols
)
9974 reg_prefix
= bad_reg
;
9975 /* PR 17512: file: 069-133014-0.006. */
9976 /* PR 17512: file: 98c02eb4. */
9977 if (ofs
> (size_t) (block_end
- start
))
9979 printf (_(" %s: <corrupt len %" PRIu64
">\n"),
9980 "DW_CFA_expression", ofs
);
9983 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9985 printf (" DW_CFA_expression: %s%s (",
9986 reg_prefix
, regname (reg
, 0));
9987 decode_location_expression (start
, eh_addr_size
, 0, -1,
9991 if (*reg_prefix
== '\0')
9992 fc
->col_type
[reg
] = DW_CFA_expression
;
9996 case DW_CFA_val_expression
:
9997 READ_ULEB (reg
, start
, block_end
);
9998 READ_ULEB (ofs
, start
, block_end
);
9999 if (reg
>= fc
->ncols
)
10000 reg_prefix
= bad_reg
;
10001 if (ofs
> (size_t) (block_end
- start
))
10003 printf (" %s: <corrupt len %" PRIu64
">\n",
10004 "DW_CFA_val_expression", ofs
);
10007 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
10009 printf (" DW_CFA_val_expression: %s%s (",
10010 reg_prefix
, regname (reg
, 0));
10011 decode_location_expression (start
, eh_addr_size
, 0, -1,
10015 if (*reg_prefix
== '\0')
10016 fc
->col_type
[reg
] = DW_CFA_val_expression
;
10020 case DW_CFA_offset_extended_sf
:
10021 READ_ULEB (reg
, start
, block_end
);
10022 READ_SLEB (sofs
, start
, block_end
);
10023 /* data_factor multiplicaton done here as unsigned to
10024 avoid integer overflow warnings from asan on fuzzed
10027 ofs
*= fc
->data_factor
;
10028 if (reg
>= fc
->ncols
)
10029 reg_prefix
= bad_reg
;
10030 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
10031 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+" PRId64
"\n",
10032 reg_prefix
, regname (reg
, 0), ofs
);
10033 if (*reg_prefix
== '\0')
10035 fc
->col_type
[reg
] = DW_CFA_offset
;
10036 fc
->col_offset
[reg
] = ofs
;
10040 case DW_CFA_val_offset_sf
:
10041 READ_ULEB (reg
, start
, block_end
);
10042 READ_SLEB (sofs
, start
, block_end
);
10044 ofs
*= fc
->data_factor
;
10045 if (reg
>= fc
->ncols
)
10046 reg_prefix
= bad_reg
;
10047 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
10048 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+" PRId64
"\n",
10049 reg_prefix
, regname (reg
, 0), ofs
);
10050 if (*reg_prefix
== '\0')
10052 fc
->col_type
[reg
] = DW_CFA_val_offset
;
10053 fc
->col_offset
[reg
] = ofs
;
10057 case DW_CFA_def_cfa_sf
:
10058 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
10059 READ_SLEB (sofs
, start
, block_end
);
10061 ofs
*= fc
->data_factor
;
10062 fc
->cfa_offset
= ofs
;
10064 if (! do_debug_frames_interp
)
10065 printf (" DW_CFA_def_cfa_sf: %s ofs %" PRId64
"\n",
10066 regname (fc
->cfa_reg
, 0), ofs
);
10069 case DW_CFA_def_cfa_offset_sf
:
10070 READ_SLEB (sofs
, start
, block_end
);
10072 ofs
*= fc
->data_factor
;
10073 fc
->cfa_offset
= ofs
;
10074 if (! do_debug_frames_interp
)
10075 printf (" DW_CFA_def_cfa_offset_sf: %" PRId64
"\n", ofs
);
10078 case DW_CFA_MIPS_advance_loc8
:
10079 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
10080 ofs
*= fc
->code_factor
;
10081 if (do_debug_frames_interp
)
10082 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10085 printf (" DW_CFA_MIPS_advance_loc8: %" PRId64
" to ", ofs
);
10086 print_hex_ns (fc
->pc_begin
+ ofs
, fc
->ptr_size
);
10089 fc
->pc_begin
+= ofs
;
10092 case DW_CFA_GNU_window_save
:
10093 if (! do_debug_frames_interp
)
10094 printf (" %s\n", DW_CFA_GNU_window_save_name
[is_aarch64
]);
10097 case DW_CFA_GNU_args_size
:
10098 READ_ULEB (ofs
, start
, block_end
);
10099 if (! do_debug_frames_interp
)
10100 printf (" DW_CFA_GNU_args_size: %" PRIu64
"\n", ofs
);
10103 case DW_CFA_GNU_negative_offset_extended
:
10104 READ_ULEB (reg
, start
, block_end
);
10105 READ_SLEB (sofs
, start
, block_end
);
10107 ofs
= -ofs
* fc
->data_factor
;
10108 if (reg
>= fc
->ncols
)
10109 reg_prefix
= bad_reg
;
10110 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
10111 printf (" DW_CFA_GNU_negative_offset_extended: %s%s "
10112 "at cfa%+" PRId64
"\n",
10113 reg_prefix
, regname (reg
, 0), ofs
);
10114 if (*reg_prefix
== '\0')
10116 fc
->col_type
[reg
] = DW_CFA_offset
;
10117 fc
->col_offset
[reg
] = ofs
;
10122 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
10123 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
10125 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
10130 /* Interpret the CFA - as long as it is not completely full of NOPs. */
10131 if (do_debug_frames_interp
&& ! all_nops
)
10132 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10134 if (fde_fc
.col_type
!= NULL
)
10136 free (fde_fc
.col_type
);
10137 fde_fc
.col_type
= NULL
;
10139 if (fde_fc
.col_offset
!= NULL
)
10141 free (fde_fc
.col_offset
);
10142 fde_fc
.col_offset
= NULL
;
10146 eh_addr_size
= saved_eh_addr_size
;
10151 while (remembered_state
!= NULL
)
10153 rs
= remembered_state
;
10154 remembered_state
= rs
->next
;
10155 free (rs
->col_type
);
10156 free (rs
->col_offset
);
10157 rs
->next
= NULL
; /* Paranoia. */
10161 while (chunks
!= NULL
)
10165 free (rs
->col_type
);
10166 free (rs
->col_offset
);
10167 rs
->next
= NULL
; /* Paranoia. */
10171 while (forward_refs
!= NULL
)
10174 forward_refs
= rs
->next
;
10175 free (rs
->col_type
);
10176 free (rs
->col_offset
);
10177 rs
->next
= NULL
; /* Paranoia. */
10187 display_debug_names (struct dwarf_section
*section
, void *file
)
10189 unsigned char *hdrptr
= section
->start
;
10190 uint64_t unit_length
;
10191 unsigned char *unit_start
;
10192 const unsigned char *const section_end
= section
->start
+ section
->size
;
10193 unsigned char *unit_end
;
10195 introduce (section
, false);
10197 load_debug_section_with_follow (str
, file
);
10199 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
10201 unsigned int offset_size
;
10202 uint16_t dwarf_version
, padding
;
10203 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
10204 uint64_t bucket_count
, name_count
, abbrev_table_size
;
10205 uint32_t augmentation_string_size
;
10207 bool augmentation_printable
;
10208 const char *augmentation_string
;
10211 unit_start
= hdrptr
;
10213 /* Get and check the length of the block. */
10214 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
10216 if (unit_length
== 0xffffffff)
10218 /* This section is 64-bit DWARF. */
10219 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
10225 if (unit_length
> (size_t) (section_end
- hdrptr
)
10226 || unit_length
< 2 + 2 + 4 * 7)
10229 warn (_("Debug info is corrupted, %s header at %#tx"
10230 " has length %#" PRIx64
"\n"),
10231 section
->name
, unit_start
- section
->start
, unit_length
);
10234 unit_end
= hdrptr
+ unit_length
;
10236 /* Get and check the version number. */
10237 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
10238 printf (_("Version %d\n"), (int) dwarf_version
);
10240 /* Prior versions did not exist, and future versions may not be
10241 backwards compatible. */
10242 if (dwarf_version
!= 5)
10244 warn (_("Only DWARF version 5 .debug_names "
10245 "is currently supported.\n"));
10249 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
10251 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
10254 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
10255 if (comp_unit_count
== 0)
10256 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
10258 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
10259 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
10260 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
10261 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
10262 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
10264 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
10265 if (augmentation_string_size
% 4 != 0)
10267 warn (_("Augmentation string length %u must be rounded up "
10268 "to a multiple of 4 in .debug_names.\n"),
10269 augmentation_string_size
);
10270 augmentation_string_size
+= (-augmentation_string_size
) & 3;
10272 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
10275 printf (_("Augmentation string:"));
10277 augmentation_printable
= true;
10278 augmentation_string
= (const char *) hdrptr
;
10280 for (i
= 0; i
< augmentation_string_size
; i
++)
10284 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
10285 printf (" %02x", uc
);
10287 if (uc
!= 0 && !ISPRINT (uc
))
10288 augmentation_printable
= false;
10291 if (augmentation_printable
)
10295 i
< augmentation_string_size
&& augmentation_string
[i
];
10297 putchar (augmentation_string
[i
]);
10302 printf (_("CU table:\n"));
10303 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
10304 || total
> (size_t) (unit_end
- hdrptr
))
10306 for (i
= 0; i
< comp_unit_count
; i
++)
10308 uint64_t cu_offset
;
10310 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
10311 printf ("[%3u] %#" PRIx64
"\n", i
, cu_offset
);
10315 printf (_("TU table:\n"));
10316 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
10317 || total
> (size_t) (unit_end
- hdrptr
))
10319 for (i
= 0; i
< local_type_unit_count
; i
++)
10321 uint64_t tu_offset
;
10323 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
10324 printf ("[%3u] %#" PRIx64
"\n", i
, tu_offset
);
10328 printf (_("Foreign TU table:\n"));
10329 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
10330 || total
> (size_t) (unit_end
- hdrptr
))
10332 for (i
= 0; i
< foreign_type_unit_count
; i
++)
10334 uint64_t signature
;
10336 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
10337 printf (_("[%3u] "), i
);
10338 print_hex_ns (signature
, 8);
10343 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
10344 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
10345 + abbrev_table_size
);
10346 if (xtra
> (size_t) (unit_end
- hdrptr
))
10348 warn (_("Entry pool offset (%#" PRIx64
") exceeds unit size %#tx "
10349 "for unit %#tx in the debug_names\n"),
10350 xtra
, unit_end
- unit_start
, unit_start
- section
->start
);
10353 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
10354 hdrptr
+= bucket_count
* sizeof (uint32_t);
10355 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
10356 hdrptr
+= name_count
* sizeof (uint32_t);
10357 unsigned char *const name_table_string_offsets
= hdrptr
;
10358 hdrptr
+= name_count
* offset_size
;
10359 unsigned char *const name_table_entry_offsets
= hdrptr
;
10360 hdrptr
+= name_count
* offset_size
;
10361 unsigned char *const abbrev_table
= hdrptr
;
10362 hdrptr
+= abbrev_table_size
;
10363 const unsigned char *const abbrev_table_end
= hdrptr
;
10364 unsigned char *const entry_pool
= hdrptr
;
10366 size_t buckets_filled
= 0;
10368 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
10370 const uint32_t bucket
= hash_table_buckets
[bucketi
];
10375 printf (ngettext ("Used %zu of %lu bucket.\n",
10376 "Used %zu of %lu buckets.\n",
10377 (unsigned long) bucket_count
),
10378 buckets_filled
, (unsigned long) bucket_count
);
10380 if (bucket_count
!= 0)
10382 uint32_t hash_prev
= 0;
10383 size_t hash_clash_count
= 0;
10384 size_t longest_clash
= 0;
10385 size_t this_length
= 0;
10387 for (hashi
= 0; hashi
< name_count
; hashi
++)
10389 const uint32_t hash_this
= hash_table_hashes
[hashi
];
10393 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
10395 ++hash_clash_count
;
10397 longest_clash
= MAX (longest_clash
, this_length
);
10402 hash_prev
= hash_this
;
10404 printf (_("Out of %" PRIu64
" items there are %zu bucket clashes"
10405 " (longest of %zu entries).\n"),
10406 name_count
, hash_clash_count
, longest_clash
);
10408 if (name_count
!= buckets_filled
+ hash_clash_count
)
10409 warn (_("The name_count (%" PRIu64
")"
10410 " is not the same as the used bucket_count"
10411 " (%zu) + the hash clash count (%zu)"),
10412 name_count
, buckets_filled
, hash_clash_count
);
10415 struct abbrev_lookup_entry
10417 uint64_t abbrev_tag
;
10418 unsigned char *abbrev_lookup_ptr
;
10420 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
10421 size_t abbrev_lookup_used
= 0;
10422 size_t abbrev_lookup_allocated
= 0;
10424 unsigned char *abbrevptr
= abbrev_table
;
10427 uint64_t abbrev_tag
;
10429 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
10430 if (abbrev_tag
== 0)
10432 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
10434 abbrev_lookup_allocated
= MAX (0x100,
10435 abbrev_lookup_allocated
* 2);
10436 abbrev_lookup
= xrealloc (abbrev_lookup
,
10437 (abbrev_lookup_allocated
10438 * sizeof (*abbrev_lookup
)));
10440 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
10441 struct abbrev_lookup_entry
*entry
;
10442 for (entry
= abbrev_lookup
;
10443 entry
< abbrev_lookup
+ abbrev_lookup_used
;
10445 if (entry
->abbrev_tag
== abbrev_tag
)
10447 warn (_("Duplicate abbreviation tag %" PRIu64
10448 " in unit %#tx in the debug_names section\n"),
10449 abbrev_tag
, unit_start
- section
->start
);
10452 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
10453 entry
->abbrev_tag
= abbrev_tag
;
10454 entry
->abbrev_lookup_ptr
= abbrevptr
;
10456 /* Skip DWARF tag. */
10457 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
10460 uint64_t xindex
, form
;
10462 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
10463 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
10464 if (xindex
== 0 && form
== 0)
10469 printf (_("\nSymbol table:\n"));
10471 for (namei
= 0; namei
< name_count
; ++namei
)
10473 uint64_t string_offset
, entry_offset
;
10476 p
= name_table_string_offsets
+ namei
* offset_size
;
10477 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
10478 p
= name_table_entry_offsets
+ namei
* offset_size
;
10479 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
10481 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
10482 fetch_indirect_string (string_offset
));
10484 unsigned char *entryptr
= entry_pool
+ entry_offset
;
10486 /* We need to scan first whether there is a single or multiple
10487 entries. TAGNO is -2 for the first entry, it is -1 for the
10488 initial tag read of the second entry, then it becomes 0 for the
10489 first entry for real printing etc. */
10491 /* Initialize it due to a false compiler warning. */
10492 uint64_t second_abbrev_tag
= -1;
10495 uint64_t abbrev_tag
;
10496 uint64_t dwarf_tag
;
10497 const struct abbrev_lookup_entry
*entry
;
10499 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
10502 second_abbrev_tag
= abbrev_tag
;
10504 entryptr
= entry_pool
+ entry_offset
;
10507 if (abbrev_tag
== 0)
10510 printf ("%s<%" PRIu64
">",
10511 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
10514 for (entry
= abbrev_lookup
;
10515 entry
< abbrev_lookup
+ abbrev_lookup_used
;
10517 if (entry
->abbrev_tag
== abbrev_tag
)
10519 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
10521 warn (_("Undefined abbreviation tag %" PRId64
10522 " in unit %#tx in the debug_names section\n"),
10524 unit_start
- section
->start
);
10527 abbrevptr
= entry
->abbrev_lookup_ptr
;
10528 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
10530 printf (" %s", get_TAG_name (dwarf_tag
));
10533 uint64_t xindex
, form
;
10535 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
10536 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
10537 if (xindex
== 0 && form
== 0)
10541 printf (" %s", get_IDX_name (xindex
));
10542 entryptr
= read_and_display_attr_value (0, form
, 0,
10543 unit_start
, entryptr
, unit_end
,
10545 dwarf_version
, NULL
,
10546 (tagno
< 0), section
,
10552 printf (_(" <no entries>"));
10556 free (abbrev_lookup
);
10563 display_debug_links (struct dwarf_section
* section
,
10564 void * file ATTRIBUTE_UNUSED
)
10566 const unsigned char * filename
;
10567 unsigned int filelen
;
10569 introduce (section
, false);
10571 /* The .gnu_debuglink section is formatted as:
10572 (c-string) Filename.
10573 (padding) If needed to reach a 4 byte boundary.
10574 (uint32_t) CRC32 value.
10576 The .gun_debugaltlink section is formatted as:
10577 (c-string) Filename.
10578 (binary) Build-ID. */
10580 filename
= section
->start
;
10581 filelen
= strnlen ((const char *) filename
, section
->size
);
10582 if (filelen
== section
->size
)
10584 warn (_("The debuglink filename is corrupt/missing\n"));
10588 printf (_(" Separate debug info file: %s\n"), filename
);
10590 if (startswith (section
->name
, ".gnu_debuglink"))
10592 unsigned int crc32
;
10593 unsigned int crc_offset
;
10595 crc_offset
= filelen
+ 1;
10596 crc_offset
= (crc_offset
+ 3) & ~3;
10597 if (crc_offset
+ 4 > section
->size
)
10599 warn (_("CRC offset missing/truncated\n"));
10603 crc32
= byte_get (filename
+ crc_offset
, 4);
10605 printf (_(" CRC value: %#x\n"), crc32
);
10607 if (crc_offset
+ 4 < section
->size
)
10609 warn (_("There are %#" PRIx64
10610 " extraneous bytes at the end of the section\n"),
10611 section
->size
- (crc_offset
+ 4));
10615 else /* startswith (section->name, ".gnu_debugaltlink") */
10617 const unsigned char *build_id
= section
->start
+ filelen
+ 1;
10618 size_t build_id_len
= section
->size
- (filelen
+ 1);
10621 /* FIXME: Should we support smaller build-id notes ? */
10622 if (build_id_len
< 0x14)
10624 warn (_("Build-ID is too short (%#zx bytes)\n"), build_id_len
);
10628 printed
= printf (_(" Build-ID (%#zx bytes):"), build_id_len
);
10629 display_data (printed
, build_id
, build_id_len
);
10638 display_gdb_index (struct dwarf_section
*section
,
10639 void *file ATTRIBUTE_UNUSED
)
10641 unsigned char *start
= section
->start
;
10643 uint32_t cu_list_offset
, tu_list_offset
;
10644 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10645 unsigned int cu_list_elements
, tu_list_elements
;
10646 unsigned int address_table_elements
, symbol_table_slots
;
10647 unsigned char *cu_list
, *tu_list
;
10648 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10651 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10653 introduce (section
, false);
10655 if (section
->size
< 6 * sizeof (uint32_t))
10657 warn (_("Truncated header in the %s section.\n"), section
->name
);
10661 version
= byte_get_little_endian (start
, 4);
10662 printf (_("Version %lu\n"), (unsigned long) version
);
10664 /* Prior versions are obsolete, and future versions may not be
10665 backwards compatible. */
10666 if (version
< 3 || version
> 8)
10668 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10672 warn (_("The address table data in version 3 may be wrong.\n"));
10674 warn (_("Version 4 does not support case insensitive lookups.\n"));
10676 warn (_("Version 5 does not include inlined functions.\n"));
10678 warn (_("Version 6 does not include symbol attributes.\n"));
10679 /* Version 7 indices generated by Gold have bad type unit references,
10680 PR binutils/15021. But we don't know if the index was generated by
10681 Gold or not, so to avoid worrying users with gdb-generated indices
10682 we say nothing for version 7 here. */
10684 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10685 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10686 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10687 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10688 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10690 if (cu_list_offset
> section
->size
10691 || tu_list_offset
> section
->size
10692 || address_table_offset
> section
->size
10693 || symbol_table_offset
> section
->size
10694 || constant_pool_offset
> section
->size
10695 || tu_list_offset
< cu_list_offset
10696 || address_table_offset
< tu_list_offset
10697 || symbol_table_offset
< address_table_offset
10698 || constant_pool_offset
< symbol_table_offset
)
10700 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10704 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 16;
10705 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 24;
10706 address_table_elements
= (symbol_table_offset
- address_table_offset
) / 20;
10707 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10709 cu_list
= start
+ cu_list_offset
;
10710 tu_list
= start
+ tu_list_offset
;
10711 address_table
= start
+ address_table_offset
;
10712 symbol_table
= start
+ symbol_table_offset
;
10713 constant_pool
= start
+ constant_pool_offset
;
10715 printf (_("\nCU table:\n"));
10716 for (i
= 0; i
< cu_list_elements
; i
++)
10718 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 16, 8);
10719 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 16 + 8, 8);
10721 printf ("[%3u] %#" PRIx64
" - %#" PRIx64
"\n",
10722 i
, cu_offset
, cu_offset
+ cu_length
- 1);
10725 printf (_("\nTU table:\n"));
10726 for (i
= 0; i
< tu_list_elements
; i
++)
10728 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 24, 8);
10729 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 24 + 8, 8);
10730 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 24 + 16, 8);
10732 printf ("[%3u] %#" PRIx64
" %#" PRIx64
" ",
10733 i
, tu_offset
, type_offset
);
10734 print_hex_ns (signature
, 8);
10738 printf (_("\nAddress table:\n"));
10739 for (i
= 0; i
< address_table_elements
; i
++)
10741 uint64_t low
= byte_get_little_endian (address_table
+ i
* 20, 8);
10742 uint64_t high
= byte_get_little_endian (address_table
+ i
* 20 + 8, 8);
10743 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
* 20 + 16, 4);
10745 print_hex (low
, 8);
10746 print_hex (high
, 8);
10747 printf ("%" PRIu32
"\n", cu_index
);
10750 printf (_("\nSymbol table:\n"));
10751 for (i
= 0; i
< symbol_table_slots
; ++i
)
10753 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10754 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10755 uint32_t num_cus
, cu
;
10757 if (name_offset
!= 0
10758 || cu_vector_offset
!= 0)
10762 /* PR 17531: file: 5b7b07ad. */
10763 if (name_offset
>= section
->size
- constant_pool_offset
)
10765 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10766 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10770 printf ("[%3u] %.*s:", i
,
10771 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10772 constant_pool
+ name_offset
);
10774 if (section
->size
- constant_pool_offset
< 4
10775 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10777 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10778 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10779 cu_vector_offset
, i
);
10783 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10785 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10786 + cu_vector_offset
+ 4))
10788 printf ("<invalid number of CUs: %d>\n", num_cus
);
10789 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10797 for (j
= 0; j
< num_cus
; ++j
)
10800 gdb_index_symbol_kind kind
;
10802 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10803 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10804 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10805 cu
= GDB_INDEX_CU_VALUE (cu
);
10806 /* Convert to TU number if it's for a type unit. */
10807 if (cu
>= cu_list_elements
)
10808 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10809 (unsigned long) cu
- cu_list_elements
);
10811 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10813 printf (" [%s, %s]",
10814 is_static
? _("static") : _("global"),
10815 get_gdb_index_symbol_kind_name (kind
));
10827 /* Pre-allocate enough space for the CU/TU sets needed. */
10830 prealloc_cu_tu_list (unsigned int nshndx
)
10833 /* Always allocate at least one entry for the end-marker. */
10836 if (shndx_pool
== NULL
)
10838 shndx_pool_size
= nshndx
;
10839 shndx_pool_used
= 0;
10840 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10841 sizeof (unsigned int));
10845 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10846 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10847 sizeof (unsigned int));
10852 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10854 shndx_pool
[shndx_pool_used
++] = shndx
;
10858 end_cu_tu_entry (void)
10860 shndx_pool
[shndx_pool_used
++] = 0;
10863 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10865 static const char *
10866 get_DW_SECT_short_name (unsigned int dw_sect
)
10868 static char buf
[16];
10874 case DW_SECT_TYPES
:
10876 case DW_SECT_ABBREV
:
10882 case DW_SECT_STR_OFFSETS
:
10884 case DW_SECT_MACINFO
:
10886 case DW_SECT_MACRO
:
10892 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10896 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10897 These sections are extensions for Fission.
10898 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10901 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10903 unsigned char *phdr
= section
->start
;
10904 unsigned char *limit
= phdr
+ section
->size
;
10905 unsigned char *phash
;
10906 unsigned char *pindex
;
10907 unsigned char *ppool
;
10908 unsigned int version
;
10909 unsigned int ncols
= 0;
10910 unsigned int nused
;
10911 unsigned int nslots
;
10914 uint64_t signature
;
10917 /* PR 17512: file: 002-168123-0.004. */
10920 warn (_("Section %s is empty\n"), section
->name
);
10923 /* PR 17512: file: 002-376-0.004. */
10924 if (section
->size
< 24)
10926 warn (_("Section %s is too small to contain a CU/TU header\n"),
10932 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10934 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10935 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10936 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10938 pindex
= phash
+ (size_t) nslots
* 8;
10939 ppool
= pindex
+ (size_t) nslots
* 4;
10943 introduce (section
, false);
10945 printf (_(" Version: %u\n"), version
);
10947 printf (_(" Number of columns: %u\n"), ncols
);
10948 printf (_(" Number of used entries: %u\n"), nused
);
10949 printf (_(" Number of slots: %u\n\n"), nslots
);
10952 /* PR 17531: file: 45d69832. */
10953 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10954 || total
> (size_t) (limit
- phash
))
10956 warn (ngettext ("Section %s is too small for %u slot\n",
10957 "Section %s is too small for %u slots\n",
10959 section
->name
, nslots
);
10965 unsigned char *shndx_list
;
10966 unsigned int shndx
;
10970 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10971 for (shndx_list
= ppool
+ 4; shndx_list
<= limit
- 4; shndx_list
+= 4)
10973 shndx
= byte_get (shndx_list
, 4);
10974 add_shndx_to_cu_tu_entry (shndx
);
10976 end_cu_tu_entry ();
10979 for (i
= 0; i
< nslots
; i
++)
10981 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10982 if (signature
!= 0)
10984 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10985 shndx_list
= ppool
+ j
* 4;
10986 /* PR 17531: file: 705e010d. */
10987 if (shndx_list
< ppool
)
10989 warn (_("Section index pool located before start of section\n"));
10993 printf (_(" [%3d] Signature: %#" PRIx64
" Sections: "),
10997 if (shndx_list
>= limit
)
10999 warn (_("Section %s too small for shndx pool\n"),
11003 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
11006 printf (" %d", shndx
);
11015 else if (version
== 2)
11018 unsigned int dw_sect
;
11019 unsigned char *ph
= phash
;
11020 unsigned char *pi
= pindex
;
11021 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
11022 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
11024 struct cu_tu_set
*this_set
= NULL
;
11026 unsigned char *prow
;
11029 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
11031 /* PR 17531: file: 0dd159bf.
11032 Check for integer overflow (can occur when size_t is 32-bit)
11033 with overlarge ncols or nused values. */
11035 || _mul_overflow ((size_t) ncols
, 4, &temp
)
11036 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
11037 || total
> (size_t) (limit
- ppool
)
11038 /* PR 30227: ncols could be 0. */
11039 || _mul_overflow ((size_t) nused
+ 1, 4, &total
)
11040 || total
> (size_t) (limit
- ppool
))
11042 warn (_("Section %s too small for offset and size tables\n"),
11049 printf (_(" Offset table\n"));
11050 printf (" slot %-16s ",
11051 is_tu_index
? _("signature") : _("dwo_id"));
11058 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
11059 this_set
= tu_sets
;
11064 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
11065 this_set
= cu_sets
;
11071 for (j
= 0; j
< ncols
; j
++)
11073 unsigned char *p
= ppool
+ j
* 4;
11074 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
11075 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
11080 for (i
= 0; i
< nslots
; i
++)
11082 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
11084 SAFE_BYTE_GET (row
, pi
, 4, limit
);
11087 /* PR 17531: file: a05f6ab3. */
11090 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
11097 size_t num_copy
= sizeof (uint64_t);
11099 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
11102 prow
= poffsets
+ (row
- 1) * ncols
* 4;
11104 printf (" [%3d] %#" PRIx64
, i
, signature
);
11105 for (j
= 0; j
< ncols
; j
++)
11107 unsigned char *p
= prow
+ j
* 4;
11108 SAFE_BYTE_GET (val
, p
, 4, limit
);
11110 printf (" %8d", val
);
11114 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
11116 /* PR 17531: file: 10796eb3. */
11117 if (dw_sect
>= DW_SECT_MAX
)
11118 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
11120 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
11136 printf (_(" Size table\n"));
11137 printf (" slot %-16s ",
11138 is_tu_index
? _("signature") : _("dwo_id"));
11141 for (j
= 0; j
< ncols
; j
++)
11143 unsigned char *p
= ppool
+ j
* 4;
11144 SAFE_BYTE_GET (val
, p
, 4, limit
);
11146 printf (" %8s", get_DW_SECT_short_name (val
));
11152 for (i
= 0; i
< nslots
; i
++)
11154 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
11156 SAFE_BYTE_GET (row
, pi
, 4, limit
);
11159 prow
= psizes
+ (row
- 1) * ncols
* 4;
11162 printf (" [%3d] %#" PRIx64
, i
, signature
);
11164 for (j
= 0; j
< ncols
; j
++)
11166 unsigned char *p
= prow
+ j
* 4;
11168 /* PR 28645: Check for overflow. Since we do not know how
11169 many populated rows there will be, we cannot just
11170 perform a single check at the start of this function. */
11171 if (p
> (limit
- 4))
11175 warn (_("Too many rows/columns in DWARF index section %s\n"),
11180 SAFE_BYTE_GET (val
, p
, 4, limit
);
11183 printf (" %8d", val
);
11187 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
11188 if (dw_sect
>= DW_SECT_MAX
)
11189 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
11191 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
11203 else if (do_display
)
11204 printf (_(" Unsupported version (%d)\n"), version
);
11212 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
11214 /* Load the CU and TU indexes if present. This will build a list of
11215 section sets that we can use to associate a .debug_info.dwo section
11216 with its associated .debug_abbrev.dwo section in a .dwp file. */
11219 load_cu_tu_indexes (void *file
)
11221 /* If we have already loaded (or tried to load) the CU and TU indexes
11222 then do not bother to repeat the task. */
11223 if (cu_tu_indexes_read
== -1)
11225 cu_tu_indexes_read
= true;
11227 if (load_debug_section_with_follow (dwp_cu_index
, file
))
11228 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
11229 cu_tu_indexes_read
= false;
11231 if (load_debug_section_with_follow (dwp_tu_index
, file
))
11232 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
11233 cu_tu_indexes_read
= false;
11236 return (bool) cu_tu_indexes_read
;
11239 /* Find the set of sections that includes section SHNDX. */
11242 find_cu_tu_set (void *file
, unsigned int shndx
)
11246 if (! load_cu_tu_indexes (file
))
11249 /* Find SHNDX in the shndx pool. */
11250 for (i
= 0; i
< shndx_pool_used
; i
++)
11251 if (shndx_pool
[i
] == shndx
)
11254 if (i
>= shndx_pool_used
)
11257 /* Now backup to find the first entry in the set. */
11258 while (i
> 0 && shndx_pool
[i
- 1] != 0)
11261 return shndx_pool
+ i
;
11264 /* Display a .debug_cu_index or .debug_tu_index section. */
11267 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
11269 return process_cu_tu_index (section
, 1);
11273 display_debug_not_supported (struct dwarf_section
*section
,
11274 void *file ATTRIBUTE_UNUSED
)
11276 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11282 /* Like malloc, but takes two parameters like calloc.
11283 Verifies that the first parameter is not too large.
11284 Note: does *not* initialise the allocated memory to zero. */
11287 cmalloc (uint64_t nmemb
, size_t size
)
11289 /* Check for overflow. */
11290 if (nmemb
>= ~(size_t) 0 / size
)
11293 return xmalloc (nmemb
* size
);
11296 /* Like xmalloc, but takes two parameters like calloc.
11297 Verifies that the first parameter is not too large.
11298 Note: does *not* initialise the allocated memory to zero. */
11301 xcmalloc (uint64_t nmemb
, size_t size
)
11303 /* Check for overflow. */
11304 if (nmemb
>= ~(size_t) 0 / size
)
11307 _("Attempt to allocate an array with an excessive number of elements: %#" PRIx64
"\n"),
11312 return xmalloc (nmemb
* size
);
11315 /* Like xrealloc, but takes three parameters.
11316 Verifies that the second parameter is not too large.
11317 Note: does *not* initialise any new memory to zero. */
11320 xcrealloc (void *ptr
, uint64_t nmemb
, size_t size
)
11322 /* Check for overflow. */
11323 if (nmemb
>= ~(size_t) 0 / size
)
11325 error (_("Attempt to re-allocate an array with an excessive number of elements: %#" PRIx64
"\n"),
11330 return xrealloc (ptr
, nmemb
* size
);
11333 /* Like xcalloc, but verifies that the first parameter is not too large. */
11336 xcalloc2 (uint64_t nmemb
, size_t size
)
11338 /* Check for overflow. */
11339 if (nmemb
>= ~(size_t) 0 / size
)
11341 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: %#" PRIx64
"\n"),
11346 return xcalloc (nmemb
, size
);
11349 static unsigned long
11350 calc_gnu_debuglink_crc32 (unsigned long crc
,
11351 const unsigned char *buf
,
11354 static const unsigned long crc32_table
[256] =
11356 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
11357 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
11358 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
11359 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
11360 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
11361 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
11362 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
11363 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
11364 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
11365 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
11366 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
11367 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
11368 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
11369 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
11370 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
11371 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
11372 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
11373 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
11374 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
11375 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
11376 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
11377 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
11378 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
11379 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
11380 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
11381 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
11382 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
11383 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
11384 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
11385 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
11386 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
11387 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
11388 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
11389 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
11390 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
11391 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
11392 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
11393 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
11394 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
11395 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
11396 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
11397 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
11398 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
11399 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
11400 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
11401 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
11402 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
11403 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
11404 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
11405 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
11406 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
11409 const unsigned char *end
;
11411 crc
= ~crc
& 0xffffffff;
11412 for (end
= buf
+ len
; buf
< end
; ++ buf
)
11413 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
11414 return ~crc
& 0xffffffff;
11417 typedef bool (*check_func_type
) (const char *, void *);
11418 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
11421 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
11423 static unsigned char buffer
[8 * 1024];
11426 unsigned long crc
= 0;
11429 sep_data
= open_debug_file (pathname
);
11430 if (sep_data
== NULL
)
11433 /* Yes - we are opening the file twice... */
11434 f
= fopen (pathname
, "rb");
11437 /* Paranoia: This should never happen. */
11438 close_debug_file (sep_data
);
11439 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
11443 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
11444 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
11448 if (crc
!= * (unsigned long *) crc_pointer
)
11450 close_debug_file (sep_data
);
11451 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
11459 static const char *
11460 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
11463 unsigned int crc_offset
;
11464 unsigned long * crc32
= (unsigned long *) data
;
11466 /* The name is first.
11467 The CRC value is stored after the filename, aligned up to 4 bytes. */
11468 name
= (const char *) section
->start
;
11470 crc_offset
= strnlen (name
, section
->size
) + 1;
11471 if (crc_offset
== 1)
11473 crc_offset
= (crc_offset
+ 3) & ~3;
11474 if (crc_offset
+ 4 > section
->size
)
11477 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
11482 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
11484 void * sep_data
= open_debug_file (filename
);
11486 if (sep_data
== NULL
)
11489 /* FIXME: We should now extract the build-id in the separate file
11495 typedef struct build_id_data
11498 const unsigned char *data
;
11501 static const char *
11502 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
11507 Build_id_data
*build_id_data
;
11509 /* The name is first.
11510 The build-id follows immediately, with no padding, up to the section's end. */
11512 name
= (const char *) section
->start
;
11513 namelen
= strnlen (name
, section
->size
) + 1;
11516 if (namelen
>= section
->size
)
11519 id_len
= section
->size
- namelen
;
11523 build_id_data
= (Build_id_data
*) data
;
11524 build_id_data
->len
= id_len
;
11525 build_id_data
->data
= section
->start
+ namelen
;
11531 add_separate_debug_file (const char * filename
, void * handle
)
11533 separate_info
* i
= xmalloc (sizeof * i
);
11535 i
->filename
= filename
;
11536 i
->handle
= handle
;
11537 i
->next
= first_separate_info
;
11538 first_separate_info
= i
;
11541 #if HAVE_LIBDEBUGINFOD
11542 /* Query debuginfod servers for the target debuglink or debugaltlink
11543 file. If successful, store the path of the file in filename and
11544 return TRUE, otherwise return FALSE. */
11547 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
11551 size_t build_id_len
;
11552 unsigned char * build_id
;
11554 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
11556 /* Get the build-id of file. */
11557 build_id
= get_build_id (file
);
11560 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
11562 /* Get the build-id of the debugaltlink file. */
11563 unsigned int filelen
;
11565 filelen
= strnlen ((const char *)section
->start
, section
->size
);
11566 if (filelen
== section
->size
)
11567 /* Corrupt debugaltlink. */
11570 build_id
= section
->start
+ filelen
+ 1;
11571 build_id_len
= section
->size
- (filelen
+ 1);
11573 if (build_id_len
== 0)
11582 debuginfod_client
* client
;
11584 client
= debuginfod_begin ();
11585 if (client
== NULL
)
11588 /* Query debuginfod servers for the target file. If found its path
11589 will be stored in filename. */
11590 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
11591 debuginfod_end (client
);
11593 /* Only free build_id if we allocated space for a hex string
11594 in get_build_id (). */
11595 if (build_id_len
== 0)
11600 /* File successfully retrieved. Close fd since we want to
11601 use open_debug_file () on filename instead. */
11609 #endif /* HAVE_LIBDEBUGINFOD */
11612 load_separate_debug_info (const char * main_filename
,
11613 struct dwarf_section
* xlink
,
11614 parse_func_type parse_func
,
11615 check_func_type check_func
,
11617 void * file ATTRIBUTE_UNUSED
)
11619 const char * separate_filename
;
11620 char * debug_filename
;
11622 size_t canon_dirlen
;
11624 char * canon_filename
;
11625 char * canon_debug_filename
;
11628 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11630 warn (_("Corrupt debuglink section: %s\n"),
11631 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11635 /* Attempt to locate the separate file.
11636 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11638 canon_filename
= lrealpath (main_filename
);
11639 canon_dir
= xstrdup (canon_filename
);
11641 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11642 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11644 canon_dir
[canon_dirlen
] = '\0';
11647 #define DEBUGDIR "/lib/debug"
11649 #ifndef EXTRA_DEBUG_ROOT1
11650 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11652 #ifndef EXTRA_DEBUG_ROOT2
11653 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11656 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11658 + strlen (".debug/")
11659 #ifdef EXTRA_DEBUG_ROOT1
11660 + strlen (EXTRA_DEBUG_ROOT1
)
11662 #ifdef EXTRA_DEBUG_ROOT2
11663 + strlen (EXTRA_DEBUG_ROOT2
)
11665 + strlen (separate_filename
)
11667 if (debug_filename
== NULL
)
11669 warn (_("Out of memory"));
11671 free (canon_filename
);
11675 /* First try in the current directory. */
11676 sprintf (debug_filename
, "%s", separate_filename
);
11677 if (check_func (debug_filename
, func_data
))
11680 /* Then try in a subdirectory called .debug. */
11681 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11682 if (check_func (debug_filename
, func_data
))
11685 /* Then try in the same directory as the original file. */
11686 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11687 if (check_func (debug_filename
, func_data
))
11690 /* And the .debug subdirectory of that directory. */
11691 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11692 if (check_func (debug_filename
, func_data
))
11695 #ifdef EXTRA_DEBUG_ROOT1
11696 /* Try the first extra debug file root. */
11697 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11698 if (check_func (debug_filename
, func_data
))
11701 /* Try the first extra debug file root. */
11702 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11703 if (check_func (debug_filename
, func_data
))
11707 #ifdef EXTRA_DEBUG_ROOT2
11708 /* Try the second extra debug file root. */
11709 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11710 if (check_func (debug_filename
, func_data
))
11714 /* Then try in the global debug_filename directory. */
11715 strcpy (debug_filename
, DEBUGDIR
);
11716 dirlen
= strlen (DEBUGDIR
) - 1;
11717 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11718 strcat (debug_filename
, "/");
11719 strcat (debug_filename
, (const char *) separate_filename
);
11721 if (check_func (debug_filename
, func_data
))
11724 #if HAVE_LIBDEBUGINFOD
11726 char * tmp_filename
;
11729 && debuginfod_fetch_separate_debug_info (xlink
,
11733 /* File successfully downloaded from server, replace
11734 debug_filename with the file's path. */
11735 free (debug_filename
);
11736 debug_filename
= tmp_filename
;
11742 if (do_debug_links
)
11744 /* Failed to find the file. */
11745 warn (_("could not find separate debug file '%s'\n"),
11746 separate_filename
);
11747 warn (_("tried: %s\n"), debug_filename
);
11749 #ifdef EXTRA_DEBUG_ROOT2
11750 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11751 separate_filename
);
11752 warn (_("tried: %s\n"), debug_filename
);
11755 #ifdef EXTRA_DEBUG_ROOT1
11756 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11757 canon_dir
, separate_filename
);
11758 warn (_("tried: %s\n"), debug_filename
);
11760 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11761 separate_filename
);
11762 warn (_("tried: %s\n"), debug_filename
);
11765 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11766 separate_filename
);
11767 warn (_("tried: %s\n"), debug_filename
);
11769 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11770 warn (_("tried: %s\n"), debug_filename
);
11772 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11773 warn (_("tried: %s\n"), debug_filename
);
11775 sprintf (debug_filename
, "%s", separate_filename
);
11776 warn (_("tried: %s\n"), debug_filename
);
11778 #if HAVE_LIBDEBUGINFOD
11779 if (use_debuginfod
)
11781 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11786 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11792 free (debug_filename
);
11793 free (canon_filename
);
11799 canon_debug_filename
= lrealpath (debug_filename
);
11800 self
= strcmp (canon_debug_filename
, canon_filename
) == 0;
11801 free (canon_filename
);
11802 free (canon_debug_filename
);
11805 free (debug_filename
);
11809 void * debug_handle
;
11811 /* Now open the file.... */
11812 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11814 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11815 free (debug_filename
);
11819 /* FIXME: We do not check to see if there are any other separate debug info
11820 files that would also match. */
11822 if (do_debug_links
)
11823 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11824 add_separate_debug_file (debug_filename
, debug_handle
);
11826 /* Do not free debug_filename - it might be referenced inside
11827 the structure returned by open_debug_file(). */
11828 return debug_handle
;
11831 /* Attempt to load a separate dwarf object file. */
11834 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11836 char * separate_filename
;
11837 void * separate_handle
;
11839 if (IS_ABSOLUTE_PATH (name
))
11840 separate_filename
= strdup (name
);
11842 /* FIXME: Skip adding / if dwo_dir ends in /. */
11843 separate_filename
= concat (dir
, "/", name
, NULL
);
11844 if (separate_filename
== NULL
)
11846 warn (_("Out of memory allocating dwo filename\n"));
11850 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11852 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11853 free (separate_filename
);
11857 /* FIXME: We should check the dwo_id. */
11859 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11861 add_separate_debug_file (separate_filename
, separate_handle
);
11862 /* Note - separate_filename will be freed in free_debug_memory(). */
11863 return separate_handle
;
11867 try_build_id_prefix (const char * prefix
, char * filename
, const unsigned char * data
, unsigned long id_len
)
11869 char * f
= filename
;
11871 f
+= sprintf (f
, "%s.build-id/%02x/", prefix
, (unsigned) *data
++);
11874 f
+= sprintf (f
, "%02x", (unsigned) *data
++);
11875 strcpy (f
, ".debug");
11877 return open_debug_file (filename
);
11880 /* Try to load a debug file based upon the build-id held in the .note.gnu.build-id section. */
11883 load_build_id_debug_file (const char * main_filename ATTRIBUTE_UNUSED
, void * main_file
)
11885 if (! load_debug_section (note_gnu_build_id
, main_file
))
11886 return; /* No .note.gnu.build-id section. */
11888 struct dwarf_section
* section
= & debug_displays
[note_gnu_build_id
].section
;
11889 if (section
== NULL
)
11891 warn (_("Unable to load the .note.gnu.build-id section\n"));
11895 if (section
->start
== NULL
|| section
->size
< 0x18)
11897 warn (_(".note.gnu.build-id section is corrupt/empty\n"));
11901 /* In theory we should extract the contents of the section into
11902 a note structure and then check the fields. For now though
11903 just use hard coded offsets instead:
11905 Field Bytes Contents
11908 Type 8..11 3 (NT_GNU_BUILD_ID)
11912 /* FIXME: Check the name size, name and type fields. */
11914 unsigned long build_id_size
;
11915 build_id_size
= byte_get (section
->start
+ 4, 4);
11916 if (build_id_size
< 8)
11918 warn (_(".note.gnu.build-id data size is too small\n"));
11922 if (build_id_size
> (section
->size
- 16))
11924 warn (_(".note.gnu.build-id data size is too big\n"));
11929 filename
= xmalloc (strlen (".build-id/")
11930 + build_id_size
* 2 + 2
11931 + strlen (".debug")
11932 /* The next string should be the same as the longest
11933 name found in the prefixes[] array below. */
11934 + strlen ("/usrlib64/debug/usr")
11938 static const char * prefixes
[] =
11943 "/usr/lib/debug/usr/",
11944 "/usr/lib64/debug/",
11945 "/usr/lib64/debug/usr"
11947 long unsigned int i
;
11949 for (i
= 0; i
< ARRAY_SIZE (prefixes
); i
++)
11951 handle
= try_build_id_prefix (prefixes
[i
], filename
,
11952 section
->start
+ 16, build_id_size
);
11953 if (handle
!= NULL
)
11956 /* FIXME: TYhe BFD library also tries a global debugfile directory prefix. */
11957 if (handle
== NULL
)
11959 /* Failed to find a debug file associated with the build-id.
11960 This is not an error however, rather it just means that
11961 the debug info has probably not been loaded on the system,
11962 or that another method is being used to link to the debug
11968 add_separate_debug_file (filename
, handle
);
11971 /* Try to load a debug file pointed to by the .debug_sup section. */
11974 load_debug_sup_file (const char * main_filename
, void * file
)
11976 if (! load_debug_section (debug_sup
, file
))
11977 return; /* No .debug_sup section. */
11979 struct dwarf_section
* section
;
11980 section
= & debug_displays
[debug_sup
].section
;
11981 assert (section
!= NULL
);
11983 if (section
->start
== NULL
|| section
->size
< 5)
11985 warn (_(".debug_sup section is corrupt/empty\n"));
11989 if (section
->start
[2] != 0)
11990 return; /* This is a supplementary file. */
11992 const char * filename
= (const char *) section
->start
+ 3;
11993 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11995 warn (_("filename in .debug_sup section is corrupt\n"));
11999 if (filename
[0] != '/' && strchr (main_filename
, '/'))
12004 new_len
= asprintf (& new_name
, "%.*s/%s",
12005 (int) (strrchr (main_filename
, '/') - main_filename
),
12010 warn (_("unable to construct path for supplementary debug file"));
12015 filename
= new_name
;
12019 /* PR 27796: Make sure that we pass a filename that can be free'd to
12020 add_separate_debug_file(). */
12021 filename
= strdup (filename
);
12022 if (filename
== NULL
)
12024 warn (_("out of memory constructing filename for .debug_sup link\n"));
12029 void * handle
= open_debug_file (filename
);
12030 if (handle
== NULL
)
12032 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
12033 free ((void *) filename
);
12037 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
12039 /* FIXME: Compare the checksums, if present. */
12040 add_separate_debug_file (filename
, handle
);
12043 /* Load a debuglink section and/or a debugaltlink section, if either are present.
12044 Recursively check the loaded files for more of these sections.
12045 Also follow any links in .debug_sup sections.
12046 FIXME: Should also check for DWO_* entries in the newly loaded files. */
12049 check_for_and_load_links (void * file
, const char * filename
)
12051 void * handle
= NULL
;
12053 if (load_debug_section (gnu_debugaltlink
, file
))
12055 Build_id_data build_id_data
;
12057 handle
= load_separate_debug_info (filename
,
12058 & debug_displays
[gnu_debugaltlink
].section
,
12059 parse_gnu_debugaltlink
,
12060 check_gnu_debugaltlink
,
12065 assert (handle
== first_separate_info
->handle
);
12066 check_for_and_load_links (first_separate_info
->handle
,
12067 first_separate_info
->filename
);
12071 if (load_debug_section (gnu_debuglink
, file
))
12073 unsigned long crc32
;
12075 handle
= load_separate_debug_info (filename
,
12076 & debug_displays
[gnu_debuglink
].section
,
12077 parse_gnu_debuglink
,
12078 check_gnu_debuglink
,
12083 assert (handle
== first_separate_info
->handle
);
12084 check_for_and_load_links (first_separate_info
->handle
,
12085 first_separate_info
->filename
);
12089 load_debug_sup_file (filename
, file
);
12091 load_build_id_debug_file (filename
, file
);
12094 /* Load the separate debug info file(s) attached to FILE, if any exist.
12095 Returns TRUE if any were found, FALSE otherwise.
12096 If TRUE is returned then the linked list starting at first_separate_info
12097 will be populated with open file handles. */
12100 load_separate_debug_files (void * file
, const char * filename
)
12102 /* Skip this operation if we are not interested in debug links. */
12103 if (! do_follow_links
&& ! do_debug_links
)
12106 /* See if there are any dwo links. */
12107 if (load_debug_section (str
, file
)
12108 && load_debug_section (abbrev
, file
)
12109 && load_debug_section (info
, file
))
12111 /* Load the .debug_addr section, if it exists. */
12112 load_debug_section (debug_addr
, file
);
12113 /* Load the .debug_str_offsets section, if it exists. */
12114 load_debug_section (str_index
, file
);
12115 /* Load the .debug_loclists section, if it exists. */
12116 load_debug_section (loclists
, file
);
12117 /* Load the .debug_rnglists section, if it exists. */
12118 load_debug_section (rnglists
, file
);
12122 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
12125 bool introduced
= false;
12127 const char *dir
= NULL
;
12128 const char *id
= NULL
;
12129 const char *name
= NULL
;
12131 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
12133 /* Accumulate NAME, DIR and ID fields. */
12134 switch (dwinfo
->type
)
12138 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
12139 name
= dwinfo
->value
;
12143 /* There can be multiple DW_AT_comp_dir entries in a CU,
12144 so do not complain. */
12145 dir
= dwinfo
->value
;
12150 warn (_("multiple DWO_IDs encountered for the same CU\n"));
12151 id
= dwinfo
->value
;
12155 error (_("Unexpected DWO INFO type"));
12159 /* If we have reached the end of our list, or we are changing
12160 CUs, then display the information that we have accumulated
12163 && (dwinfo
->next
== NULL
12164 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
12166 if (do_debug_links
)
12170 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
12171 debug_displays
[info
].section
.uncompressed_name
);
12175 printf (_(" Name: %s\n"), name
);
12176 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
12178 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
12179 else if (debug_information
[0].dwarf_version
!= 5)
12180 printf (_(" ID: <not specified>\n"));
12184 if (do_follow_links
)
12185 load_dwo_file (filename
, name
, dir
, id
);
12187 name
= dir
= id
= NULL
;
12193 if (! do_follow_links
)
12194 /* The other debug links will be displayed by display_debug_links()
12195 so we do not need to do any further processing here. */
12198 /* FIXME: We do not check for the presence of both link sections in the same file. */
12199 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
12200 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
12202 check_for_and_load_links (file
, filename
);
12203 if (first_separate_info
!= NULL
)
12206 do_follow_links
= 0;
12211 free_debug_memory (void)
12215 free_all_abbrevs ();
12219 shndx_pool_size
= 0;
12220 shndx_pool_used
= 0;
12228 memset (level_type_signed
, 0, sizeof level_type_signed
);
12229 cu_tu_indexes_read
= -1;
12231 for (i
= 0; i
< max
; i
++)
12232 free_debug_section ((enum dwarf_section_display_enum
) i
);
12234 if (debug_information
!= NULL
)
12236 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
12237 free_debug_information (&debug_information
[i
]);
12238 free (debug_information
);
12239 debug_information
= NULL
;
12240 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
12244 separate_info
* next
;
12246 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
12248 close_debug_file (d
->handle
);
12249 free ((void *) d
->filename
);
12253 first_separate_info
= NULL
;
12261 const char *option
;
12264 } debug_dump_long_opts
;
12266 static const debug_dump_long_opts debug_option_table
[] =
12268 { 'A', "addr", &do_debug_addr
, 1 },
12269 { 'a', "abbrev", &do_debug_abbrevs
, 1 },
12270 { 'c', "cu_index", &do_debug_cu_index
, 1 },
12271 #ifdef HAVE_LIBDEBUGINFOD
12272 { 'D', "use-debuginfod", &use_debuginfod
, 1 },
12273 { 'E', "do-not-use-debuginfod", &use_debuginfod
, 0 },
12275 { 'F', "frames-interp", &do_debug_frames_interp
, 1 },
12276 { 'f', "frames", &do_debug_frames
, 1 },
12277 { 'g', "gdb_index", &do_gdb_index
, 1 },
12278 { 'i', "info", &do_debug_info
, 1 },
12279 { 'K', "follow-links", &do_follow_links
, 1 },
12280 { 'k', "links", &do_debug_links
, 1 },
12281 { 'L', "decodedline", &do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
12282 { 'l', "rawline", &do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
12283 /* For compatibility with earlier versions of readelf. */
12284 { 'l', "line", &do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
12285 { 'm', "macro", &do_debug_macinfo
, 1 },
12286 { 'N', "no-follow-links", &do_follow_links
, 0 },
12287 { 'O', "str-offsets", &do_debug_str_offsets
, 1 },
12288 { 'o', "loc", &do_debug_loc
, 1 },
12289 { 'p', "pubnames", &do_debug_pubnames
, 1 },
12290 { 'R', "Ranges", &do_debug_ranges
, 1 },
12291 { 'r', "aranges", &do_debug_aranges
, 1 },
12292 /* For compatibility with earlier versions of readelf. */
12293 { 'r', "ranges", &do_debug_aranges
, 1 },
12294 { 's', "str", &do_debug_str
, 1 },
12295 { 'T', "trace_aranges", &do_trace_aranges
, 1 },
12296 { 't', "pubtypes", &do_debug_pubtypes
, 1 },
12297 { 'U', "trace_info", &do_trace_info
, 1 },
12298 { 'u', "trace_abbrev", &do_trace_abbrevs
, 1 },
12299 { 0, NULL
, NULL
, 0 }
12302 /* Enable display of specific DWARF sections as determined by the comma
12303 separated strings in NAMES. Returns non-zero if any displaying was
12307 dwarf_select_sections_by_names (const char *names
)
12315 const debug_dump_long_opts
*entry
;
12317 for (entry
= debug_option_table
; entry
->option
; entry
++)
12319 size_t len
= strlen (entry
->option
);
12321 if (strncmp (p
, entry
->option
, len
) == 0
12322 && (p
[len
] == ',' || p
[len
] == '\0'))
12324 if (entry
->val
== 0)
12325 * entry
->variable
= 0;
12327 * entry
->variable
= entry
->val
;
12328 result
|= entry
->val
;
12335 if (entry
->option
== NULL
)
12337 warn (_("Unrecognized debug option '%s'\n"), p
);
12338 p
= strchr (p
, ',');
12347 /* The --debug-dump=frames-interp option also enables the
12348 --debug-dump=frames option. */
12349 if (do_debug_frames_interp
)
12350 do_debug_frames
= 1;
12355 /* Enable display of specific DWARF sections as determined by the characters
12356 in LETTERS. Returns non-zero if any displaying was enabled. */
12359 dwarf_select_sections_by_letters (const char *letters
)
12365 const debug_dump_long_opts
*entry
;
12367 for (entry
= debug_option_table
; entry
->letter
; entry
++)
12369 if (entry
->letter
== * letters
)
12371 if (entry
->val
== 0)
12372 * entry
->variable
= 0;
12374 * entry
->variable
|= entry
->val
;
12375 result
|= entry
->val
;
12380 if (entry
->letter
== 0)
12381 warn (_("Unrecognized debug letter option '%c'\n"), * letters
);
12386 /* The --debug-dump=frames-interp option also enables the
12387 --debug-dump=frames option. */
12388 if (do_debug_frames_interp
)
12389 do_debug_frames
= 1;
12395 dwarf_select_sections_all (void)
12398 do_debug_abbrevs
= 1;
12399 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
12400 do_debug_pubnames
= 1;
12401 do_debug_pubtypes
= 1;
12402 do_debug_aranges
= 1;
12403 do_debug_ranges
= 1;
12404 do_debug_frames
= 1;
12405 do_debug_macinfo
= 1;
12410 do_trace_abbrevs
= 1;
12411 do_trace_aranges
= 1;
12413 do_debug_cu_index
= 1;
12414 do_follow_links
= 1;
12415 do_debug_links
= 1;
12416 do_debug_str_offsets
= 1;
12419 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
12420 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
12422 /* N.B. The order here must match the order in section_display_enum. */
12424 struct dwarf_section_display debug_displays
[] =
12426 { { ".debug_abbrev", ".zdebug_abbrev", ".dwabrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
12427 { { ".debug_aranges", ".zdebug_aranges", ".dwarnge", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
12428 { { ".debug_frame", ".zdebug_frame", ".dwframe", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
12429 { { ".debug_info", ".zdebug_info", ".dwinfo", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
12430 { { ".debug_line", ".zdebug_line", ".dwline", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
12431 { { ".debug_pubnames", ".zdebug_pubnames", ".dwpbnms", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
12432 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
12433 { { ".eh_frame", "", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
12434 { { ".debug_macinfo", ".zdebug_macinfo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
12435 { { ".debug_macro", ".zdebug_macro", ".dwmac", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
12436 { { ".debug_str", ".zdebug_str", ".dwstr", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12437 { { ".debug_line_str", ".zdebug_line_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12438 { { ".debug_loc", ".zdebug_loc", ".dwloc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12439 { { ".debug_loclists", ".zdebug_loclists", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12440 { { ".debug_loclists.dwo", ".zdebug_loclists.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12441 { { ".debug_pubtypes", ".zdebug_pubtypes", ".dwpbtyp", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
12442 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
12443 { { ".debug_ranges", ".zdebug_ranges", ".dwrnges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12444 { { ".debug_rnglists", ".zdebug_rnglists", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12445 { { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
12446 { { ".debug_static_func", ".zdebug_static_func", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12447 { { ".debug_static_vars", ".zdebug_static_vars", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12448 { { ".debug_types", ".zdebug_types", "", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
12449 { { ".debug_weaknames", ".zdebug_weaknames", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12450 { { ".gdb_index", "", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
12451 { { ".debug_names", "", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
12452 { { ".trace_info", "", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
12453 { { ".trace_abbrev", "", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
12454 { { ".trace_aranges", "", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
12455 { { ".debug_info.dwo", ".zdebug_info.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
12456 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", "", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
12457 { { ".debug_types.dwo", ".zdebug_types.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
12458 { { ".debug_line.dwo", ".zdebug_line.dwo", "", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
12459 { { ".debug_loc.dwo", ".zdebug_loc.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
12460 { { ".debug_macro.dwo", ".zdebug_macro.dwo", "", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
12461 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
12462 { { ".debug_str.dwo", ".zdebug_str.dwo", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
12463 { { ".debug_str_offsets", ".zdebug_str_offsets", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
12464 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
12465 { { ".debug_addr", ".zdebug_addr", "", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
12466 { { ".debug_cu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
12467 { { ".debug_tu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
12468 { { ".gnu_debuglink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
12469 { { ".gnu_debugaltlink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
12470 { { ".debug_sup", "", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
12471 /* Separate debug info files can containt their own .debug_str section,
12472 and this might be in *addition* to a .debug_str section already present
12473 in the main file. Hence we need to have two entries for .debug_str. */
12474 { { ".debug_str", ".zdebug_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
12475 { { ".note.gnu.build-id", "", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
12478 /* A static assertion. */
12479 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];