1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2021 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>
46 #define MAX(a, b) ((a) > (b) ? (a) : (b))
47 #define MIN(a, b) ((a) < (b) ? (a) : (b))
49 static const char *regname (unsigned int regno
, int row
);
50 static const char *regname_internal_by_table_only (unsigned int regno
);
52 static int have_frame_base
;
53 static int need_base_address
;
55 static unsigned int num_debug_info_entries
= 0;
56 static unsigned int alloc_num_debug_info_entries
= 0;
57 static debug_info
*debug_information
= NULL
;
58 /* Special value for num_debug_info_entries to indicate
59 that the .debug_info section could not be loaded/parsed. */
60 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
62 /* A .debug_info section can contain multiple links to separate
63 DWO object files. We use these structures to record these links. */
71 typedef struct dwo_info
76 struct dwo_info
* next
;
79 static dwo_info
*first_dwo_info
= NULL
;
80 static bool need_dwo_info
;
82 separate_info
* first_separate_info
= NULL
;
84 unsigned int eh_addr_size
;
89 int do_debug_pubnames
;
90 int do_debug_pubtypes
;
94 int do_debug_frames_interp
;
97 int do_debug_str_offsets
;
101 int do_trace_abbrevs
;
102 int do_trace_aranges
;
104 int do_debug_cu_index
;
107 int do_follow_links
= DEFAULT_FOR_FOLLOW_LINKS
;
110 int dwarf_cutoff_level
= -1;
111 unsigned long dwarf_start_die
;
115 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
116 testing whether e.g. a locview list is present. */
117 static const dwarf_vma vm1
= -1;
119 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
120 sections. For version 1 package files, each set is stored in SHNDX_POOL
121 as a zero-terminated list of section indexes comprising one set of debug
122 sections from a .dwo file. */
124 static unsigned int *shndx_pool
= NULL
;
125 static unsigned int shndx_pool_size
= 0;
126 static unsigned int shndx_pool_used
= 0;
128 /* For version 2 package files, each set contains an array of section offsets
129 and an array of section sizes, giving the offset and size of the
130 contribution from a CU or TU within one of the debug sections.
131 When displaying debug info from a package file, we need to use these
132 tables to locate the corresponding contributions to each section. */
137 dwarf_vma section_offsets
[DW_SECT_MAX
];
138 size_t section_sizes
[DW_SECT_MAX
];
141 static int cu_count
= 0;
142 static int tu_count
= 0;
143 static struct cu_tu_set
*cu_sets
= NULL
;
144 static struct cu_tu_set
*tu_sets
= NULL
;
146 static bool load_cu_tu_indexes (void *);
148 /* An array that indicates for a given level of CU nesting whether
149 the latest DW_AT_type seen for that level was a signed type or
151 #define MAX_CU_NESTING (1 << 8)
152 static bool level_type_signed
[MAX_CU_NESTING
];
154 /* Values for do_debug_lines. */
155 #define FLAG_DEBUG_LINES_RAW 1
156 #define FLAG_DEBUG_LINES_DECODED 2
159 size_of_encoded_value (int encoding
)
161 switch (encoding
& 0x7)
164 case 0: return eh_addr_size
;
172 get_encoded_value (unsigned char **pdata
,
174 struct dwarf_section
*section
,
177 unsigned char * data
= * pdata
;
178 unsigned int size
= size_of_encoded_value (encoding
);
181 if (data
>= end
|| size
> (size_t) (end
- data
))
183 warn (_("Encoded value extends past end of section\n"));
188 /* PR 17512: file: 002-829853-0.004. */
191 warn (_("Encoded size of %d is too large to read\n"), size
);
196 /* PR 17512: file: 1085-5603-0.004. */
199 warn (_("Encoded size of 0 is too small to read\n"));
204 if (encoding
& DW_EH_PE_signed
)
205 val
= byte_get_signed (data
, size
);
207 val
= byte_get (data
, size
);
209 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
210 val
+= section
->address
+ (data
- section
->start
);
212 * pdata
= data
+ size
;
216 #if SIZEOF_LONG_LONG > SIZEOF_LONG
218 # define DWARF_VMA_FMT "ll"
219 # define DWARF_VMA_FMT_LONG "%16.16llx"
221 # define DWARF_VMA_FMT "I64"
222 # define DWARF_VMA_FMT_LONG "%016I64x"
225 # define DWARF_VMA_FMT "l"
226 # define DWARF_VMA_FMT_LONG "%16.16lx"
229 /* Convert a dwarf vma value into a string. Returns a pointer to a static
230 buffer containing the converted VALUE. The value is converted according
231 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
232 it specifies the maximum number of bytes to be displayed in the converted
233 value and FMTCH is ignored - hex is always used. */
236 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
238 /* As dwarf_vmatoa is used more then once in a printf call
239 for output, we are cycling through an fixed array of pointers
240 for return address. */
241 static int buf_pos
= 0;
242 static struct dwarf_vmatoa_buf
248 ret
= buf
[buf_pos
++].place
;
249 buf_pos
%= ARRAY_SIZE (buf
);
253 /* Printf does not have a way of specifying a maximum field width for an
254 integer value, so we print the full value into a buffer and then select
255 the precision we need. */
256 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
259 return ret
+ (16 - 2 * num_bytes
);
266 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
268 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
269 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
274 static inline const char *
275 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
277 return dwarf_vmatoa_1 (fmtch
, value
, 0);
280 /* Print a dwarf_vma value (typically an address, offset or length) in
281 hexadecimal format, followed by a space. The length of the VALUE (and
282 hence the precision displayed) is determined by the NUM_BYTES parameter. */
285 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
287 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
290 /* Print a view number in hexadecimal value, with the same width
291 print_dwarf_vma would have printed it with the same num_bytes.
292 Print blanks for zero view, unless force is nonzero. */
295 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
303 assert (value
== (unsigned long) value
);
305 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
307 printf ("%*s", len
+ 1, "");
310 /* Read in a LEB128 encoded value starting at address DATA.
311 If SIGN is true, return a signed LEB128 value.
312 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
313 If STATUS_RETURN is not NULL, return with bit 0 (LSB) set if the
314 terminating byte was not found and with bit 1 set if the value
315 overflows a dwarf_vma.
316 No bytes will be read at address END or beyond. */
319 read_leb128 (unsigned char *data
,
320 const unsigned char *const end
,
322 unsigned int *length_return
,
325 dwarf_vma result
= 0;
326 unsigned int num_read
= 0;
327 unsigned int shift
= 0;
332 unsigned char byte
= *data
++;
333 unsigned char lost
, mask
;
337 if (shift
< CHAR_BIT
* sizeof (result
))
339 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
340 /* These bits overflowed. */
341 lost
= byte
^ (result
>> shift
);
342 /* And this is the mask of possible overflow bits. */
343 mask
= 0x7f ^ ((dwarf_vma
) 0x7f << shift
>> shift
);
351 if ((lost
& mask
) != (sign
&& (dwarf_signed_vma
) result
< 0 ? mask
: 0))
354 if ((byte
& 0x80) == 0)
357 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
358 result
|= -((dwarf_vma
) 1 << shift
);
363 if (length_return
!= NULL
)
364 *length_return
= num_read
;
365 if (status_return
!= NULL
)
366 *status_return
= status
;
371 /* Read AMOUNT bytes from PTR and store them in VAL.
372 Checks to make sure that the read will not reach or pass END.
373 FUNC chooses whether the value read is unsigned or signed, and may
374 be either byte_get or byte_get_signed. If INC is true, PTR is
375 incremented after reading the value.
376 This macro cannot protect against PTR values derived from user input.
377 The C standard sections 6.5.6 and 6.5.8 say attempts to do so using
378 pointers is undefined behaviour. */
379 #define SAFE_BYTE_GET_INTERNAL(VAL, PTR, AMOUNT, END, FUNC, INC) \
382 size_t amount = (AMOUNT); \
383 if (sizeof (VAL) < amount) \
385 error (ngettext ("internal error: attempt to read %d byte " \
386 "of data in to %d sized variable", \
387 "internal error: attempt to read %d bytes " \
388 "of data in to %d sized variable", \
390 (int) amount, (int) sizeof (VAL)); \
391 amount = sizeof (VAL); \
393 if (ENABLE_CHECKING) \
394 assert ((PTR) <= (END)); \
395 size_t avail = (END) - (PTR); \
398 if (amount > avail) \
403 (VAL) = (FUNC) ((PTR), amount); \
409 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
410 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, false)
412 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
413 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, true)
415 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
416 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, false)
418 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
419 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, true)
421 typedef struct State_Machine_Registers
430 unsigned char op_index
;
431 unsigned char end_sequence
;
432 /* This variable hold the number of the last entry seen
433 in the File Table. */
434 unsigned int last_file_entry
;
437 static SMR state_machine_regs
;
440 reset_state_machine (int is_stmt
)
442 state_machine_regs
.address
= 0;
443 state_machine_regs
.view
= 0;
444 state_machine_regs
.op_index
= 0;
445 state_machine_regs
.file
= 1;
446 state_machine_regs
.line
= 1;
447 state_machine_regs
.column
= 0;
448 state_machine_regs
.is_stmt
= is_stmt
;
449 state_machine_regs
.basic_block
= 0;
450 state_machine_regs
.end_sequence
= 0;
451 state_machine_regs
.last_file_entry
= 0;
454 /* Handled an extend line op.
455 Returns the number of bytes read. */
458 process_extended_line_op (unsigned char * data
,
462 unsigned char op_code
;
463 size_t len
, header_len
;
465 unsigned char *orig_data
= data
;
468 READ_ULEB (len
, data
, end
);
469 header_len
= data
- orig_data
;
471 if (len
== 0 || data
>= end
|| len
> (size_t) (end
- data
))
473 warn (_("Badly formed extended line op encountered!\n"));
479 printf (_(" Extended opcode %d: "), op_code
);
483 case DW_LNE_end_sequence
:
484 printf (_("End of Sequence\n\n"));
485 reset_state_machine (is_stmt
);
488 case DW_LNE_set_address
:
489 /* PR 17512: file: 002-100480-0.004. */
492 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
493 (unsigned long) len
- 1);
497 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
498 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
499 state_machine_regs
.address
= adr
;
500 state_machine_regs
.view
= 0;
501 state_machine_regs
.op_index
= 0;
504 case DW_LNE_define_file
:
505 printf (_("define new File Table entry\n"));
506 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
507 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
513 l
= strnlen ((char *) data
, end
- data
);
517 READ_ULEB (val
, data
, end
);
518 printf ("%s\t", dwarf_vmatoa ("u", val
));
519 READ_ULEB (val
, data
, end
);
520 printf ("%s\t", dwarf_vmatoa ("u", val
));
521 READ_ULEB (val
, data
, end
);
522 printf ("%s\t", dwarf_vmatoa ("u", val
));
523 printf ("%.*s\n\n", (int) l
, name
);
526 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
>= end
)
527 warn (_("DW_LNE_define_file: Bad opcode length\n"));
530 case DW_LNE_set_discriminator
:
531 READ_ULEB (val
, data
, end
);
532 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
536 case DW_LNE_HP_negate_is_UV_update
:
537 printf ("DW_LNE_HP_negate_is_UV_update\n");
539 case DW_LNE_HP_push_context
:
540 printf ("DW_LNE_HP_push_context\n");
542 case DW_LNE_HP_pop_context
:
543 printf ("DW_LNE_HP_pop_context\n");
545 case DW_LNE_HP_set_file_line_column
:
546 printf ("DW_LNE_HP_set_file_line_column\n");
548 case DW_LNE_HP_set_routine_name
:
549 printf ("DW_LNE_HP_set_routine_name\n");
551 case DW_LNE_HP_set_sequence
:
552 printf ("DW_LNE_HP_set_sequence\n");
554 case DW_LNE_HP_negate_post_semantics
:
555 printf ("DW_LNE_HP_negate_post_semantics\n");
557 case DW_LNE_HP_negate_function_exit
:
558 printf ("DW_LNE_HP_negate_function_exit\n");
560 case DW_LNE_HP_negate_front_end_logical
:
561 printf ("DW_LNE_HP_negate_front_end_logical\n");
563 case DW_LNE_HP_define_proc
:
564 printf ("DW_LNE_HP_define_proc\n");
566 case DW_LNE_HP_source_file_correlation
:
568 unsigned char *edata
= data
+ len
- 1;
570 printf ("DW_LNE_HP_source_file_correlation\n");
576 READ_ULEB (opc
, data
, edata
);
580 case DW_LNE_HP_SFC_formfeed
:
581 printf (" DW_LNE_HP_SFC_formfeed\n");
583 case DW_LNE_HP_SFC_set_listing_line
:
584 READ_ULEB (val
, data
, edata
);
585 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
586 dwarf_vmatoa ("u", val
));
588 case DW_LNE_HP_SFC_associate
:
589 printf (" DW_LNE_HP_SFC_associate ");
590 READ_ULEB (val
, data
, edata
);
591 printf ("(%s", dwarf_vmatoa ("u", val
));
592 READ_ULEB (val
, data
, edata
);
593 printf (",%s", dwarf_vmatoa ("u", val
));
594 READ_ULEB (val
, data
, edata
);
595 printf (",%s)\n", dwarf_vmatoa ("u", val
));
598 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
608 unsigned int rlen
= len
- 1;
610 if (op_code
>= DW_LNE_lo_user
611 /* The test against DW_LNW_hi_user is redundant due to
612 the limited range of the unsigned char data type used
614 /*&& op_code <= DW_LNE_hi_user*/)
615 printf (_("user defined: "));
617 printf (_("UNKNOWN: "));
618 printf (_("length %d ["), rlen
);
620 printf (" %02x", *data
++);
626 return len
+ header_len
;
629 static const unsigned char *
630 fetch_indirect_string (dwarf_vma offset
)
632 struct dwarf_section
*section
= &debug_displays
[str
].section
;
633 const unsigned char * ret
;
635 if (section
->start
== NULL
)
636 return (const unsigned char *) _("<no .debug_str section>");
638 if (offset
>= section
->size
)
640 warn (_("DW_FORM_strp offset too big: 0x%s\n"),
641 dwarf_vmatoa ("x", offset
));
642 return (const unsigned char *) _("<offset is too big>");
645 ret
= section
->start
+ offset
;
646 /* Unfortunately we cannot rely upon the .debug_str section ending with a
647 NUL byte. Since our caller is expecting to receive a well formed C
648 string we test for the lack of a terminating byte here. */
649 if (strnlen ((const char *) ret
, section
->size
- offset
)
650 == section
->size
- offset
)
651 ret
= (const unsigned char *)
652 _("<no NUL byte at end of .debug_str section>");
657 static const unsigned char *
658 fetch_indirect_line_string (dwarf_vma offset
)
660 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
661 const unsigned char * ret
;
663 if (section
->start
== NULL
)
664 return (const unsigned char *) _("<no .debug_line_str section>");
666 if (offset
>= section
->size
)
668 warn (_("DW_FORM_line_strp offset too big: 0x%s\n"),
669 dwarf_vmatoa ("x", offset
));
670 return (const unsigned char *) _("<offset is too big>");
673 ret
= section
->start
+ offset
;
674 /* Unfortunately we cannot rely upon the .debug_line_str section ending
675 with a NUL byte. Since our caller is expecting to receive a well formed
676 C string we test for the lack of a terminating byte here. */
677 if (strnlen ((const char *) ret
, section
->size
- offset
)
678 == section
->size
- offset
)
679 ret
= (const unsigned char *)
680 _("<no NUL byte at end of .debug_line_str section>");
686 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
687 dwarf_vma offset_size
, bool dwo
)
689 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
690 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
691 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
692 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
693 dwarf_vma index_offset
;
694 dwarf_vma str_offset
;
696 unsigned char *curr
= index_section
->start
;
697 unsigned char *end
= curr
+ index_section
->size
;
700 if (index_section
->start
== NULL
)
701 return (dwo
? _("<no .debug_str_offsets.dwo section>")
702 : _("<no .debug_str_offsets section>"));
704 if (str_section
->start
== NULL
)
705 return (dwo
? _("<no .debug_str.dwo section>")
706 : _("<no .debug_str section>"));
708 /* FIXME: We should cache the length... */
709 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
710 if (length
== 0xffffffff)
712 if (offset_size
!= 8)
713 warn (_("Expected offset size of 8 but given %s"), dwarf_vmatoa ("x", offset_size
));
714 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
716 else if (offset_size
!= 4)
718 warn (_("Expected offset size of 4 but given %s"), dwarf_vmatoa ("x", offset_size
));
723 /* This is probably an old style .debug_str_offset section which
724 just contains offsets and no header (and the first offset is 0). */
725 curr
= index_section
->start
;
726 length
= index_section
->size
;
730 /* Skip the version and padding bytes.
731 We assume that they are correct. */
742 && this_set
->section_sizes
[DW_SECT_STR_OFFSETS
] < length
)
743 length
= this_set
->section_sizes
[DW_SECT_STR_OFFSETS
];
745 if (length
> (dwarf_vma
) (end
- curr
))
747 warn (_("index table size too large for section %s vs %s\n"),
748 dwarf_vmatoa ("x", length
),
749 dwarf_vmatoa ("x", index_section
->size
));
753 if (length
< offset_size
)
755 warn (_("index table size %s is too small\n"),
756 dwarf_vmatoa ("x", length
));
757 return _("<table too small>");
761 index_offset
= idx
* offset_size
;
763 if (this_set
!= NULL
)
764 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
766 if (index_offset
>= length
767 || length
- index_offset
< offset_size
)
769 warn (_("DW_FORM_GNU_str_index offset too big: 0x%s vs 0x%s\n"),
770 dwarf_vmatoa ("x", index_offset
),
771 dwarf_vmatoa ("x", length
));
772 return _("<index offset is too big>");
775 str_offset
= byte_get (curr
+ index_offset
, offset_size
);
776 str_offset
-= str_section
->address
;
777 if (str_offset
>= str_section
->size
)
779 warn (_("DW_FORM_GNU_str_index indirect offset too big: 0x%s\n"),
780 dwarf_vmatoa ("x", str_offset
));
781 return _("<indirect index offset is too big>");
784 ret
= (const char *) str_section
->start
+ str_offset
;
785 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
786 Since our caller is expecting to receive a well formed C string we test
787 for the lack of a terminating byte here. */
788 if (strnlen (ret
, str_section
->size
- str_offset
)
789 == str_section
->size
- str_offset
)
790 ret
= (const char *) _("<no NUL byte at end of section>");
796 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
798 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
800 if (section
->start
== NULL
)
801 return (_("<no .debug_addr section>"));
803 if (offset
+ bytes
> section
->size
)
805 warn (_("Offset into section %s too big: 0x%s\n"),
806 section
->name
, dwarf_vmatoa ("x", offset
));
807 return "<offset too big>";
810 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
814 /* FIXME: There are better and more efficient ways to handle
815 these structures. For now though, I just want something that
816 is simple to implement. */
817 /* Records a single attribute in an abbrev. */
818 typedef struct abbrev_attr
820 unsigned long attribute
;
822 bfd_signed_vma implicit_const
;
823 struct abbrev_attr
* next
;
827 /* Records a single abbrev. */
828 typedef struct abbrev_entry
830 unsigned long number
;
833 struct abbrev_attr
* first_attr
;
834 struct abbrev_attr
* last_attr
;
835 struct abbrev_entry
* next
;
839 /* Records a set of abbreviations. */
840 typedef struct abbrev_list
842 abbrev_entry
* first_abbrev
;
843 abbrev_entry
* last_abbrev
;
844 dwarf_vma abbrev_base
;
845 dwarf_vma abbrev_offset
;
846 struct abbrev_list
* next
;
847 unsigned char * start_of_next_abbrevs
;
851 /* Records all the abbrevs found so far. */
852 static struct abbrev_list
* abbrev_lists
= NULL
;
854 typedef struct abbrev_map
861 /* Maps between CU offsets and abbrev sets. */
862 static abbrev_map
* cu_abbrev_map
= NULL
;
863 static unsigned long num_abbrev_map_entries
= 0;
864 static unsigned long next_free_abbrev_map_entry
= 0;
866 #define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
867 #define ABBREV_MAP_ENTRIES_INCREMENT 8
870 record_abbrev_list_for_cu (dwarf_vma start
, dwarf_vma end
, abbrev_list
* list
)
872 if (cu_abbrev_map
== NULL
)
874 num_abbrev_map_entries
= INITIAL_NUM_ABBREV_MAP_ENTRIES
;
875 cu_abbrev_map
= xmalloc (num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
877 else if (next_free_abbrev_map_entry
== num_abbrev_map_entries
)
879 num_abbrev_map_entries
+= ABBREV_MAP_ENTRIES_INCREMENT
;
880 cu_abbrev_map
= xrealloc (cu_abbrev_map
, num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
883 cu_abbrev_map
[next_free_abbrev_map_entry
].start
= start
;
884 cu_abbrev_map
[next_free_abbrev_map_entry
].end
= end
;
885 cu_abbrev_map
[next_free_abbrev_map_entry
].list
= list
;
886 next_free_abbrev_map_entry
++;
890 free_all_abbrevs (void)
894 for (list
= abbrev_lists
; list
!= NULL
;)
896 abbrev_list
* next
= list
->next
;
897 abbrev_entry
* abbrv
;
899 for (abbrv
= list
->first_abbrev
; abbrv
!= NULL
;)
901 abbrev_entry
* next_abbrev
= abbrv
->next
;
904 for (attr
= abbrv
->first_attr
; attr
;)
906 abbrev_attr
*next_attr
= attr
->next
;
924 new_abbrev_list (dwarf_vma abbrev_base
, dwarf_vma abbrev_offset
)
926 abbrev_list
* list
= (abbrev_list
*) xcalloc (sizeof * list
, 1);
928 list
->abbrev_base
= abbrev_base
;
929 list
->abbrev_offset
= abbrev_offset
;
931 list
->next
= abbrev_lists
;
938 find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_base
,
939 dwarf_vma abbrev_offset
)
943 for (list
= abbrev_lists
; list
!= NULL
; list
= list
->next
)
944 if (list
->abbrev_base
== abbrev_base
945 && list
->abbrev_offset
== abbrev_offset
)
951 /* Find the abbreviation map for the CU that includes OFFSET.
952 OFFSET is an absolute offset from the start of the .debug_info section. */
953 /* FIXME: This function is going to slow down readelf & objdump.
954 Consider using a better algorithm to mitigate this effect. */
957 find_abbrev_map_by_offset (dwarf_vma offset
)
961 for (i
= 0; i
< next_free_abbrev_map_entry
; i
++)
962 if (cu_abbrev_map
[i
].start
<= offset
963 && cu_abbrev_map
[i
].end
> offset
)
964 return cu_abbrev_map
+ i
;
970 add_abbrev (unsigned long number
,
975 abbrev_entry
* entry
;
977 entry
= (abbrev_entry
*) xmalloc (sizeof (*entry
));
979 entry
->number
= number
;
981 entry
->children
= children
;
982 entry
->first_attr
= NULL
;
983 entry
->last_attr
= NULL
;
986 assert (list
!= NULL
);
988 if (list
->first_abbrev
== NULL
)
989 list
->first_abbrev
= entry
;
991 list
->last_abbrev
->next
= entry
;
993 list
->last_abbrev
= entry
;
997 add_abbrev_attr (unsigned long attribute
,
999 bfd_signed_vma implicit_const
,
1004 attr
= (abbrev_attr
*) xmalloc (sizeof (*attr
));
1006 attr
->attribute
= attribute
;
1008 attr
->implicit_const
= implicit_const
;
1011 assert (list
!= NULL
&& list
->last_abbrev
!= NULL
);
1013 if (list
->last_abbrev
->first_attr
== NULL
)
1014 list
->last_abbrev
->first_attr
= attr
;
1016 list
->last_abbrev
->last_attr
->next
= attr
;
1018 list
->last_abbrev
->last_attr
= attr
;
1021 /* Processes the (partial) contents of a .debug_abbrev section.
1022 Returns NULL if the end of the section was encountered.
1023 Returns the address after the last byte read if the end of
1024 an abbreviation set was found. */
1026 static unsigned char *
1027 process_abbrev_set (struct dwarf_section
*section
,
1028 dwarf_vma abbrev_base
,
1029 dwarf_vma abbrev_size
,
1030 dwarf_vma abbrev_offset
,
1033 if (abbrev_base
>= section
->size
1034 || abbrev_size
> section
->size
- abbrev_base
)
1036 /* PR 17531: file:4bcd9ce9. */
1037 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than "
1038 "abbrev section size (%lx)\n"),
1039 (unsigned long) (abbrev_base
+ abbrev_size
),
1040 (unsigned long) section
->size
);
1043 if (abbrev_offset
>= abbrev_size
)
1045 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than "
1046 "abbrev section size (%lx)\n"),
1047 (unsigned long) abbrev_offset
,
1048 (unsigned long) abbrev_size
);
1052 unsigned char *start
= section
->start
+ abbrev_base
;
1053 unsigned char *end
= start
+ abbrev_size
;
1054 start
+= abbrev_offset
;
1057 unsigned long entry
;
1059 unsigned long attribute
;
1062 READ_ULEB (entry
, start
, end
);
1064 /* A single zero is supposed to end the set according
1065 to the standard. If there's more, then signal that to
1072 READ_ULEB (tag
, start
, end
);
1076 children
= *start
++;
1078 add_abbrev (entry
, tag
, children
, list
);
1083 /* Initialize it due to a false compiler warning. */
1084 bfd_signed_vma implicit_const
= -1;
1086 READ_ULEB (attribute
, start
, end
);
1090 READ_ULEB (form
, start
, end
);
1094 if (form
== DW_FORM_implicit_const
)
1096 READ_SLEB (implicit_const
, start
, end
);
1101 add_abbrev_attr (attribute
, form
, implicit_const
, list
);
1103 while (attribute
!= 0);
1106 /* Report the missing single zero which ends the section. */
1107 error (_(".debug_abbrev section not zero terminated\n"));
1113 get_TAG_name (unsigned long tag
)
1115 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
1119 static char buffer
[100];
1121 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1122 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
1124 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1132 get_FORM_name (unsigned long form
)
1137 return "DW_FORM value: 0";
1139 name
= get_DW_FORM_name (form
);
1142 static char buffer
[100];
1144 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1152 get_IDX_name (unsigned long idx
)
1154 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1158 static char buffer
[100];
1160 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1167 static unsigned char *
1168 display_block (unsigned char *data
,
1170 const unsigned char * const end
, char delimiter
)
1174 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1176 return (unsigned char *) end
;
1178 maxlen
= (dwarf_vma
) (end
- data
);
1179 length
= length
> maxlen
? maxlen
: length
;
1182 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1188 decode_location_expression (unsigned char * data
,
1189 unsigned int pointer_size
,
1190 unsigned int offset_size
,
1193 dwarf_vma cu_offset
,
1194 struct dwarf_section
* section
)
1198 dwarf_signed_vma svalue
;
1199 unsigned char *end
= data
+ length
;
1200 int need_frame_base
= 0;
1209 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1210 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1213 printf ("DW_OP_deref");
1216 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1217 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1220 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1221 printf ("DW_OP_const1s: %ld", (long) svalue
);
1224 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1225 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1228 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1229 printf ("DW_OP_const2s: %ld", (long) svalue
);
1232 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1233 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1236 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1237 printf ("DW_OP_const4s: %ld", (long) svalue
);
1240 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1241 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1242 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1243 printf ("%lu", (unsigned long) uvalue
);
1246 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1247 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1248 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1249 printf ("%ld", (long) svalue
);
1252 READ_ULEB (uvalue
, data
, end
);
1253 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1256 READ_SLEB (svalue
, data
, end
);
1257 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1260 printf ("DW_OP_dup");
1263 printf ("DW_OP_drop");
1266 printf ("DW_OP_over");
1269 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1270 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1273 printf ("DW_OP_swap");
1276 printf ("DW_OP_rot");
1279 printf ("DW_OP_xderef");
1282 printf ("DW_OP_abs");
1285 printf ("DW_OP_and");
1288 printf ("DW_OP_div");
1291 printf ("DW_OP_minus");
1294 printf ("DW_OP_mod");
1297 printf ("DW_OP_mul");
1300 printf ("DW_OP_neg");
1303 printf ("DW_OP_not");
1306 printf ("DW_OP_or");
1309 printf ("DW_OP_plus");
1311 case DW_OP_plus_uconst
:
1312 READ_ULEB (uvalue
, data
, end
);
1313 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1316 printf ("DW_OP_shl");
1319 printf ("DW_OP_shr");
1322 printf ("DW_OP_shra");
1325 printf ("DW_OP_xor");
1328 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1329 printf ("DW_OP_bra: %ld", (long) svalue
);
1332 printf ("DW_OP_eq");
1335 printf ("DW_OP_ge");
1338 printf ("DW_OP_gt");
1341 printf ("DW_OP_le");
1344 printf ("DW_OP_lt");
1347 printf ("DW_OP_ne");
1350 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1351 printf ("DW_OP_skip: %ld", (long) svalue
);
1386 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1421 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1422 regname (op
- DW_OP_reg0
, 1));
1457 READ_SLEB (svalue
, data
, end
);
1458 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1459 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1463 READ_ULEB (uvalue
, data
, end
);
1464 printf ("DW_OP_regx: %s (%s)",
1465 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1468 need_frame_base
= 1;
1469 READ_SLEB (svalue
, data
, end
);
1470 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1473 READ_ULEB (uvalue
, data
, end
);
1474 READ_SLEB (svalue
, data
, end
);
1475 printf ("DW_OP_bregx: %s (%s) %s",
1476 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1477 dwarf_vmatoa ("d", svalue
));
1480 READ_ULEB (uvalue
, data
, end
);
1481 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1483 case DW_OP_deref_size
:
1484 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1485 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1487 case DW_OP_xderef_size
:
1488 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1489 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1492 printf ("DW_OP_nop");
1495 /* DWARF 3 extensions. */
1496 case DW_OP_push_object_address
:
1497 printf ("DW_OP_push_object_address");
1500 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1501 this ought to be an 8-byte wide computation. */
1502 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1503 printf ("DW_OP_call2: <0x%s>",
1504 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1507 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1508 this ought to be an 8-byte wide computation. */
1509 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1510 printf ("DW_OP_call4: <0x%s>",
1511 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1513 case DW_OP_call_ref
:
1514 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1515 this ought to be an 8-byte wide computation. */
1516 if (dwarf_version
== -1)
1518 printf (_("(DW_OP_call_ref in frame info)"));
1519 /* No way to tell where the next op is, so just bail. */
1520 return need_frame_base
;
1522 if (dwarf_version
== 2)
1524 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1528 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1530 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1532 case DW_OP_form_tls_address
:
1533 printf ("DW_OP_form_tls_address");
1535 case DW_OP_call_frame_cfa
:
1536 printf ("DW_OP_call_frame_cfa");
1538 case DW_OP_bit_piece
:
1539 printf ("DW_OP_bit_piece: ");
1540 READ_ULEB (uvalue
, data
, end
);
1541 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1542 READ_ULEB (uvalue
, data
, end
);
1543 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1546 /* DWARF 4 extensions. */
1547 case DW_OP_stack_value
:
1548 printf ("DW_OP_stack_value");
1551 case DW_OP_implicit_value
:
1552 printf ("DW_OP_implicit_value");
1553 READ_ULEB (uvalue
, data
, end
);
1554 data
= display_block (data
, uvalue
, end
, ' ');
1557 /* GNU extensions. */
1558 case DW_OP_GNU_push_tls_address
:
1559 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1561 case DW_OP_GNU_uninit
:
1562 printf ("DW_OP_GNU_uninit");
1563 /* FIXME: Is there data associated with this OP ? */
1565 case DW_OP_GNU_encoded_addr
:
1572 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1574 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1575 print_dwarf_vma (addr
, pointer_size
);
1578 case DW_OP_implicit_pointer
:
1579 case DW_OP_GNU_implicit_pointer
:
1580 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1581 this ought to be an 8-byte wide computation. */
1582 if (dwarf_version
== -1)
1584 printf (_("(%s in frame info)"),
1585 (op
== DW_OP_implicit_pointer
1586 ? "DW_OP_implicit_pointer"
1587 : "DW_OP_GNU_implicit_pointer"));
1588 /* No way to tell where the next op is, so just bail. */
1589 return need_frame_base
;
1591 if (dwarf_version
== 2)
1593 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1597 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1599 READ_SLEB (svalue
, data
, end
);
1600 printf ("%s: <0x%s> %s",
1601 (op
== DW_OP_implicit_pointer
1602 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1603 dwarf_vmatoa ("x", uvalue
),
1604 dwarf_vmatoa ("d", svalue
));
1606 case DW_OP_entry_value
:
1607 case DW_OP_GNU_entry_value
:
1608 READ_ULEB (uvalue
, data
, end
);
1609 /* PR 17531: file: 0cc9cd00. */
1610 if (uvalue
> (dwarf_vma
) (end
- data
))
1611 uvalue
= end
- data
;
1612 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1613 : "DW_OP_GNU_entry_value"));
1614 if (decode_location_expression (data
, pointer_size
, offset_size
,
1615 dwarf_version
, uvalue
,
1616 cu_offset
, section
))
1617 need_frame_base
= 1;
1621 case DW_OP_const_type
:
1622 case DW_OP_GNU_const_type
:
1623 READ_ULEB (uvalue
, data
, end
);
1624 printf ("%s: <0x%s> ",
1625 (op
== DW_OP_const_type
? "DW_OP_const_type"
1626 : "DW_OP_GNU_const_type"),
1627 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1628 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1629 data
= display_block (data
, uvalue
, end
, ' ');
1631 case DW_OP_regval_type
:
1632 case DW_OP_GNU_regval_type
:
1633 READ_ULEB (uvalue
, data
, end
);
1634 printf ("%s: %s (%s)",
1635 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1636 : "DW_OP_GNU_regval_type"),
1637 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1638 READ_ULEB (uvalue
, data
, end
);
1639 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1641 case DW_OP_deref_type
:
1642 case DW_OP_GNU_deref_type
:
1643 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1645 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1646 : "DW_OP_GNU_deref_type"),
1648 READ_ULEB (uvalue
, data
, end
);
1649 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1652 case DW_OP_GNU_convert
:
1653 READ_ULEB (uvalue
, data
, end
);
1654 printf ("%s <0x%s>",
1655 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1656 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1658 case DW_OP_reinterpret
:
1659 case DW_OP_GNU_reinterpret
:
1660 READ_ULEB (uvalue
, data
, end
);
1661 printf ("%s <0x%s>",
1662 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1663 : "DW_OP_GNU_reinterpret"),
1664 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1666 case DW_OP_GNU_parameter_ref
:
1667 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1668 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1669 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1671 case DW_OP_GNU_addr_index
:
1672 READ_ULEB (uvalue
, data
, end
);
1673 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1675 case DW_OP_GNU_const_index
:
1676 READ_ULEB (uvalue
, data
, end
);
1677 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1679 case DW_OP_GNU_variable_value
:
1680 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1681 this ought to be an 8-byte wide computation. */
1682 if (dwarf_version
== -1)
1684 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1685 /* No way to tell where the next op is, so just bail. */
1686 return need_frame_base
;
1688 if (dwarf_version
== 2)
1690 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1694 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1696 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1699 /* HP extensions. */
1700 case DW_OP_HP_is_value
:
1701 printf ("DW_OP_HP_is_value");
1702 /* FIXME: Is there data associated with this OP ? */
1704 case DW_OP_HP_fltconst4
:
1705 printf ("DW_OP_HP_fltconst4");
1706 /* FIXME: Is there data associated with this OP ? */
1708 case DW_OP_HP_fltconst8
:
1709 printf ("DW_OP_HP_fltconst8");
1710 /* FIXME: Is there data associated with this OP ? */
1712 case DW_OP_HP_mod_range
:
1713 printf ("DW_OP_HP_mod_range");
1714 /* FIXME: Is there data associated with this OP ? */
1716 case DW_OP_HP_unmod_range
:
1717 printf ("DW_OP_HP_unmod_range");
1718 /* FIXME: Is there data associated with this OP ? */
1721 printf ("DW_OP_HP_tls");
1722 /* FIXME: Is there data associated with this OP ? */
1725 /* PGI (STMicroelectronics) extensions. */
1726 case DW_OP_PGI_omp_thread_num
:
1727 /* Pushes the thread number for the current thread as it would be
1728 returned by the standard OpenMP library function:
1729 omp_get_thread_num(). The "current thread" is the thread for
1730 which the expression is being evaluated. */
1731 printf ("DW_OP_PGI_omp_thread_num");
1735 if (op
>= DW_OP_lo_user
1736 && op
<= DW_OP_hi_user
)
1737 printf (_("(User defined location op 0x%x)"), op
);
1739 printf (_("(Unknown location op 0x%x)"), op
);
1740 /* No way to tell where the next op is, so just bail. */
1741 return need_frame_base
;
1744 /* Separate the ops. */
1749 return need_frame_base
;
1752 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1753 This is used for DWARF package files. */
1755 static struct cu_tu_set
*
1756 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1758 struct cu_tu_set
*p
;
1760 unsigned int dw_sect
;
1766 dw_sect
= DW_SECT_TYPES
;
1772 dw_sect
= DW_SECT_INFO
;
1776 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1785 fetch_alt_indirect_string (dwarf_vma offset
)
1789 if (! do_follow_links
)
1792 if (first_separate_info
== NULL
)
1793 return _("<no links available>");
1795 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1797 struct dwarf_section
* section
;
1800 if (! load_debug_section (separate_debug_str
, i
->handle
))
1803 section
= &debug_displays
[separate_debug_str
].section
;
1805 if (section
->start
== NULL
)
1808 if (offset
>= section
->size
)
1811 ret
= (const char *) (section
->start
+ offset
);
1812 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1813 NUL byte. Since our caller is expecting to receive a well formed C
1814 string we test for the lack of a terminating byte here. */
1815 if (strnlen ((const char *) ret
, section
->size
- offset
)
1816 == section
->size
- offset
)
1817 return _("<no NUL byte at end of alt .debug_str section>");
1822 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1823 dwarf_vmatoa ("x", offset
));
1824 return _("<offset is too big>");
1828 get_AT_name (unsigned long attribute
)
1833 return "DW_AT value: 0";
1835 /* One value is shared by the MIPS and HP extensions: */
1836 if (attribute
== DW_AT_MIPS_fde
)
1837 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1839 name
= get_DW_AT_name (attribute
);
1843 static char buffer
[100];
1845 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1854 add_dwo_info (const char * value
, dwarf_vma cu_offset
, dwo_type type
)
1856 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1858 dwinfo
->type
= type
;
1859 dwinfo
->value
= value
;
1860 dwinfo
->cu_offset
= cu_offset
;
1861 dwinfo
->next
= first_dwo_info
;
1862 first_dwo_info
= dwinfo
;
1866 add_dwo_name (const char * name
, dwarf_vma cu_offset
)
1868 add_dwo_info (name
, cu_offset
, DWO_NAME
);
1872 add_dwo_dir (const char * dir
, dwarf_vma cu_offset
)
1874 add_dwo_info (dir
, cu_offset
, DWO_DIR
);
1878 add_dwo_id (const char * id
, dwarf_vma cu_offset
)
1880 add_dwo_info (id
, cu_offset
, DWO_ID
);
1884 free_dwo_info (void)
1889 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1891 next
= dwinfo
->next
;
1894 first_dwo_info
= NULL
;
1897 /* Ensure that START + UVALUE is less than END.
1898 Return an adjusted UVALUE if necessary to ensure this relationship. */
1900 static inline dwarf_vma
1901 check_uvalue (const unsigned char * start
,
1903 const unsigned char * end
)
1905 dwarf_vma max_uvalue
= end
- start
;
1907 /* See PR 17512: file: 008-103549-0.001:0.1.
1908 and PR 24829 for examples of where these tests are triggered. */
1909 if (uvalue
> max_uvalue
)
1911 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1912 uvalue
= max_uvalue
;
1918 static unsigned char *
1919 skip_attr_bytes (unsigned long form
,
1920 unsigned char *data
,
1922 dwarf_vma pointer_size
,
1923 dwarf_vma offset_size
,
1925 dwarf_vma
*value_return
)
1927 dwarf_signed_vma svalue
;
1928 dwarf_vma uvalue
= 0;
1935 case DW_FORM_ref_addr
:
1936 if (dwarf_version
== 2)
1937 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1938 else if (dwarf_version
> 2)
1939 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1945 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1949 case DW_FORM_line_strp
:
1950 case DW_FORM_sec_offset
:
1951 case DW_FORM_GNU_ref_alt
:
1952 case DW_FORM_GNU_strp_alt
:
1953 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1956 case DW_FORM_flag_present
:
1964 case DW_FORM_addrx1
:
1965 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1969 case DW_FORM_addrx3
:
1970 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
1976 case DW_FORM_addrx2
:
1977 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1983 case DW_FORM_addrx4
:
1984 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1988 READ_SLEB (svalue
, data
, end
);
1992 case DW_FORM_ref_udata
:
1994 case DW_FORM_GNU_str_index
:
1996 case DW_FORM_GNU_addr_index
:
1998 READ_ULEB (uvalue
, data
, end
);
2002 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2006 case DW_FORM_ref_sig8
:
2010 case DW_FORM_data16
:
2014 case DW_FORM_string
:
2015 inc
= strnlen ((char *) data
, end
- data
) + 1;
2019 case DW_FORM_exprloc
:
2020 READ_ULEB (uvalue
, data
, end
);
2024 case DW_FORM_block1
:
2025 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2029 case DW_FORM_block2
:
2030 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2034 case DW_FORM_block4
:
2035 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2039 case DW_FORM_indirect
:
2040 READ_ULEB (form
, data
, end
);
2041 if (form
== DW_FORM_implicit_const
)
2042 SKIP_ULEB (data
, end
);
2043 return skip_attr_bytes (form
, data
, end
, pointer_size
, offset_size
,
2044 dwarf_version
, value_return
);
2050 * value_return
= uvalue
;
2051 if (inc
<= (dwarf_vma
) (end
- data
))
2058 /* Given form FORM with value UVALUE, locate and return the abbreviation
2059 associated with it. */
2061 static abbrev_entry
*
2062 get_type_abbrev_from_form (unsigned long form
,
2063 unsigned long uvalue
,
2064 dwarf_vma cu_offset
,
2065 const struct dwarf_section
* section
,
2066 unsigned long * abbrev_num_return
,
2067 unsigned char ** data_return
,
2068 unsigned long * cu_offset_return
)
2070 unsigned long abbrev_number
;
2072 abbrev_entry
* entry
;
2073 unsigned char * data
;
2075 if (abbrev_num_return
!= NULL
)
2076 * abbrev_num_return
= 0;
2077 if (data_return
!= NULL
)
2078 * data_return
= NULL
;
2082 case DW_FORM_GNU_ref_alt
:
2083 case DW_FORM_ref_sig8
:
2084 /* FIXME: We are unable to handle this form at the moment. */
2087 case DW_FORM_ref_addr
:
2088 if (uvalue
>= section
->size
)
2090 warn (_("Unable to resolve ref_addr form: uvalue %lx > section size %lx (%s)\n"),
2091 uvalue
, (long) section
->size
, section
->name
);
2096 case DW_FORM_ref_sup4
:
2097 case DW_FORM_ref_sup8
:
2104 case DW_FORM_ref_udata
:
2105 if (uvalue
+ cu_offset
> section
->size
)
2107 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %lx > section size %lx\n"),
2108 uvalue
, (long) cu_offset
, (long) section
->size
);
2111 uvalue
+= cu_offset
;
2114 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2117 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2121 data
= (unsigned char *) section
->start
+ uvalue
;
2122 map
= find_abbrev_map_by_offset (uvalue
);
2126 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2129 if (map
->list
== NULL
)
2131 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2135 if (cu_offset_return
!= NULL
)
2137 if (form
== DW_FORM_ref_addr
)
2138 * cu_offset_return
= map
->start
;
2140 * cu_offset_return
= cu_offset
;
2143 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2145 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2146 if (entry
->number
== abbrev_number
)
2149 if (abbrev_num_return
!= NULL
)
2150 * abbrev_num_return
= abbrev_number
;
2152 if (data_return
!= NULL
)
2153 * data_return
= data
;
2156 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2161 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2162 can be determined to be a signed type. The data for ENTRY can be
2163 found starting at DATA. */
2166 get_type_signedness (abbrev_entry
*entry
,
2167 const struct dwarf_section
*section
,
2168 unsigned char *data
,
2170 dwarf_vma cu_offset
,
2171 dwarf_vma pointer_size
,
2172 dwarf_vma offset_size
,
2175 unsigned int nesting
)
2179 * is_signed
= false;
2181 #define MAX_NESTING 20
2182 if (nesting
> MAX_NESTING
)
2184 /* FIXME: Warn - or is this expected ?
2185 NB/ We need to avoid infinite recursion. */
2189 for (attr
= entry
->first_attr
;
2190 attr
!= NULL
&& attr
->attribute
;
2193 unsigned char * orig_data
= data
;
2194 dwarf_vma uvalue
= 0;
2196 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2197 offset_size
, dwarf_version
, & uvalue
);
2201 switch (attr
->attribute
)
2203 case DW_AT_linkage_name
:
2207 if (attr
->form
== DW_FORM_strp
)
2208 printf (", %s", fetch_indirect_string (uvalue
));
2209 else if (attr
->form
== DW_FORM_string
)
2210 printf (", %s", orig_data
);
2217 abbrev_entry
* type_abbrev
;
2218 unsigned char * type_data
;
2219 unsigned long type_cu_offset
;
2221 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2225 NULL
/* abbrev num return */,
2228 if (type_abbrev
== NULL
)
2231 get_type_signedness (type_abbrev
, section
, type_data
, end
, type_cu_offset
,
2232 pointer_size
, offset_size
, dwarf_version
,
2233 is_signed
, nesting
+ 1);
2237 case DW_AT_encoding
:
2238 /* Determine signness. */
2241 case DW_ATE_address
:
2242 /* FIXME - some architectures have signed addresses. */
2243 case DW_ATE_boolean
:
2244 case DW_ATE_unsigned
:
2245 case DW_ATE_unsigned_char
:
2246 case DW_ATE_unsigned_fixed
:
2247 * is_signed
= false;
2251 case DW_ATE_complex_float
:
2254 case DW_ATE_signed_char
:
2255 case DW_ATE_imaginary_float
:
2256 case DW_ATE_decimal_float
:
2257 case DW_ATE_signed_fixed
:
2267 read_and_print_leb128 (unsigned char *data
,
2268 unsigned int *bytes_read
,
2269 unsigned const char *end
,
2273 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2275 report_leb_status (status
, __FILE__
, __LINE__
);
2277 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2281 display_discr_list (unsigned long form
,
2283 unsigned char * data
,
2284 unsigned const char * end
,
2289 printf ("[default]");
2296 case DW_FORM_block1
:
2297 case DW_FORM_block2
:
2298 case DW_FORM_block4
:
2299 /* Move data pointer back to the start of the byte array. */
2303 printf ("<corrupt>\n");
2304 warn (_("corrupt discr_list - not using a block form\n"));
2310 printf ("<corrupt>\n");
2311 warn (_("corrupt discr_list - block not long enough\n"));
2316 (level
> 0 && level
<= MAX_CU_NESTING
)
2317 ? level_type_signed
[level
- 1] : false;
2322 unsigned char discriminant
;
2323 unsigned int bytes_read
;
2325 SAFE_BYTE_GET_AND_INC (discriminant
, data
, 1, end
);
2328 assert (uvalue
> 0);
2329 switch (discriminant
)
2333 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2334 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2335 uvalue
-= bytes_read
;
2341 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2342 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2343 uvalue
-= bytes_read
;
2347 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2348 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2349 uvalue
-= bytes_read
;
2354 printf ("<corrupt>\n");
2355 warn (_("corrupt discr_list - unrecognized discriminant byte %#x\n"),
2365 printf (")(signed)");
2367 printf (")(unsigned)");
2370 static unsigned char *
2371 read_and_display_attr_value (unsigned long attribute
,
2373 dwarf_signed_vma implicit_const
,
2374 unsigned char * start
,
2375 unsigned char * data
,
2376 unsigned char * end
,
2377 dwarf_vma cu_offset
,
2378 dwarf_vma pointer_size
,
2379 dwarf_vma offset_size
,
2381 debug_info
* debug_info_p
,
2383 struct dwarf_section
* section
,
2384 struct cu_tu_set
* this_set
,
2388 dwarf_signed_vma svalue
;
2389 dwarf_vma uvalue
= 0;
2390 dwarf_vma uvalue_hi
= 0;
2391 unsigned char *block_start
= NULL
;
2392 unsigned char *orig_data
= data
;
2394 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2396 warn (_("Corrupt attribute\n"));
2400 if (do_wide
&& ! do_loc
)
2402 /* PR 26847: Display the name of the form. */
2403 const char * name
= get_FORM_name (form
);
2405 /* For convenience we skip the DW_FORM_ prefix to the name. */
2407 name
+= 8; /* strlen ("DW_FORM_") */
2408 printf ("%c(%s)", delimiter
, name
);
2416 case DW_FORM_ref_addr
:
2417 if (dwarf_version
== 2)
2418 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2419 else if (dwarf_version
> 2)
2420 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2422 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2426 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2429 case DW_FORM_strp_sup
:
2431 case DW_FORM_line_strp
:
2432 case DW_FORM_sec_offset
:
2433 case DW_FORM_GNU_ref_alt
:
2434 case DW_FORM_GNU_strp_alt
:
2435 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2438 case DW_FORM_flag_present
:
2446 case DW_FORM_addrx1
:
2447 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2453 case DW_FORM_addrx2
:
2454 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2458 case DW_FORM_addrx3
:
2459 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2462 case DW_FORM_ref_sup4
:
2466 case DW_FORM_addrx4
:
2467 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2470 case DW_FORM_ref_sup8
:
2473 case DW_FORM_ref_sig8
:
2474 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2477 case DW_FORM_data16
:
2478 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2479 SAFE_BYTE_GET_AND_INC (uvalue_hi
, data
, 8, end
);
2480 if (byte_get
!= byte_get_little_endian
)
2482 dwarf_vma utmp
= uvalue
;
2489 READ_SLEB (svalue
, data
, end
);
2493 case DW_FORM_GNU_str_index
:
2495 case DW_FORM_ref_udata
:
2497 case DW_FORM_GNU_addr_index
:
2499 READ_ULEB (uvalue
, data
, end
);
2502 case DW_FORM_indirect
:
2503 READ_ULEB (form
, data
, end
);
2505 printf ("%c%s", delimiter
, get_FORM_name (form
));
2506 if (form
== DW_FORM_implicit_const
)
2507 READ_SLEB (implicit_const
, data
, end
);
2508 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2510 cu_offset
, pointer_size
,
2511 offset_size
, dwarf_version
,
2512 debug_info_p
, do_loc
,
2513 section
, this_set
, delimiter
, level
);
2518 case DW_FORM_ref_addr
:
2520 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2523 case DW_FORM_GNU_ref_alt
:
2527 /* We have already printed the form name. */
2528 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2530 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2532 /* FIXME: Follow the reference... */
2538 case DW_FORM_ref_sup4
:
2539 case DW_FORM_ref_udata
:
2541 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2546 case DW_FORM_sec_offset
:
2548 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2551 case DW_FORM_flag_present
:
2558 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2561 case DW_FORM_implicit_const
:
2563 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2566 case DW_FORM_ref_sup8
:
2571 dwarf_vma utmp
= uvalue
;
2572 if (form
== DW_FORM_ref8
)
2574 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", utmp
));
2578 case DW_FORM_data16
:
2581 uvalue_hi
== 0 ? "" : dwarf_vmatoa ("x", uvalue_hi
),
2582 dwarf_vmatoa_1 ("x", uvalue
, uvalue_hi
== 0 ? 0 : 8));
2585 case DW_FORM_string
:
2587 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2588 data
+= strnlen ((char *) data
, end
- data
);
2594 case DW_FORM_exprloc
:
2595 READ_ULEB (uvalue
, data
, end
);
2598 if (block_start
>= end
)
2600 warn (_("Block ends prematurely\n"));
2605 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2608 data
= block_start
+ uvalue
;
2610 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2613 case DW_FORM_block1
:
2614 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2617 case DW_FORM_block2
:
2618 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2621 case DW_FORM_block4
:
2622 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2629 /* We have already displayed the form name. */
2630 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2631 dwarf_vmatoa ("x", uvalue
),
2632 fetch_indirect_string (uvalue
));
2634 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2635 dwarf_vmatoa ("x", uvalue
),
2636 fetch_indirect_string (uvalue
));
2640 case DW_FORM_line_strp
:
2644 /* We have already displayed the form name. */
2645 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2646 dwarf_vmatoa ("x", uvalue
),
2647 fetch_indirect_line_string (uvalue
));
2649 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2650 dwarf_vmatoa ("x", uvalue
),
2651 fetch_indirect_line_string (uvalue
));
2655 case DW_FORM_GNU_str_index
:
2663 const char *suffix
= strrchr (section
->name
, '.');
2664 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2667 /* We have already displayed the form name. */
2668 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2669 dwarf_vmatoa ("x", uvalue
),
2670 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2672 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2673 dwarf_vmatoa ("x", uvalue
),
2674 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2678 case DW_FORM_GNU_strp_alt
:
2682 /* We have already displayed the form name. */
2683 printf (_("%c(offset: 0x%s) %s"), delimiter
,
2684 dwarf_vmatoa ("x", uvalue
),
2685 fetch_alt_indirect_string (uvalue
));
2687 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2688 dwarf_vmatoa ("x", uvalue
),
2689 fetch_alt_indirect_string (uvalue
));
2693 case DW_FORM_indirect
:
2694 /* Handled above. */
2697 case DW_FORM_ref_sig8
:
2699 printf ("%c%s: 0x%s", delimiter
, do_wide
? "" : "signature",
2700 dwarf_vmatoa ("x", uvalue
));
2703 case DW_FORM_GNU_addr_index
:
2705 case DW_FORM_addrx1
:
2706 case DW_FORM_addrx2
:
2707 case DW_FORM_addrx3
:
2708 case DW_FORM_addrx4
:
2714 if (debug_info_p
== NULL
)
2716 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2719 base
= debug_info_p
->addr_base
;
2721 offset
= base
+ uvalue
* pointer_size
;
2724 /* We have already displayed the form name. */
2725 printf (_("%c(index: 0x%s): %s"), delimiter
,
2726 dwarf_vmatoa ("x", uvalue
),
2727 fetch_indexed_value (offset
, pointer_size
));
2729 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2730 dwarf_vmatoa ("x", uvalue
),
2731 fetch_indexed_value (offset
, pointer_size
));
2735 case DW_FORM_strp_sup
:
2737 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2741 warn (_("Unrecognized form: 0x%lx\n"), form
);
2745 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2746 && num_debug_info_entries
== 0
2747 && debug_info_p
!= NULL
)
2751 case DW_AT_frame_base
:
2752 have_frame_base
= 1;
2754 case DW_AT_location
:
2755 case DW_AT_GNU_locviews
:
2756 case DW_AT_string_length
:
2757 case DW_AT_return_addr
:
2758 case DW_AT_data_member_location
:
2759 case DW_AT_vtable_elem_location
:
2761 case DW_AT_static_link
:
2762 case DW_AT_use_location
:
2763 case DW_AT_call_value
:
2764 case DW_AT_GNU_call_site_value
:
2765 case DW_AT_call_data_value
:
2766 case DW_AT_GNU_call_site_data_value
:
2767 case DW_AT_call_target
:
2768 case DW_AT_GNU_call_site_target
:
2769 case DW_AT_call_target_clobbered
:
2770 case DW_AT_GNU_call_site_target_clobbered
:
2771 if ((dwarf_version
< 4
2772 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2773 || form
== DW_FORM_sec_offset
)
2775 /* Process location list. */
2776 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2777 unsigned int num
= debug_info_p
->num_loc_offsets
;
2779 if (lmax
== 0 || num
>= lmax
)
2782 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2783 xcrealloc (debug_info_p
->loc_offsets
,
2784 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2785 debug_info_p
->loc_views
= (dwarf_vma
*)
2786 xcrealloc (debug_info_p
->loc_views
,
2787 lmax
, sizeof (*debug_info_p
->loc_views
));
2788 debug_info_p
->have_frame_base
= (int *)
2789 xcrealloc (debug_info_p
->have_frame_base
,
2790 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2791 debug_info_p
->max_loc_offsets
= lmax
;
2793 if (this_set
!= NULL
)
2794 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2795 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2796 if (attribute
!= DW_AT_GNU_locviews
)
2798 /* Corrupt DWARF info can produce more offsets than views.
2799 See PR 23062 for an example. */
2800 if (debug_info_p
->num_loc_offsets
2801 > debug_info_p
->num_loc_views
)
2802 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2805 debug_info_p
->loc_offsets
[num
] = uvalue
;
2806 debug_info_p
->num_loc_offsets
++;
2811 assert (debug_info_p
->num_loc_views
<= num
);
2812 num
= debug_info_p
->num_loc_views
;
2813 if (num
> debug_info_p
->num_loc_offsets
)
2814 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2817 debug_info_p
->loc_views
[num
] = uvalue
;
2818 debug_info_p
->num_loc_views
++;
2825 if (need_base_address
)
2826 debug_info_p
->base_address
= uvalue
;
2829 case DW_AT_GNU_addr_base
:
2830 case DW_AT_addr_base
:
2831 debug_info_p
->addr_base
= uvalue
;
2834 case DW_AT_GNU_ranges_base
:
2835 debug_info_p
->ranges_base
= uvalue
;
2839 if ((dwarf_version
< 4
2840 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2841 || form
== DW_FORM_sec_offset
)
2843 /* Process range list. */
2844 unsigned int lmax
= debug_info_p
->max_range_lists
;
2845 unsigned int num
= debug_info_p
->num_range_lists
;
2847 if (lmax
== 0 || num
>= lmax
)
2850 debug_info_p
->range_lists
= (dwarf_vma
*)
2851 xcrealloc (debug_info_p
->range_lists
,
2852 lmax
, sizeof (*debug_info_p
->range_lists
));
2853 debug_info_p
->max_range_lists
= lmax
;
2855 debug_info_p
->range_lists
[num
] = uvalue
;
2856 debug_info_p
->num_range_lists
++;
2860 case DW_AT_GNU_dwo_name
:
2861 case DW_AT_dwo_name
:
2866 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2868 case DW_FORM_GNU_strp_alt
:
2869 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2871 case DW_FORM_GNU_str_index
:
2877 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2879 case DW_FORM_string
:
2880 add_dwo_name ((const char *) orig_data
, cu_offset
);
2883 warn (_("Unsupported form (%s) for attribute %s\n"),
2884 get_FORM_name (form
), get_AT_name (attribute
));
2889 case DW_AT_comp_dir
:
2890 /* FIXME: Also extract a build-id in a CU/TU. */
2895 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2897 case DW_FORM_GNU_strp_alt
:
2898 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2900 case DW_FORM_line_strp
:
2901 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2903 case DW_FORM_GNU_str_index
:
2909 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2911 case DW_FORM_string
:
2912 add_dwo_dir ((const char *) orig_data
, cu_offset
);
2915 warn (_("Unsupported form (%s) for attribute %s\n"),
2916 get_FORM_name (form
), get_AT_name (attribute
));
2921 case DW_AT_GNU_dwo_id
:
2926 /* FIXME: Record the length of the ID as well ? */
2927 add_dwo_id ((const char *) (data
- 8), cu_offset
);
2930 warn (_("Unsupported form (%s) for attribute %s\n"),
2931 get_FORM_name (form
), get_AT_name (attribute
));
2941 if (do_loc
|| attribute
== 0)
2944 /* For some attributes we can display further information. */
2948 if (level
>= 0 && level
< MAX_CU_NESTING
2949 && uvalue
< (size_t) (end
- start
))
2951 bool is_signed
= false;
2952 abbrev_entry
*type_abbrev
;
2953 unsigned char *type_data
;
2954 unsigned long type_cu_offset
;
2956 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
2957 section
, NULL
, & type_data
, & type_cu_offset
);
2958 if (type_abbrev
!= NULL
)
2960 get_type_signedness (type_abbrev
, section
, type_data
, end
, type_cu_offset
,
2961 pointer_size
, offset_size
, dwarf_version
,
2964 level_type_signed
[level
] = is_signed
;
2972 case DW_INL_not_inlined
:
2973 printf (_("(not inlined)"));
2975 case DW_INL_inlined
:
2976 printf (_("(inlined)"));
2978 case DW_INL_declared_not_inlined
:
2979 printf (_("(declared as inline but ignored)"));
2981 case DW_INL_declared_inlined
:
2982 printf (_("(declared as inline and inlined)"));
2985 printf (_(" (Unknown inline attribute value: %s)"),
2986 dwarf_vmatoa ("x", uvalue
));
2991 case DW_AT_language
:
2995 /* Ordered by the numeric value of these constants. */
2996 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2997 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2998 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2999 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3000 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3001 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3002 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3003 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3004 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3005 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3006 /* DWARF 2.1 values. */
3007 case DW_LANG_Java
: printf ("(Java)"); break;
3008 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3009 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3010 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3011 /* DWARF 3 values. */
3012 case DW_LANG_PLI
: printf ("(PLI)"); break;
3013 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3014 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3015 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3016 case DW_LANG_D
: printf ("(D)"); break;
3017 /* DWARF 4 values. */
3018 case DW_LANG_Python
: printf ("(Python)"); break;
3019 /* DWARF 5 values. */
3020 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3021 case DW_LANG_Go
: printf ("(Go)"); break;
3022 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3023 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3024 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3025 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3026 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3027 case DW_LANG_Rust
: printf ("(Rust)"); break;
3028 case DW_LANG_C11
: printf ("(C11)"); break;
3029 case DW_LANG_Swift
: printf ("(Swift)"); break;
3030 case DW_LANG_Julia
: printf ("(Julia)"); break;
3031 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3032 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3033 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3034 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3035 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3036 /* MIPS extension. */
3037 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3038 /* UPC extension. */
3039 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3041 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3042 printf (_("(implementation defined: %s)"),
3043 dwarf_vmatoa ("x", uvalue
));
3045 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3050 case DW_AT_encoding
:
3054 case DW_ATE_void
: printf ("(void)"); break;
3055 case DW_ATE_address
: printf ("(machine address)"); break;
3056 case DW_ATE_boolean
: printf ("(boolean)"); break;
3057 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3058 case DW_ATE_float
: printf ("(float)"); break;
3059 case DW_ATE_signed
: printf ("(signed)"); break;
3060 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3061 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3062 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3063 /* DWARF 2.1 values: */
3064 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3065 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3066 /* DWARF 3 values: */
3067 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3068 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3069 case DW_ATE_edited
: printf ("(edited)"); break;
3070 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3071 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3072 /* DWARF 4 values: */
3073 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3074 /* DWARF 5 values: */
3075 case DW_ATE_UCS
: printf ("(UCS)"); break;
3076 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3078 /* HP extensions: */
3079 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3080 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3081 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3082 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3083 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3084 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3085 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3088 if (uvalue
>= DW_ATE_lo_user
3089 && uvalue
<= DW_ATE_hi_user
)
3090 printf (_("(user defined type)"));
3092 printf (_("(unknown type)"));
3097 case DW_AT_accessibility
:
3101 case DW_ACCESS_public
: printf ("(public)"); break;
3102 case DW_ACCESS_protected
: printf ("(protected)"); break;
3103 case DW_ACCESS_private
: printf ("(private)"); break;
3105 printf (_("(unknown accessibility)"));
3110 case DW_AT_visibility
:
3114 case DW_VIS_local
: printf ("(local)"); break;
3115 case DW_VIS_exported
: printf ("(exported)"); break;
3116 case DW_VIS_qualified
: printf ("(qualified)"); break;
3117 default: printf (_("(unknown visibility)")); break;
3121 case DW_AT_endianity
:
3125 case DW_END_default
: printf ("(default)"); break;
3126 case DW_END_big
: printf ("(big)"); break;
3127 case DW_END_little
: printf ("(little)"); break;
3129 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3130 printf (_("(user specified)"));
3132 printf (_("(unknown endianity)"));
3137 case DW_AT_virtuality
:
3141 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3142 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3143 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3144 default: printf (_("(unknown virtuality)")); break;
3148 case DW_AT_identifier_case
:
3152 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3153 case DW_ID_up_case
: printf ("(up_case)"); break;
3154 case DW_ID_down_case
: printf ("(down_case)"); break;
3155 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3156 default: printf (_("(unknown case)")); break;
3160 case DW_AT_calling_convention
:
3164 case DW_CC_normal
: printf ("(normal)"); break;
3165 case DW_CC_program
: printf ("(program)"); break;
3166 case DW_CC_nocall
: printf ("(nocall)"); break;
3167 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3168 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3169 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3170 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3172 if (uvalue
>= DW_CC_lo_user
3173 && uvalue
<= DW_CC_hi_user
)
3174 printf (_("(user defined)"));
3176 printf (_("(unknown convention)"));
3180 case DW_AT_ordering
:
3185 case -1: printf (_("(undefined)")); break;
3186 case 0: printf ("(row major)"); break;
3187 case 1: printf ("(column major)"); break;
3191 case DW_AT_decimal_sign
:
3195 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3196 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3197 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3198 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3199 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3200 default: printf (_("(unrecognised)")); break;
3204 case DW_AT_defaulted
:
3208 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3209 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3210 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3211 default: printf (_("(unrecognised)")); break;
3215 case DW_AT_discr_list
:
3217 display_discr_list (form
, uvalue
, data
, end
, level
);
3220 case DW_AT_frame_base
:
3221 have_frame_base
= 1;
3223 case DW_AT_location
:
3224 case DW_AT_string_length
:
3225 case DW_AT_return_addr
:
3226 case DW_AT_data_member_location
:
3227 case DW_AT_vtable_elem_location
:
3229 case DW_AT_static_link
:
3230 case DW_AT_use_location
:
3231 case DW_AT_call_value
:
3232 case DW_AT_GNU_call_site_value
:
3233 case DW_AT_call_data_value
:
3234 case DW_AT_GNU_call_site_data_value
:
3235 case DW_AT_call_target
:
3236 case DW_AT_GNU_call_site_target
:
3237 case DW_AT_call_target_clobbered
:
3238 case DW_AT_GNU_call_site_target_clobbered
:
3239 if ((dwarf_version
< 4
3240 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3241 || form
== DW_FORM_sec_offset
)
3242 printf (_(" (location list)"));
3244 case DW_AT_allocated
:
3245 case DW_AT_associated
:
3246 case DW_AT_data_location
:
3248 case DW_AT_upper_bound
:
3249 case DW_AT_lower_bound
:
3252 int need_frame_base
;
3255 need_frame_base
= decode_location_expression (block_start
,
3260 cu_offset
, section
);
3262 if (need_frame_base
&& !have_frame_base
)
3263 printf (_(" [without DW_AT_frame_base]"));
3267 case DW_AT_data_bit_offset
:
3268 case DW_AT_byte_size
:
3269 case DW_AT_bit_size
:
3270 case DW_AT_string_length_byte_size
:
3271 case DW_AT_string_length_bit_size
:
3272 case DW_AT_bit_stride
:
3273 if (form
== DW_FORM_exprloc
)
3276 (void) decode_location_expression (block_start
, pointer_size
,
3277 offset_size
, dwarf_version
,
3278 uvalue
, cu_offset
, section
);
3285 unsigned long abbrev_number
;
3286 abbrev_entry
*entry
;
3288 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
3289 section
, & abbrev_number
, NULL
, NULL
);
3292 if (form
!= DW_FORM_GNU_ref_alt
)
3293 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3294 dwarf_vmatoa ("x", uvalue
),
3295 (unsigned long) (orig_data
- section
->start
));
3299 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3300 printf (" (%s)", get_TAG_name (entry
->tag
));
3313 static unsigned char *
3314 read_and_display_attr (unsigned long attribute
,
3316 dwarf_signed_vma implicit_const
,
3317 unsigned char * start
,
3318 unsigned char * data
,
3319 unsigned char * end
,
3320 dwarf_vma cu_offset
,
3321 dwarf_vma pointer_size
,
3322 dwarf_vma offset_size
,
3324 debug_info
* debug_info_p
,
3326 struct dwarf_section
* section
,
3327 struct cu_tu_set
* this_set
,
3331 printf (" %-18s:", get_AT_name (attribute
));
3332 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3334 cu_offset
, pointer_size
, offset_size
,
3335 dwarf_version
, debug_info_p
,
3336 do_loc
, section
, this_set
, ' ', level
);
3342 /* Like load_debug_section, but if the ordinary call fails, and we are
3343 following debug links, then attempt to load the requested section
3344 from one of the separate debug info files. */
3347 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3350 if (load_debug_section (sec_enum
, handle
))
3352 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3354 /* See if we can associate a filename with this section. */
3357 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3358 if (i
->handle
== handle
)
3360 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3368 if (do_follow_links
)
3372 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3374 if (load_debug_section (sec_enum
, i
->handle
))
3376 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3378 /* FIXME: We should check to see if any of the remaining debug info
3379 files also contain this section, and, umm, do something about it. */
3389 introduce (struct dwarf_section
* section
, bool raw
)
3393 if (do_follow_links
&& section
->filename
)
3394 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3395 section
->name
, section
->filename
);
3397 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3401 if (do_follow_links
&& section
->filename
)
3402 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3403 section
->name
, section
->filename
);
3405 printf (_("Contents of the %s section:\n\n"), section
->name
);
3409 /* Process the contents of a .debug_info section.
3410 If do_loc is TRUE then we are scanning for location lists and dwo tags
3411 and we do not want to display anything to the user.
3412 If do_types is TRUE, we are processing a .debug_types section instead of
3413 a .debug_info section.
3414 The information displayed is restricted by the values in DWARF_START_DIE
3415 and DWARF_CUTOFF_LEVEL.
3416 Returns TRUE upon success. Otherwise an error or warning message is
3417 printed and FALSE is returned. */
3420 process_debug_info (struct dwarf_section
* section
,
3422 enum dwarf_section_display_enum abbrev_sec
,
3426 unsigned char *start
= section
->start
;
3427 unsigned char *end
= start
+ section
->size
;
3428 unsigned char *section_begin
;
3430 unsigned int num_units
= 0;
3432 /* First scan the section to get the number of comp units.
3433 Length sanity checks are done here. */
3434 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3439 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3440 will be the length. For a 64-bit DWARF section, it'll be
3441 the escape code 0xffffffff followed by an 8 byte length. */
3442 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3444 if (length
== 0xffffffff)
3445 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3446 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3448 warn (_("Reserved length value (0x%s) found in section %s\n"),
3449 dwarf_vmatoa ("x", length
), section
->name
);
3453 /* Negative values are illegal, they may even cause infinite
3454 looping. This can happen if we can't accurately apply
3455 relocations to an object file, or if the file is corrupt. */
3456 if (length
> (size_t) (end
- section_begin
))
3458 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3459 dwarf_vmatoa ("x", length
), section
->name
);
3462 section_begin
+= length
;
3467 error (_("No comp units in %s section ?\n"), section
->name
);
3471 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3472 && num_debug_info_entries
== 0
3476 /* Then allocate an array to hold the information. */
3477 debug_information
= (debug_info
*) cmalloc (num_units
,
3478 sizeof (* debug_information
));
3479 if (debug_information
== NULL
)
3481 error (_("Not enough memory for a debug info array of %u entries\n"),
3483 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3487 /* PR 17531: file: 92ca3797.
3488 We cannot rely upon the debug_information array being initialised
3489 before it is used. A corrupt file could easily contain references
3490 to a unit for which information has not been made available. So
3491 we ensure that the array is zeroed here. */
3492 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3494 alloc_num_debug_info_entries
= num_units
;
3499 load_debug_section_with_follow (str
, file
);
3500 load_debug_section_with_follow (line_str
, file
);
3501 load_debug_section_with_follow (str_dwo
, file
);
3502 load_debug_section_with_follow (str_index
, file
);
3503 load_debug_section_with_follow (str_index_dwo
, file
);
3504 load_debug_section_with_follow (debug_addr
, file
);
3507 load_debug_section_with_follow (abbrev_sec
, file
);
3508 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3510 warn (_("Unable to locate %s section!\n"),
3511 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3515 if (!do_loc
&& dwarf_start_die
== 0)
3516 introduce (section
, false);
3518 free_all_abbrevs ();
3519 free (cu_abbrev_map
);
3520 cu_abbrev_map
= NULL
;
3521 next_free_abbrev_map_entry
= 0;
3523 /* In order to be able to resolve DW_FORM_ref_attr forms we need
3524 to load *all* of the abbrevs for all CUs in this .debug_info
3525 section. This does effectively mean that we (partially) read
3526 every CU header twice. */
3527 for (section_begin
= start
; start
< end
;)
3529 DWARF2_Internal_CompUnit compunit
;
3530 unsigned char * hdrptr
;
3531 dwarf_vma abbrev_base
;
3533 dwarf_vma cu_offset
;
3534 unsigned int offset_size
;
3535 struct cu_tu_set
* this_set
;
3537 unsigned char *end_cu
;
3540 cu_offset
= start
- section_begin
;
3542 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3544 if (compunit
.cu_length
== 0xffffffff)
3546 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3551 end_cu
= hdrptr
+ compunit
.cu_length
;
3553 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3555 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3557 if (compunit
.cu_version
< 5)
3559 compunit
.cu_unit_type
= DW_UT_compile
;
3560 /* Initialize it due to a false compiler warning. */
3561 compunit
.cu_pointer_size
= -1;
3565 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3566 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3568 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3571 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3574 if (compunit
.cu_unit_type
== DW_UT_split_compile
3575 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3578 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3581 if (this_set
== NULL
)
3584 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3588 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3589 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3592 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3593 compunit
.cu_abbrev_offset
);
3596 unsigned char * next
;
3598 list
= new_abbrev_list (abbrev_base
,
3599 compunit
.cu_abbrev_offset
);
3600 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3601 abbrev_base
, abbrev_size
,
3602 compunit
.cu_abbrev_offset
, list
);
3603 list
->start_of_next_abbrevs
= next
;
3607 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
, list
);
3610 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3612 DWARF2_Internal_CompUnit compunit
;
3613 unsigned char *hdrptr
;
3614 unsigned char *tags
;
3615 int level
, last_level
, saved_level
;
3616 dwarf_vma cu_offset
;
3617 unsigned int offset_size
;
3618 dwarf_vma signature
= 0;
3619 dwarf_vma type_offset
= 0;
3620 struct cu_tu_set
*this_set
;
3621 dwarf_vma abbrev_base
;
3623 abbrev_list
* list
= NULL
;
3624 unsigned char *end_cu
;
3627 cu_offset
= start
- section_begin
;
3629 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3631 if (compunit
.cu_length
== 0xffffffff)
3633 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3638 end_cu
= hdrptr
+ compunit
.cu_length
;
3640 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3642 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3644 if (compunit
.cu_version
< 5)
3646 compunit
.cu_unit_type
= DW_UT_compile
;
3647 /* Initialize it due to a false compiler warning. */
3648 compunit
.cu_pointer_size
= -1;
3652 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3653 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3655 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3658 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3660 if (this_set
== NULL
)
3663 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3667 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3668 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3671 if (compunit
.cu_version
< 5)
3672 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3674 bool do_dwo_id
= false;
3675 uint64_t dwo_id
= 0;
3676 if (compunit
.cu_unit_type
== DW_UT_split_compile
3677 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3679 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3683 /* PR 17512: file: 001-108546-0.001:0.1. */
3684 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3686 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3687 compunit
.cu_pointer_size
, offset_size
);
3688 compunit
.cu_pointer_size
= offset_size
;
3693 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
3694 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
3697 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
3703 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3704 && num_debug_info_entries
== 0
3705 && alloc_num_debug_info_entries
> unit
3708 debug_information
[unit
].cu_offset
= cu_offset
;
3709 debug_information
[unit
].pointer_size
3710 = compunit
.cu_pointer_size
;
3711 debug_information
[unit
].offset_size
= offset_size
;
3712 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3713 debug_information
[unit
].base_address
= 0;
3714 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3715 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3716 debug_information
[unit
].loc_offsets
= NULL
;
3717 debug_information
[unit
].have_frame_base
= NULL
;
3718 debug_information
[unit
].max_loc_offsets
= 0;
3719 debug_information
[unit
].num_loc_offsets
= 0;
3720 debug_information
[unit
].range_lists
= NULL
;
3721 debug_information
[unit
].max_range_lists
= 0;
3722 debug_information
[unit
].num_range_lists
= 0;
3725 if (!do_loc
&& dwarf_start_die
== 0)
3727 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3728 dwarf_vmatoa ("x", cu_offset
));
3729 printf (_(" Length: 0x%s (%s)\n"),
3730 dwarf_vmatoa ("x", compunit
.cu_length
),
3731 offset_size
== 8 ? "64-bit" : "32-bit");
3732 printf (_(" Version: %d\n"), compunit
.cu_version
);
3733 if (compunit
.cu_version
>= 5)
3735 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
3737 printf (_(" Unit Type: %s (%x)\n"),
3738 name
? name
: "???",
3739 compunit
.cu_unit_type
);
3741 printf (_(" Abbrev Offset: 0x%s\n"),
3742 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3743 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3746 printf (_(" Signature: 0x%s\n"),
3747 dwarf_vmatoa ("x", signature
));
3748 printf (_(" Type Offset: 0x%s\n"),
3749 dwarf_vmatoa ("x", type_offset
));
3752 printf (_(" DWO ID: 0x%s\n"), dwarf_vmatoa ("x", dwo_id
));
3753 if (this_set
!= NULL
)
3755 dwarf_vma
*offsets
= this_set
->section_offsets
;
3756 size_t *sizes
= this_set
->section_sizes
;
3758 printf (_(" Section contributions:\n"));
3759 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3760 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3761 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3762 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3763 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3764 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3765 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3766 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3767 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3768 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3769 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3770 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3777 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3779 warn (_("CU at offset %s contains corrupt or "
3780 "unsupported version number: %d.\n"),
3781 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3785 if (compunit
.cu_unit_type
!= DW_UT_compile
3786 && compunit
.cu_unit_type
!= DW_UT_partial
3787 && compunit
.cu_unit_type
!= DW_UT_type
3788 && compunit
.cu_unit_type
!= DW_UT_split_compile
3789 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3791 warn (_("CU at offset %s contains corrupt or "
3792 "unsupported unit type: %d.\n"),
3793 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3797 /* Process the abbrevs used by this compilation unit. */
3798 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3799 compunit
.cu_abbrev_offset
);
3802 unsigned char *next
;
3804 list
= new_abbrev_list (abbrev_base
,
3805 compunit
.cu_abbrev_offset
);
3806 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3807 abbrev_base
, abbrev_size
,
3808 compunit
.cu_abbrev_offset
, list
);
3809 list
->start_of_next_abbrevs
= next
;
3815 while (tags
< start
)
3817 unsigned long abbrev_number
;
3818 unsigned long die_offset
;
3819 abbrev_entry
*entry
;
3821 int do_printing
= 1;
3823 die_offset
= tags
- section_begin
;
3825 READ_ULEB (abbrev_number
, tags
, start
);
3827 /* A null DIE marks the end of a list of siblings or it may also be
3828 a section padding. */
3829 if (abbrev_number
== 0)
3831 /* Check if it can be a section padding for the last CU. */
3832 if (level
== 0 && start
== end
)
3836 for (chk
= tags
; chk
< start
; chk
++)
3843 if (!do_loc
&& die_offset
>= dwarf_start_die
3844 && (dwarf_cutoff_level
== -1
3845 || level
< dwarf_cutoff_level
))
3846 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3852 static unsigned num_bogus_warns
= 0;
3854 if (num_bogus_warns
< 3)
3856 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3857 die_offset
, section
->name
);
3859 if (num_bogus_warns
== 3)
3860 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3863 if (dwarf_start_die
!= 0 && level
< saved_level
)
3870 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3874 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3875 saved_level
= level
;
3876 do_printing
= (dwarf_cutoff_level
== -1
3877 || level
< dwarf_cutoff_level
);
3879 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3880 level
, die_offset
, abbrev_number
);
3881 else if (dwarf_cutoff_level
== -1
3882 || last_level
< dwarf_cutoff_level
)
3883 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3888 /* Scan through the abbreviation list until we reach the
3893 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3894 if (entry
->number
== abbrev_number
)
3899 if (!do_loc
&& do_printing
)
3904 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3905 die_offset
, abbrev_number
);
3909 if (!do_loc
&& do_printing
)
3910 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3915 need_base_address
= 0;
3917 case DW_TAG_compile_unit
:
3918 need_base_address
= 1;
3919 need_dwo_info
= do_loc
;
3921 case DW_TAG_entry_point
:
3922 case DW_TAG_subprogram
:
3923 need_base_address
= 0;
3924 /* Assuming that there is no DW_AT_frame_base. */
3925 have_frame_base
= 0;
3929 debug_info
*debug_info_p
=
3930 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3931 ? debug_information
+ unit
: NULL
;
3933 assert (!debug_info_p
3934 || (debug_info_p
->num_loc_offsets
3935 == debug_info_p
->num_loc_views
));
3937 for (attr
= entry
->first_attr
;
3938 attr
&& attr
->attribute
;
3941 if (! do_loc
&& do_printing
)
3942 /* Show the offset from where the tag was extracted. */
3943 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3944 tags
= read_and_display_attr (attr
->attribute
,
3946 attr
->implicit_const
,
3951 compunit
.cu_pointer_size
,
3953 compunit
.cu_version
,
3955 do_loc
|| ! do_printing
,
3961 /* If a locview attribute appears before a location one,
3962 make sure we don't associate it with an earlier
3965 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3968 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3969 debug_info_p
->num_loc_views
++;
3970 assert (debug_info_p
->num_loc_views
3971 == debug_info_p
->num_loc_offsets
);
3978 warn(_("DIE has locviews without loclist\n"));
3979 debug_info_p
->num_loc_views
--;
3986 if (entry
->children
)
3991 /* Set num_debug_info_entries here so that it can be used to check if
3992 we need to process .debug_loc and .debug_ranges sections. */
3993 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3994 && num_debug_info_entries
== 0
3997 if (num_units
> alloc_num_debug_info_entries
)
3998 num_debug_info_entries
= alloc_num_debug_info_entries
;
4000 num_debug_info_entries
= num_units
;
4009 /* Locate and scan the .debug_info section in the file and record the pointer
4010 sizes and offsets for the compilation units in it. Usually an executable
4011 will have just one pointer size, but this is not guaranteed, and so we try
4012 not to make any assumptions. Returns zero upon failure, or the number of
4013 compilation units upon success. */
4016 load_debug_info (void * file
)
4018 /* If we have already tried and failed to load the .debug_info
4019 section then do not bother to repeat the task. */
4020 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4023 /* If we already have the information there is nothing else to do. */
4024 if (num_debug_info_entries
> 0)
4025 return num_debug_info_entries
;
4027 /* If this is a DWARF package file, load the CU and TU indexes. */
4028 (void) load_cu_tu_indexes (file
);
4030 if (load_debug_section_with_follow (info
, file
)
4031 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4032 return num_debug_info_entries
;
4034 if (load_debug_section_with_follow (info_dwo
, file
)
4035 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4036 abbrev_dwo
, true, false))
4037 return num_debug_info_entries
;
4039 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4043 /* Read a DWARF .debug_line section header starting at DATA.
4044 Upon success returns an updated DATA pointer and the LINFO
4045 structure and the END_OF_SEQUENCE pointer will be filled in.
4046 Otherwise returns NULL. */
4048 static unsigned char *
4049 read_debug_line_header (struct dwarf_section
* section
,
4050 unsigned char * data
,
4051 unsigned char * end
,
4052 DWARF2_Internal_LineInfo
* linfo
,
4053 unsigned char ** end_of_sequence
)
4055 unsigned char *hdrptr
;
4056 unsigned int initial_length_size
;
4058 /* Extract information from the Line Number Program Header.
4059 (section 6.2.4 in the Dwarf3 doc). */
4062 /* Get and check the length of the block. */
4063 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4065 if (linfo
->li_length
== 0xffffffff)
4067 /* This section is 64-bit DWARF 3. */
4068 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4069 linfo
->li_offset_size
= 8;
4070 initial_length_size
= 12;
4074 linfo
->li_offset_size
= 4;
4075 initial_length_size
= 4;
4078 if (linfo
->li_length
+ initial_length_size
> section
->size
)
4080 /* If the length field has a relocation against it, then we should
4081 not complain if it is inaccurate (and probably negative). This
4082 happens in object files when the .debug_line section is actually
4083 comprised of several different .debug_line.* sections, (some of
4084 which may be removed by linker garbage collection), and a relocation
4085 is used to compute the correct length once that is done. */
4086 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4088 linfo
->li_length
= (end
- data
) - initial_length_size
;
4092 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
4093 (long) linfo
->li_length
);
4098 /* Get and check the version number. */
4099 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4101 if (linfo
->li_version
!= 2
4102 && linfo
->li_version
!= 3
4103 && linfo
->li_version
!= 4
4104 && linfo
->li_version
!= 5)
4106 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4107 "is currently supported.\n"));
4111 if (linfo
->li_version
>= 5)
4113 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4115 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4116 if (linfo
->li_segment_size
!= 0)
4118 warn (_("The %s section contains "
4119 "unsupported segment selector size: %d.\n"),
4120 section
->name
, linfo
->li_segment_size
);
4125 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4126 linfo
->li_offset_size
, end
);
4127 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4129 if (linfo
->li_version
>= 4)
4131 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4133 if (linfo
->li_max_ops_per_insn
== 0)
4135 warn (_("Invalid maximum operations per insn.\n"));
4140 linfo
->li_max_ops_per_insn
= 1;
4142 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4143 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4144 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4145 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4147 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
4148 /* PR 17512: file:002-117414-0.004. */
4149 if (* end_of_sequence
> end
)
4151 warn (_("Line length %s extends beyond end of section\n"),
4152 dwarf_vmatoa ("u", linfo
->li_length
));
4153 * end_of_sequence
= end
;
4160 static unsigned char *
4161 display_formatted_table (unsigned char *data
,
4162 unsigned char *start
,
4164 const DWARF2_Internal_LineInfo
*linfo
,
4165 struct dwarf_section
*section
,
4168 unsigned char *format_start
, format_count
, *format
, formati
;
4169 dwarf_vma data_count
, datai
;
4170 unsigned int namepass
, last_entry
= 0;
4171 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4173 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4174 if (do_checks
&& format_count
> 5)
4175 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4176 table_name
, format_count
);
4178 format_start
= data
;
4179 for (formati
= 0; formati
< format_count
; formati
++)
4181 SKIP_ULEB (data
, end
);
4182 SKIP_ULEB (data
, end
);
4185 warn (_("%s: Corrupt format description entry\n"), table_name
);
4190 READ_ULEB (data_count
, data
, end
);
4191 if (data_count
== 0)
4193 printf (_("\n The %s is empty.\n"), table_name
);
4196 else if (data
>= end
)
4198 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
4199 table_name
, dwarf_vmatoa ("x", data_count
));
4203 else if (format_count
== 0)
4205 warn (_("%s: format count is zero, but the table is not empty\n"),
4210 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
4211 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
4214 printf (_(" Entry"));
4215 /* Delay displaying name as the last entry for better screen layout. */
4216 for (namepass
= 0; namepass
< 2; namepass
++)
4218 format
= format_start
;
4219 for (formati
= 0; formati
< format_count
; formati
++)
4221 dwarf_vma content_type
;
4223 READ_ULEB (content_type
, format
, end
);
4224 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4225 switch (content_type
)
4228 printf (_("\tName"));
4230 case DW_LNCT_directory_index
:
4231 printf (_("\tDir"));
4233 case DW_LNCT_timestamp
:
4234 printf (_("\tTime"));
4237 printf (_("\tSize"));
4240 printf (_("\tMD5\t\t\t"));
4243 printf (_("\t(Unknown format content type %s)"),
4244 dwarf_vmatoa ("u", content_type
));
4246 SKIP_ULEB (format
, end
);
4251 for (datai
= 0; datai
< data_count
; datai
++)
4253 unsigned char *datapass
= data
;
4255 printf (" %d", last_entry
++);
4256 /* Delay displaying name as the last entry for better screen layout. */
4257 for (namepass
= 0; namepass
< 2; namepass
++)
4259 format
= format_start
;
4261 for (formati
= 0; formati
< format_count
; formati
++)
4263 dwarf_vma content_type
, form
;
4265 READ_ULEB (content_type
, format
, end
);
4266 READ_ULEB (form
, format
, end
);
4267 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4268 0, 0, linfo
->li_offset_size
,
4269 linfo
->li_version
, NULL
,
4270 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4271 section
, NULL
, '\t', -1);
4275 if (data
>= end
&& (datai
< data_count
- 1))
4277 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4286 display_debug_sup (struct dwarf_section
* section
,
4287 void * file ATTRIBUTE_UNUSED
)
4289 unsigned char * start
= section
->start
;
4290 unsigned char * end
= section
->start
+ section
->size
;
4291 unsigned int version
;
4292 char is_supplementary
;
4293 const unsigned char * sup_filename
;
4294 size_t sup_filename_len
;
4295 unsigned int num_read
;
4297 dwarf_vma checksum_len
;
4300 introduce (section
, true);
4301 if (section
->size
< 4)
4303 error (_("corrupt .debug_sup section: size is too small\n"));
4307 /* Read the data. */
4308 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4310 warn (_("corrupt .debug_sup section: version < 5"));
4312 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4313 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4314 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4316 sup_filename
= start
;
4317 if (is_supplementary
&& sup_filename
[0] != 0)
4318 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4320 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4321 if (sup_filename_len
== (size_t) (end
- start
))
4323 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4326 start
+= sup_filename_len
+ 1;
4328 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4331 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4335 if (checksum_len
> (dwarf_vma
) (end
- start
))
4337 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4338 checksum_len
= end
- start
;
4340 else if (checksum_len
< (dwarf_vma
) (end
- start
))
4342 warn (_("corrupt .debug_sup section: there are 0x%lx extra, unused bytes at the end of the section\n"),
4343 (long) ((end
- start
) - checksum_len
));
4346 printf (_(" Version: %u\n"), version
);
4347 printf (_(" Is Supp: %u\n"), is_supplementary
);
4348 printf (_(" Filename: %s\n"), sup_filename
);
4349 printf (_(" Checksum Len: %lu\n"), (long) checksum_len
);
4350 if (checksum_len
> 0)
4352 printf (_(" Checksum: "));
4353 while (checksum_len
--)
4354 printf ("0x%x ", * start
++ );
4361 display_debug_lines_raw (struct dwarf_section
* section
,
4362 unsigned char * data
,
4363 unsigned char * end
,
4366 unsigned char *start
= section
->start
;
4367 int verbose_view
= 0;
4369 introduce (section
, true);
4373 static DWARF2_Internal_LineInfo saved_linfo
;
4374 DWARF2_Internal_LineInfo linfo
;
4375 unsigned char *standard_opcodes
;
4376 unsigned char *end_of_sequence
;
4379 if (startswith (section
->name
, ".debug_line.")
4380 /* Note: the following does not apply to .debug_line.dwo sections.
4381 These are full debug_line sections. */
4382 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4384 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4385 section containing just the Line Number Statements. They are
4386 created by the assembler and intended to be used alongside gcc's
4387 -ffunction-sections command line option. When the linker's
4388 garbage collection decides to discard a .text.<foo> section it
4389 can then also discard the line number information in .debug_line.<foo>.
4391 Since the section is a fragment it does not have the details
4392 needed to fill out a LineInfo structure, so instead we use the
4393 details from the last full debug_line section that we processed. */
4394 end_of_sequence
= end
;
4395 standard_opcodes
= NULL
;
4396 linfo
= saved_linfo
;
4397 /* PR 17531: file: 0522b371. */
4398 if (linfo
.li_line_range
== 0)
4400 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4403 reset_state_machine (linfo
.li_default_is_stmt
);
4407 unsigned char * hdrptr
;
4409 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4410 & end_of_sequence
)) == NULL
)
4413 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4414 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4415 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4416 if (linfo
.li_version
>= 5)
4418 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4419 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4421 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4422 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4423 if (linfo
.li_version
>= 4)
4424 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4425 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4426 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4427 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4428 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4430 /* PR 17512: file: 1665-6428-0.004. */
4431 if (linfo
.li_line_range
== 0)
4433 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4434 linfo
.li_line_range
= 1;
4437 reset_state_machine (linfo
.li_default_is_stmt
);
4439 /* Display the contents of the Opcodes table. */
4440 standard_opcodes
= hdrptr
;
4442 /* PR 17512: file: 002-417945-0.004. */
4443 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4445 warn (_("Line Base extends beyond end of section\n"));
4449 printf (_("\n Opcodes:\n"));
4451 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4452 printf (ngettext (" Opcode %d has %d arg\n",
4453 " Opcode %d has %d args\n",
4454 standard_opcodes
[i
- 1]),
4455 i
, standard_opcodes
[i
- 1]);
4457 /* Display the contents of the Directory table. */
4458 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4460 if (linfo
.li_version
>= 5)
4462 load_debug_section_with_follow (line_str
, file
);
4464 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4466 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4472 printf (_("\n The Directory Table is empty.\n"));
4475 unsigned int last_dir_entry
= 0;
4477 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4478 (long)(data
- start
));
4480 while (data
< end
&& *data
!= 0)
4482 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4484 data
+= strnlen ((char *) data
, end
- data
);
4489 /* PR 17512: file: 002-132094-0.004. */
4490 if (data
>= end
- 1)
4494 /* Skip the NUL at the end of the table. */
4498 /* Display the contents of the File Name table. */
4499 if (data
>= end
|| *data
== 0)
4500 printf (_("\n The File Name Table is empty.\n"));
4503 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4504 (long)(data
- start
));
4505 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4507 while (data
< end
&& *data
!= 0)
4509 unsigned char *name
;
4512 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4514 data
+= strnlen ((char *) data
, end
- data
);
4518 READ_ULEB (val
, data
, end
);
4519 printf ("%s\t", dwarf_vmatoa ("u", val
));
4520 READ_ULEB (val
, data
, end
);
4521 printf ("%s\t", dwarf_vmatoa ("u", val
));
4522 READ_ULEB (val
, data
, end
);
4523 printf ("%s\t", dwarf_vmatoa ("u", val
));
4524 printf ("%.*s\n", (int)(end
- name
), name
);
4528 warn (_("Corrupt file name table entry\n"));
4534 /* Skip the NUL at the end of the table. */
4540 saved_linfo
= linfo
;
4543 /* Now display the statements. */
4544 if (data
>= end_of_sequence
)
4545 printf (_(" No Line Number Statements.\n"));
4548 printf (_(" Line Number Statements:\n"));
4550 while (data
< end_of_sequence
)
4552 unsigned char op_code
;
4553 dwarf_signed_vma adv
;
4556 printf (" [0x%08lx]", (long)(data
- start
));
4560 if (op_code
>= linfo
.li_opcode_base
)
4562 op_code
-= linfo
.li_opcode_base
;
4563 uladv
= (op_code
/ linfo
.li_line_range
);
4564 if (linfo
.li_max_ops_per_insn
== 1)
4566 uladv
*= linfo
.li_min_insn_length
;
4567 state_machine_regs
.address
+= uladv
;
4569 state_machine_regs
.view
= 0;
4570 printf (_(" Special opcode %d: "
4571 "advance Address by %s to 0x%s%s"),
4572 op_code
, dwarf_vmatoa ("u", uladv
),
4573 dwarf_vmatoa ("x", state_machine_regs
.address
),
4574 verbose_view
&& uladv
4575 ? _(" (reset view)") : "");
4580 = ((state_machine_regs
.op_index
+ uladv
)
4581 / linfo
.li_max_ops_per_insn
)
4582 * linfo
.li_min_insn_length
;
4584 state_machine_regs
.address
+= addrdelta
;
4585 state_machine_regs
.op_index
4586 = (state_machine_regs
.op_index
+ uladv
)
4587 % linfo
.li_max_ops_per_insn
;
4589 state_machine_regs
.view
= 0;
4590 printf (_(" Special opcode %d: "
4591 "advance Address by %s to 0x%s[%d]%s"),
4592 op_code
, dwarf_vmatoa ("u", uladv
),
4593 dwarf_vmatoa ("x", state_machine_regs
.address
),
4594 state_machine_regs
.op_index
,
4595 verbose_view
&& addrdelta
4596 ? _(" (reset view)") : "");
4598 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4599 state_machine_regs
.line
+= adv
;
4600 printf (_(" and Line by %s to %d"),
4601 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4602 if (verbose_view
|| state_machine_regs
.view
)
4603 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4606 state_machine_regs
.view
++;
4611 case DW_LNS_extended_op
:
4612 data
+= process_extended_line_op (data
,
4613 linfo
.li_default_is_stmt
,
4618 printf (_(" Copy"));
4619 if (verbose_view
|| state_machine_regs
.view
)
4620 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4623 state_machine_regs
.view
++;
4626 case DW_LNS_advance_pc
:
4627 READ_ULEB (uladv
, data
, end
);
4628 if (linfo
.li_max_ops_per_insn
== 1)
4630 uladv
*= linfo
.li_min_insn_length
;
4631 state_machine_regs
.address
+= uladv
;
4633 state_machine_regs
.view
= 0;
4634 printf (_(" Advance PC by %s to 0x%s%s\n"),
4635 dwarf_vmatoa ("u", uladv
),
4636 dwarf_vmatoa ("x", state_machine_regs
.address
),
4637 verbose_view
&& uladv
4638 ? _(" (reset view)") : "");
4643 = ((state_machine_regs
.op_index
+ uladv
)
4644 / linfo
.li_max_ops_per_insn
)
4645 * linfo
.li_min_insn_length
;
4646 state_machine_regs
.address
4648 state_machine_regs
.op_index
4649 = (state_machine_regs
.op_index
+ uladv
)
4650 % linfo
.li_max_ops_per_insn
;
4652 state_machine_regs
.view
= 0;
4653 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4654 dwarf_vmatoa ("u", uladv
),
4655 dwarf_vmatoa ("x", state_machine_regs
.address
),
4656 state_machine_regs
.op_index
,
4657 verbose_view
&& addrdelta
4658 ? _(" (reset view)") : "");
4662 case DW_LNS_advance_line
:
4663 READ_SLEB (adv
, data
, end
);
4664 state_machine_regs
.line
+= adv
;
4665 printf (_(" Advance Line by %s to %d\n"),
4666 dwarf_vmatoa ("d", adv
),
4667 state_machine_regs
.line
);
4670 case DW_LNS_set_file
:
4671 READ_ULEB (uladv
, data
, end
);
4672 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4673 dwarf_vmatoa ("u", uladv
));
4674 state_machine_regs
.file
= uladv
;
4677 case DW_LNS_set_column
:
4678 READ_ULEB (uladv
, data
, end
);
4679 printf (_(" Set column to %s\n"),
4680 dwarf_vmatoa ("u", uladv
));
4681 state_machine_regs
.column
= uladv
;
4684 case DW_LNS_negate_stmt
:
4685 adv
= state_machine_regs
.is_stmt
;
4687 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4688 state_machine_regs
.is_stmt
= adv
;
4691 case DW_LNS_set_basic_block
:
4692 printf (_(" Set basic block\n"));
4693 state_machine_regs
.basic_block
= 1;
4696 case DW_LNS_const_add_pc
:
4697 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4698 if (linfo
.li_max_ops_per_insn
)
4700 uladv
*= linfo
.li_min_insn_length
;
4701 state_machine_regs
.address
+= uladv
;
4703 state_machine_regs
.view
= 0;
4704 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4705 dwarf_vmatoa ("u", uladv
),
4706 dwarf_vmatoa ("x", state_machine_regs
.address
),
4707 verbose_view
&& uladv
4708 ? _(" (reset view)") : "");
4713 = ((state_machine_regs
.op_index
+ uladv
)
4714 / linfo
.li_max_ops_per_insn
)
4715 * linfo
.li_min_insn_length
;
4716 state_machine_regs
.address
4718 state_machine_regs
.op_index
4719 = (state_machine_regs
.op_index
+ uladv
)
4720 % linfo
.li_max_ops_per_insn
;
4722 state_machine_regs
.view
= 0;
4723 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4724 dwarf_vmatoa ("u", uladv
),
4725 dwarf_vmatoa ("x", state_machine_regs
.address
),
4726 state_machine_regs
.op_index
,
4727 verbose_view
&& addrdelta
4728 ? _(" (reset view)") : "");
4732 case DW_LNS_fixed_advance_pc
:
4733 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4734 state_machine_regs
.address
+= uladv
;
4735 state_machine_regs
.op_index
= 0;
4736 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4737 dwarf_vmatoa ("u", uladv
),
4738 dwarf_vmatoa ("x", state_machine_regs
.address
));
4739 /* Do NOT reset view. */
4742 case DW_LNS_set_prologue_end
:
4743 printf (_(" Set prologue_end to true\n"));
4746 case DW_LNS_set_epilogue_begin
:
4747 printf (_(" Set epilogue_begin to true\n"));
4750 case DW_LNS_set_isa
:
4751 READ_ULEB (uladv
, data
, end
);
4752 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4756 printf (_(" Unknown opcode %d with operands: "), op_code
);
4758 if (standard_opcodes
!= NULL
)
4759 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4761 READ_ULEB (uladv
, data
, end
);
4762 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4763 i
== 1 ? "" : ", ");
4778 unsigned char *name
;
4779 unsigned int directory_index
;
4780 unsigned int modification_date
;
4781 unsigned int length
;
4784 /* Output a decoded representation of the .debug_line section. */
4787 display_debug_lines_decoded (struct dwarf_section
* section
,
4788 unsigned char * start
,
4789 unsigned char * data
,
4790 unsigned char * end
,
4793 static DWARF2_Internal_LineInfo saved_linfo
;
4795 introduce (section
, false);
4799 /* This loop amounts to one iteration per compilation unit. */
4800 DWARF2_Internal_LineInfo linfo
;
4801 unsigned char *standard_opcodes
;
4802 unsigned char *end_of_sequence
;
4804 File_Entry
*file_table
= NULL
;
4805 unsigned int n_files
= 0;
4806 unsigned char **directory_table
= NULL
;
4807 dwarf_vma n_directories
= 0;
4809 if (startswith (section
->name
, ".debug_line.")
4810 /* Note: the following does not apply to .debug_line.dwo sections.
4811 These are full debug_line sections. */
4812 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4814 /* See comment in display_debug_lines_raw(). */
4815 end_of_sequence
= end
;
4816 standard_opcodes
= NULL
;
4817 linfo
= saved_linfo
;
4818 /* PR 17531: file: 0522b371. */
4819 if (linfo
.li_line_range
== 0)
4821 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4824 reset_state_machine (linfo
.li_default_is_stmt
);
4828 unsigned char *hdrptr
;
4830 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4831 & end_of_sequence
)) == NULL
)
4834 /* PR 17531: file: 0522b371. */
4835 if (linfo
.li_line_range
== 0)
4837 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4838 linfo
.li_line_range
= 1;
4840 reset_state_machine (linfo
.li_default_is_stmt
);
4842 /* Save a pointer to the contents of the Opcodes table. */
4843 standard_opcodes
= hdrptr
;
4845 /* Traverse the Directory table just to count entries. */
4846 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4850 warn (_("opcode base of %d extends beyond end of section\n"),
4851 linfo
.li_opcode_base
);
4855 if (linfo
.li_version
>= 5)
4857 unsigned char *format_start
, format_count
, *format
;
4858 dwarf_vma formati
, entryi
;
4860 load_debug_section_with_follow (line_str
, fileptr
);
4862 /* Skip directories format. */
4863 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4864 if (do_checks
&& format_count
> 1)
4865 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4867 format_start
= data
;
4868 for (formati
= 0; formati
< format_count
; formati
++)
4870 SKIP_ULEB (data
, end
);
4871 SKIP_ULEB (data
, end
);
4874 READ_ULEB (n_directories
, data
, end
);
4877 warn (_("Corrupt directories list\n"));
4881 if (n_directories
== 0)
4882 directory_table
= NULL
;
4884 directory_table
= (unsigned char **)
4885 xmalloc (n_directories
* sizeof (unsigned char *));
4887 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4889 unsigned char **pathp
= &directory_table
[entryi
];
4891 format
= format_start
;
4892 for (formati
= 0; formati
< format_count
; formati
++)
4894 dwarf_vma content_type
, form
;
4897 READ_ULEB (content_type
, format
, end
);
4898 READ_ULEB (form
, format
, end
);
4901 warn (_("Corrupt directories list\n"));
4904 switch (content_type
)
4909 case DW_FORM_string
:
4912 case DW_FORM_line_strp
:
4913 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4915 /* Remove const by the cast. */
4916 *pathp
= (unsigned char *)
4917 fetch_indirect_line_string (uvalue
);
4922 data
= read_and_display_attr_value (0, form
, 0, start
,
4924 linfo
.li_offset_size
,
4931 warn (_("Corrupt directories list\n"));
4936 /* Skip files format. */
4937 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4938 if (do_checks
&& format_count
> 5)
4939 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4941 format_start
= data
;
4942 for (formati
= 0; formati
< format_count
; formati
++)
4944 SKIP_ULEB (data
, end
);
4945 SKIP_ULEB (data
, end
);
4948 READ_ULEB (n_files
, data
, end
);
4949 if (data
>= end
&& n_files
> 0)
4951 warn (_("Corrupt file name list\n"));
4958 file_table
= (File_Entry
*) xcalloc (1, n_files
4959 * sizeof (File_Entry
));
4961 for (entryi
= 0; entryi
< n_files
; entryi
++)
4963 File_Entry
*file
= &file_table
[entryi
];
4965 format
= format_start
;
4966 for (formati
= 0; formati
< format_count
; formati
++)
4968 dwarf_vma content_type
, form
;
4972 READ_ULEB (content_type
, format
, end
);
4973 READ_ULEB (form
, format
, end
);
4976 warn (_("Corrupt file name list\n"));
4979 switch (content_type
)
4984 case DW_FORM_string
:
4987 case DW_FORM_line_strp
:
4988 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4990 /* Remove const by the cast. */
4991 file
->name
= (unsigned char *)
4992 fetch_indirect_line_string (uvalue
);
4996 case DW_LNCT_directory_index
:
5000 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5004 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5009 READ_ULEB (file
->directory_index
, tmp
, end
);
5014 data
= read_and_display_attr_value (0, form
, 0, start
,
5016 linfo
.li_offset_size
,
5023 warn (_("Corrupt file name list\n"));
5032 unsigned char *ptr_directory_table
= data
;
5034 while (data
< end
&& *data
!= 0)
5036 data
+= strnlen ((char *) data
, end
- data
);
5045 warn (_("directory table ends unexpectedly\n"));
5050 /* Go through the directory table again to save the directories. */
5051 directory_table
= (unsigned char **)
5052 xmalloc (n_directories
* sizeof (unsigned char *));
5055 while (*ptr_directory_table
!= 0)
5057 directory_table
[i
] = ptr_directory_table
;
5058 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
5059 ptr_directory_table
- end
) + 1;
5063 /* Skip the NUL at the end of the table. */
5066 /* Traverse the File Name table just to count the entries. */
5067 if (data
< end
&& *data
!= 0)
5069 unsigned char *ptr_file_name_table
= data
;
5071 while (data
< end
&& *data
!= 0)
5073 /* Skip Name, directory index, last modification
5074 time and length of file. */
5075 data
+= strnlen ((char *) data
, end
- data
);
5078 SKIP_ULEB (data
, end
);
5079 SKIP_ULEB (data
, end
);
5080 SKIP_ULEB (data
, end
);
5086 warn (_("file table ends unexpectedly\n"));
5091 /* Go through the file table again to save the strings. */
5092 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5095 while (*ptr_file_name_table
!= 0)
5097 file_table
[i
].name
= ptr_file_name_table
;
5098 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
5099 end
- ptr_file_name_table
) + 1;
5101 /* We are not interested in directory, time or size. */
5102 READ_ULEB (file_table
[i
].directory_index
,
5103 ptr_file_name_table
, end
);
5104 READ_ULEB (file_table
[i
].modification_date
,
5105 ptr_file_name_table
, end
);
5106 READ_ULEB (file_table
[i
].length
,
5107 ptr_file_name_table
, end
);
5113 /* Skip the NUL at the end of the table. */
5117 /* Print the Compilation Unit's name and a header. */
5118 if (file_table
== NULL
)
5119 printf (_("CU: No directory table\n"));
5120 else if (directory_table
== NULL
)
5121 printf (_("CU: %s:\n"), file_table
[0].name
);
5124 unsigned int ix
= file_table
[0].directory_index
;
5125 const char *directory
;
5130 else if (n_directories
== 0)
5131 directory
= _("<unknown>");
5132 else if (ix
> n_directories
)
5134 warn (_("directory index %u > number of directories %s\n"),
5135 ix
, dwarf_vmatoa ("u", n_directories
));
5136 directory
= _("<corrupt>");
5139 directory
= (char *) directory_table
[ix
- 1];
5141 if (do_wide
|| strlen (directory
) < 76)
5142 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5144 printf ("%s:\n", file_table
[0].name
);
5148 printf (_("File name Line number Starting address View Stmt\n"));
5150 printf (_("CU: Empty file name table\n"));
5151 saved_linfo
= linfo
;
5154 /* This loop iterates through the Dwarf Line Number Program. */
5155 while (data
< end_of_sequence
)
5157 unsigned char op_code
;
5160 unsigned long int uladv
;
5161 int is_special_opcode
= 0;
5166 if (op_code
>= linfo
.li_opcode_base
)
5168 op_code
-= linfo
.li_opcode_base
;
5169 uladv
= (op_code
/ linfo
.li_line_range
);
5170 if (linfo
.li_max_ops_per_insn
== 1)
5172 uladv
*= linfo
.li_min_insn_length
;
5173 state_machine_regs
.address
+= uladv
;
5175 state_machine_regs
.view
= 0;
5180 = ((state_machine_regs
.op_index
+ uladv
)
5181 / linfo
.li_max_ops_per_insn
)
5182 * linfo
.li_min_insn_length
;
5183 state_machine_regs
.address
5185 state_machine_regs
.op_index
5186 = (state_machine_regs
.op_index
+ uladv
)
5187 % linfo
.li_max_ops_per_insn
;
5189 state_machine_regs
.view
= 0;
5192 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5193 state_machine_regs
.line
+= adv
;
5194 is_special_opcode
= 1;
5195 /* Increment view after printing this row. */
5200 case DW_LNS_extended_op
:
5202 unsigned int ext_op_code_len
;
5203 unsigned char ext_op_code
;
5204 unsigned char *op_code_end
;
5205 unsigned char *op_code_data
= data
;
5207 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5208 op_code_end
= op_code_data
+ ext_op_code_len
;
5209 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5211 warn (_("Badly formed extended line op encountered!\n"));
5214 ext_op_code
= *op_code_data
++;
5218 switch (ext_op_code
)
5220 case DW_LNE_end_sequence
:
5221 /* Reset stuff after printing this row. */
5223 case DW_LNE_set_address
:
5224 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5226 op_code_end
- op_code_data
,
5228 state_machine_regs
.op_index
= 0;
5229 state_machine_regs
.view
= 0;
5231 case DW_LNE_define_file
:
5232 file_table
= (File_Entry
*) xrealloc
5233 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5235 ++state_machine_regs
.last_file_entry
;
5236 /* Source file name. */
5237 file_table
[n_files
].name
= op_code_data
;
5238 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5239 /* Directory index. */
5240 READ_ULEB (file_table
[n_files
].directory_index
,
5241 op_code_data
, op_code_end
);
5242 /* Last modification time. */
5243 READ_ULEB (file_table
[n_files
].modification_date
,
5244 op_code_data
, op_code_end
);
5246 READ_ULEB (file_table
[n_files
].length
,
5247 op_code_data
, op_code_end
);
5251 case DW_LNE_set_discriminator
:
5252 case DW_LNE_HP_set_sequence
:
5253 /* Simply ignored. */
5257 printf (_("UNKNOWN (%u): length %ld\n"),
5258 ext_op_code
, (long int) (op_code_data
- data
));
5265 /* Increment view after printing this row. */
5268 case DW_LNS_advance_pc
:
5269 READ_ULEB (uladv
, data
, end
);
5270 if (linfo
.li_max_ops_per_insn
== 1)
5272 uladv
*= linfo
.li_min_insn_length
;
5273 state_machine_regs
.address
+= uladv
;
5275 state_machine_regs
.view
= 0;
5280 = ((state_machine_regs
.op_index
+ uladv
)
5281 / linfo
.li_max_ops_per_insn
)
5282 * linfo
.li_min_insn_length
;
5283 state_machine_regs
.address
5285 state_machine_regs
.op_index
5286 = (state_machine_regs
.op_index
+ uladv
)
5287 % linfo
.li_max_ops_per_insn
;
5289 state_machine_regs
.view
= 0;
5293 case DW_LNS_advance_line
:
5294 READ_SLEB (adv
, data
, end
);
5295 state_machine_regs
.line
+= adv
;
5298 case DW_LNS_set_file
:
5299 READ_ULEB (uladv
, data
, end
);
5300 state_machine_regs
.file
= uladv
;
5303 unsigned file
= state_machine_regs
.file
- 1;
5306 if (file_table
== NULL
|| n_files
== 0)
5307 printf (_("\n [Use file table entry %d]\n"), file
);
5309 else if (file
>= n_files
)
5311 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
5312 printf (_("\n <over large file table index %u>"), file
);
5314 else if ((dir
= file_table
[file
].directory_index
) == 0)
5315 /* If directory index is 0, that means current directory. */
5316 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5317 else if (directory_table
== NULL
|| n_directories
== 0)
5318 printf (_("\n [Use file %s in directory table entry %d]\n"),
5319 file_table
[file
].name
, dir
);
5321 else if (dir
> n_directories
)
5323 warn (_("directory index %u > number of directories %s\n"),
5324 dir
, dwarf_vmatoa ("u", n_directories
));
5325 printf (_("\n <over large directory table entry %u>\n"), dir
);
5328 printf ("\n%s/%s:\n",
5329 /* The directory index starts counting at 1. */
5330 directory_table
[dir
- 1], file_table
[file
].name
);
5334 case DW_LNS_set_column
:
5335 READ_ULEB (uladv
, data
, end
);
5336 state_machine_regs
.column
= uladv
;
5339 case DW_LNS_negate_stmt
:
5340 adv
= state_machine_regs
.is_stmt
;
5342 state_machine_regs
.is_stmt
= adv
;
5345 case DW_LNS_set_basic_block
:
5346 state_machine_regs
.basic_block
= 1;
5349 case DW_LNS_const_add_pc
:
5350 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5351 if (linfo
.li_max_ops_per_insn
== 1)
5353 uladv
*= linfo
.li_min_insn_length
;
5354 state_machine_regs
.address
+= uladv
;
5356 state_machine_regs
.view
= 0;
5361 = ((state_machine_regs
.op_index
+ uladv
)
5362 / linfo
.li_max_ops_per_insn
)
5363 * linfo
.li_min_insn_length
;
5364 state_machine_regs
.address
5366 state_machine_regs
.op_index
5367 = (state_machine_regs
.op_index
+ uladv
)
5368 % linfo
.li_max_ops_per_insn
;
5370 state_machine_regs
.view
= 0;
5374 case DW_LNS_fixed_advance_pc
:
5375 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5376 state_machine_regs
.address
+= uladv
;
5377 state_machine_regs
.op_index
= 0;
5378 /* Do NOT reset view. */
5381 case DW_LNS_set_prologue_end
:
5384 case DW_LNS_set_epilogue_begin
:
5387 case DW_LNS_set_isa
:
5388 READ_ULEB (uladv
, data
, end
);
5389 printf (_(" Set ISA to %lu\n"), uladv
);
5393 printf (_(" Unknown opcode %d with operands: "), op_code
);
5395 if (standard_opcodes
!= NULL
)
5396 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5400 READ_ULEB (val
, data
, end
);
5401 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5402 i
== 1 ? "" : ", ");
5408 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5409 to the DWARF address/line matrix. */
5410 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5411 || (xop
== DW_LNS_copy
))
5413 const unsigned int MAX_FILENAME_LENGTH
= 35;
5415 char *newFileName
= NULL
;
5416 size_t fileNameLength
;
5420 unsigned indx
= state_machine_regs
.file
- 1;
5422 if (indx
>= n_files
)
5424 warn (_("corrupt file index %u encountered\n"), indx
);
5425 fileName
= _("<corrupt>");
5428 fileName
= (char *) file_table
[indx
].name
;
5431 fileName
= _("<unknown>");
5433 fileNameLength
= strlen (fileName
);
5435 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
5437 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5438 /* Truncate file name */
5439 strncpy (newFileName
,
5440 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5441 MAX_FILENAME_LENGTH
+ 1);
5442 /* FIXME: This is to pacify gcc-10 which can warn that the
5443 strncpy above might leave a non-NUL terminated string
5444 in newFileName. It won't, but gcc's analysis doesn't
5445 quite go far enough to discover this. */
5446 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5450 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
5451 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
5454 /* A row with end_seq set to true has a meaningful address, but
5455 the other information in the same row is not significant.
5456 In such a row, print line as "-", and don't print
5458 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
5460 if (linfo
.li_max_ops_per_insn
== 1)
5462 if (xop
== -DW_LNE_end_sequence
)
5463 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5465 state_machine_regs
.address
);
5467 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5468 newFileName
, state_machine_regs
.line
,
5469 state_machine_regs
.address
);
5473 if (xop
== -DW_LNE_end_sequence
)
5474 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5476 state_machine_regs
.address
,
5477 state_machine_regs
.op_index
);
5479 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5480 newFileName
, state_machine_regs
.line
,
5481 state_machine_regs
.address
,
5482 state_machine_regs
.op_index
);
5487 if (linfo
.li_max_ops_per_insn
== 1)
5489 if (xop
== -DW_LNE_end_sequence
)
5490 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5492 state_machine_regs
.address
);
5494 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5495 newFileName
, state_machine_regs
.line
,
5496 state_machine_regs
.address
);
5500 if (xop
== -DW_LNE_end_sequence
)
5501 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5503 state_machine_regs
.address
,
5504 state_machine_regs
.op_index
);
5506 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5507 newFileName
, state_machine_regs
.line
,
5508 state_machine_regs
.address
,
5509 state_machine_regs
.op_index
);
5513 if (xop
!= -DW_LNE_end_sequence
)
5515 if (state_machine_regs
.view
)
5516 printf (" %6u", state_machine_regs
.view
);
5520 if (state_machine_regs
.is_stmt
)
5525 state_machine_regs
.view
++;
5527 if (xop
== -DW_LNE_end_sequence
)
5529 reset_state_machine (linfo
.li_default_is_stmt
);
5544 if (directory_table
)
5546 free (directory_table
);
5547 directory_table
= NULL
;
5558 display_debug_lines (struct dwarf_section
*section
, void *file
)
5560 unsigned char *data
= section
->start
;
5561 unsigned char *end
= data
+ section
->size
;
5563 int retValDecoded
= 1;
5565 if (do_debug_lines
== 0)
5566 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5568 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5569 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5571 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5572 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5574 if (!retValRaw
|| !retValDecoded
)
5581 find_debug_info_for_offset (unsigned long offset
)
5585 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5588 for (i
= 0; i
< num_debug_info_entries
; i
++)
5589 if (debug_information
[i
].cu_offset
== offset
)
5590 return debug_information
+ i
;
5596 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5598 /* See gdb/gdb-index.h. */
5599 static const char * const kinds
[] =
5611 return _ (kinds
[kind
]);
5615 display_debug_pubnames_worker (struct dwarf_section
*section
,
5616 void *file ATTRIBUTE_UNUSED
,
5619 DWARF2_Internal_PubNames names
;
5620 unsigned char *start
= section
->start
;
5621 unsigned char *end
= start
+ section
->size
;
5623 /* It does not matter if this load fails,
5624 we test for that later on. */
5625 load_debug_info (file
);
5627 introduce (section
, false);
5631 unsigned char *data
;
5632 unsigned long sec_off
;
5633 unsigned int offset_size
, initial_length_size
;
5635 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5636 if (names
.pn_length
== 0xffffffff)
5638 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5640 initial_length_size
= 12;
5645 initial_length_size
= 4;
5648 sec_off
= start
- section
->start
;
5649 if (sec_off
+ names
.pn_length
< sec_off
5650 || sec_off
+ names
.pn_length
> section
->size
)
5652 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5654 sec_off
- initial_length_size
,
5655 dwarf_vmatoa ("x", names
.pn_length
));
5660 start
+= names
.pn_length
;
5662 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5663 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5665 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5666 && num_debug_info_entries
> 0
5667 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5668 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5669 (unsigned long) names
.pn_offset
, section
->name
);
5671 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5673 printf (_(" Length: %ld\n"),
5674 (long) names
.pn_length
);
5675 printf (_(" Version: %d\n"),
5677 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5678 (unsigned long) names
.pn_offset
);
5679 printf (_(" Size of area in .debug_info section: %ld\n"),
5680 (long) names
.pn_size
);
5682 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5684 static int warned
= 0;
5688 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5696 printf (_("\n Offset Kind Name\n"));
5698 printf (_("\n Offset\tName\n"));
5702 bfd_size_type maxprint
;
5705 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, end
);
5712 maxprint
= (end
- data
) - 1;
5716 unsigned int kind_data
;
5717 gdb_index_symbol_kind kind
;
5718 const char *kind_name
;
5721 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, end
);
5723 /* GCC computes the kind as the upper byte in the CU index
5724 word, and then right shifts it by the CU index size.
5725 Left shift KIND to where the gdb-index.h accessor macros
5727 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5728 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5729 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5730 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5731 printf (" %-6lx %s,%-10s %.*s\n",
5732 (unsigned long) offset
, is_static
? _("s") : _("g"),
5733 kind_name
, (int) maxprint
, data
);
5736 printf (" %-6lx\t%.*s\n",
5737 (unsigned long) offset
, (int) maxprint
, data
);
5739 data
+= strnlen ((char *) data
, maxprint
);
5752 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5754 return display_debug_pubnames_worker (section
, file
, 0);
5758 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5760 return display_debug_pubnames_worker (section
, file
, 1);
5764 display_debug_macinfo (struct dwarf_section
*section
,
5765 void *file ATTRIBUTE_UNUSED
)
5767 unsigned char *start
= section
->start
;
5768 unsigned char *end
= start
+ section
->size
;
5769 unsigned char *curr
= start
;
5770 enum dwarf_macinfo_record_type op
;
5772 introduce (section
, false);
5776 unsigned int lineno
;
5777 const unsigned char *string
;
5779 op
= (enum dwarf_macinfo_record_type
) *curr
;
5784 case DW_MACINFO_start_file
:
5786 unsigned int filenum
;
5788 READ_ULEB (lineno
, curr
, end
);
5789 READ_ULEB (filenum
, curr
, end
);
5790 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5795 case DW_MACINFO_end_file
:
5796 printf (_(" DW_MACINFO_end_file\n"));
5799 case DW_MACINFO_define
:
5800 READ_ULEB (lineno
, curr
, end
);
5802 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5803 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5807 case DW_MACINFO_undef
:
5808 READ_ULEB (lineno
, curr
, end
);
5810 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5811 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5815 case DW_MACINFO_vendor_ext
:
5817 unsigned int constant
;
5819 READ_ULEB (constant
, curr
, end
);
5821 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5822 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5832 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5833 filename and dirname corresponding to file name table entry with index
5834 FILEIDX. Return NULL on failure. */
5836 static unsigned char *
5837 get_line_filename_and_dirname (dwarf_vma line_offset
,
5839 unsigned char **dir_name
)
5841 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5842 unsigned char *hdrptr
, *dirtable
, *file_name
;
5843 unsigned int offset_size
, initial_length_size
;
5844 unsigned int version
, opcode_base
;
5845 dwarf_vma length
, diridx
;
5846 const unsigned char * end
;
5849 if (section
->start
== NULL
5850 || line_offset
>= section
->size
5854 hdrptr
= section
->start
+ line_offset
;
5855 end
= section
->start
+ section
->size
;
5857 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5858 if (length
== 0xffffffff)
5860 /* This section is 64-bit DWARF 3. */
5861 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5863 initial_length_size
= 12;
5868 initial_length_size
= 4;
5870 if (length
+ initial_length_size
< length
5871 || length
+ initial_length_size
> section
->size
)
5874 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5875 if (version
!= 2 && version
!= 3 && version
!= 4)
5877 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5879 hdrptr
++; /* Skip max_ops_per_insn. */
5880 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5882 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5883 if (opcode_base
== 0)
5886 hdrptr
+= opcode_base
- 1;
5891 /* Skip over dirname table. */
5892 while (*hdrptr
!= '\0')
5894 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5898 hdrptr
++; /* Skip the NUL at the end of the table. */
5900 /* Now skip over preceding filename table entries. */
5901 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5903 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5904 SKIP_ULEB (hdrptr
, end
);
5905 SKIP_ULEB (hdrptr
, end
);
5906 SKIP_ULEB (hdrptr
, end
);
5908 if (hdrptr
>= end
|| *hdrptr
== '\0')
5912 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5915 READ_ULEB (diridx
, hdrptr
, end
);
5918 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5919 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5920 if (dirtable
>= end
|| *dirtable
== '\0')
5922 *dir_name
= dirtable
;
5927 display_debug_macro (struct dwarf_section
*section
,
5930 unsigned char *start
= section
->start
;
5931 unsigned char *end
= start
+ section
->size
;
5932 unsigned char *curr
= start
;
5933 unsigned char *extended_op_buf
[256];
5934 bool is_dwo
= false;
5935 const char *suffix
= strrchr (section
->name
, '.');
5937 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5940 load_debug_section_with_follow (str
, file
);
5941 load_debug_section_with_follow (line
, file
);
5942 load_debug_section_with_follow (str_index
, file
);
5944 introduce (section
, false);
5948 unsigned int lineno
, version
, flags
;
5949 unsigned int offset_size
;
5950 const unsigned char *string
;
5951 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5952 unsigned char **extended_ops
= NULL
;
5954 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5955 if (version
!= 4 && version
!= 5)
5957 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
5958 section
->name
, version
);
5962 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5963 offset_size
= (flags
& 1) ? 8 : 4;
5964 printf (_(" Offset: 0x%lx\n"),
5965 (unsigned long) sec_offset
);
5966 printf (_(" Version: %d\n"), version
);
5967 printf (_(" Offset size: %d\n"), offset_size
);
5970 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5971 printf (_(" Offset into .debug_line: 0x%lx\n"),
5972 (unsigned long) line_offset
);
5976 unsigned int i
, count
, op
;
5979 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5981 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5982 extended_ops
= extended_op_buf
;
5985 printf (_(" Extension opcode arguments:\n"));
5986 for (i
= 0; i
< count
; i
++)
5988 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5989 extended_ops
[op
] = curr
;
5990 READ_ULEB (nargs
, curr
, end
);
5992 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5995 printf (_(" DW_MACRO_%02x arguments: "), op
);
5996 for (n
= 0; n
< nargs
; n
++)
6000 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6001 printf ("%s%s", get_FORM_name (form
),
6002 n
== nargs
- 1 ? "\n" : ", ");
6012 case DW_FORM_block1
:
6013 case DW_FORM_block2
:
6014 case DW_FORM_block4
:
6016 case DW_FORM_string
:
6018 case DW_FORM_sec_offset
:
6021 error (_("Invalid extension opcode form %s\n"),
6022 get_FORM_name (form
));
6038 error (_(".debug_macro section not zero terminated\n"));
6042 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6048 case DW_MACRO_define
:
6049 READ_ULEB (lineno
, curr
, end
);
6051 curr
+= strnlen ((char *) string
, end
- string
) + 1;
6052 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
6056 case DW_MACRO_undef
:
6057 READ_ULEB (lineno
, curr
, end
);
6059 curr
+= strnlen ((char *) string
, end
- string
) + 1;
6060 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
6064 case DW_MACRO_start_file
:
6066 unsigned int filenum
;
6067 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6069 READ_ULEB (lineno
, curr
, end
);
6070 READ_ULEB (filenum
, curr
, end
);
6072 if ((flags
& 2) == 0)
6073 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6076 = get_line_filename_and_dirname (line_offset
, filenum
,
6078 if (file_name
== NULL
)
6079 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6082 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6084 dir_name
!= NULL
? (const char *) dir_name
: "",
6085 dir_name
!= NULL
? "/" : "", file_name
);
6089 case DW_MACRO_end_file
:
6090 printf (_(" DW_MACRO_end_file\n"));
6093 case DW_MACRO_define_strp
:
6094 READ_ULEB (lineno
, curr
, end
);
6095 if (version
== 4 && is_dwo
)
6096 READ_ULEB (offset
, curr
, end
);
6098 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6099 string
= fetch_indirect_string (offset
);
6100 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6104 case DW_MACRO_undef_strp
:
6105 READ_ULEB (lineno
, curr
, end
);
6106 if (version
== 4 && is_dwo
)
6107 READ_ULEB (offset
, curr
, end
);
6109 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6110 string
= fetch_indirect_string (offset
);
6111 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6115 case DW_MACRO_import
:
6116 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6117 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6118 (unsigned long) offset
);
6121 case DW_MACRO_define_sup
:
6122 READ_ULEB (lineno
, curr
, end
);
6123 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6124 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6125 lineno
, (unsigned long) offset
);
6128 case DW_MACRO_undef_sup
:
6129 READ_ULEB (lineno
, curr
, end
);
6130 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6131 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6132 lineno
, (unsigned long) offset
);
6135 case DW_MACRO_import_sup
:
6136 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6137 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6138 (unsigned long) offset
);
6141 case DW_MACRO_define_strx
:
6142 case DW_MACRO_undef_strx
:
6143 READ_ULEB (lineno
, curr
, end
);
6144 READ_ULEB (offset
, curr
, end
);
6145 string
= (const unsigned char *)
6146 fetch_indexed_string (offset
, NULL
, offset_size
, false);
6147 if (op
== DW_MACRO_define_strx
)
6148 printf (" DW_MACRO_define_strx ");
6150 printf (" DW_MACRO_undef_strx ");
6152 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6153 printf (_("lineno : %d macro : %s\n"),
6158 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6160 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6164 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6166 error (_(" Unknown macro opcode %02x seen\n"), op
);
6171 /* Skip over unhandled opcodes. */
6173 unsigned char *desc
= extended_ops
[op
];
6174 READ_ULEB (nargs
, desc
, end
);
6177 printf (_(" DW_MACRO_%02x\n"), op
);
6180 printf (_(" DW_MACRO_%02x -"), op
);
6181 for (n
= 0; n
< nargs
; n
++)
6185 /* DW_FORM_implicit_const is not expected here. */
6186 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6188 = read_and_display_attr_value (0, val
, 0,
6189 start
, curr
, end
, 0, 0, offset_size
,
6190 version
, NULL
, 0, NULL
,
6208 display_debug_abbrev (struct dwarf_section
*section
,
6209 void *file ATTRIBUTE_UNUSED
)
6211 abbrev_entry
*entry
;
6212 unsigned char *start
= section
->start
;
6214 introduce (section
, false);
6221 offset
= start
- section
->start
;
6222 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6225 list
= new_abbrev_list (0, offset
);
6226 start
= process_abbrev_set (section
, 0, section
->size
, offset
, list
);
6227 list
->start_of_next_abbrevs
= start
;
6230 start
= list
->start_of_next_abbrevs
;
6232 if (list
->first_abbrev
== NULL
)
6235 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6237 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6241 printf (" %ld %s [%s]\n",
6243 get_TAG_name (entry
->tag
),
6244 entry
->children
? _("has children") : _("no children"));
6246 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6248 printf (" %-18s %s",
6249 get_AT_name (attr
->attribute
),
6250 get_FORM_name (attr
->form
));
6251 if (attr
->form
== DW_FORM_implicit_const
)
6252 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
6264 /* Return true when ADDR is the maximum address, when addresses are
6265 POINTER_SIZE bytes long. */
6268 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6270 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6271 return ((addr
& mask
) == mask
);
6274 /* Display a view pair list starting at *VSTART_PTR and ending at
6275 VLISTEND within SECTION. */
6278 display_view_pair_list (struct dwarf_section
*section
,
6279 unsigned char **vstart_ptr
,
6280 unsigned int debug_info_entry
,
6281 unsigned char *vlistend
)
6283 unsigned char *vstart
= *vstart_ptr
;
6284 unsigned char *section_end
= section
->start
+ section
->size
;
6285 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6287 if (vlistend
< section_end
)
6288 section_end
= vlistend
;
6292 while (vstart
< section_end
)
6294 dwarf_vma off
= vstart
- section
->start
;
6295 dwarf_vma vbegin
, vend
;
6297 READ_ULEB (vbegin
, vstart
, section_end
);
6298 if (vstart
== section_end
)
6301 READ_ULEB (vend
, vstart
, section_end
);
6302 printf (" %8.8lx ", (unsigned long) off
);
6304 print_dwarf_view (vbegin
, pointer_size
, 1);
6305 print_dwarf_view (vend
, pointer_size
, 1);
6306 printf (_("location view pair\n"));
6310 *vstart_ptr
= vstart
;
6313 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6316 display_loc_list (struct dwarf_section
*section
,
6317 unsigned char **start_ptr
,
6318 unsigned int debug_info_entry
,
6320 dwarf_vma base_address
,
6321 unsigned char **vstart_ptr
,
6324 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6325 unsigned char *section_end
= section
->start
+ section
->size
;
6326 unsigned long cu_offset
;
6327 unsigned int pointer_size
;
6328 unsigned int offset_size
;
6333 unsigned short length
;
6334 int need_frame_base
;
6336 if (debug_info_entry
>= num_debug_info_entries
)
6338 warn (_("No debug information available for loc lists of entry: %u\n"),
6343 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6344 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6345 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6346 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6348 if (pointer_size
< 2 || pointer_size
> 8)
6350 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6351 pointer_size
, debug_info_entry
);
6357 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6358 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6360 if (start
+ 2 * pointer_size
> section_end
)
6362 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6363 (unsigned long) offset
);
6367 printf (" %8.8lx ", (unsigned long) off
);
6369 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6370 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6372 if (begin
== 0 && end
== 0)
6374 /* PR 18374: In a object file we can have a location list that
6375 starts with a begin and end of 0 because there are relocations
6376 that need to be applied to the addresses. Actually applying
6377 the relocations now does not help as they will probably resolve
6378 to 0, since the object file has not been fully linked. Real
6379 end of list markers will not have any relocations against them. */
6380 if (! reloc_at (section
, off
)
6381 && ! reloc_at (section
, off
+ pointer_size
))
6383 printf (_("<End of list>\n"));
6388 /* Check base address specifiers. */
6389 if (is_max_address (begin
, pointer_size
)
6390 && !is_max_address (end
, pointer_size
))
6393 print_dwarf_vma (begin
, pointer_size
);
6394 print_dwarf_vma (end
, pointer_size
);
6395 printf (_("(base address)\n"));
6401 off
= offset
+ (vstart
- *start_ptr
);
6403 READ_ULEB (vbegin
, vstart
, section_end
);
6404 print_dwarf_view (vbegin
, pointer_size
, 1);
6406 READ_ULEB (vend
, vstart
, section_end
);
6407 print_dwarf_view (vend
, pointer_size
, 1);
6409 printf (_("views at %8.8lx for:\n %*s "),
6410 (unsigned long) off
, 8, "");
6413 if (start
+ 2 > section_end
)
6415 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6416 (unsigned long) offset
);
6420 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6422 if (start
+ length
> section_end
)
6424 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6425 (unsigned long) offset
);
6429 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6430 print_dwarf_vma (end
+ base_address
, pointer_size
);
6433 need_frame_base
= decode_location_expression (start
,
6438 cu_offset
, section
);
6441 if (need_frame_base
&& !has_frame_base
)
6442 printf (_(" [without DW_AT_frame_base]"));
6444 if (begin
== end
&& vbegin
== vend
)
6445 fputs (_(" (start == end)"), stdout
);
6446 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6447 fputs (_(" (start > end)"), stdout
);
6455 *vstart_ptr
= vstart
;
6458 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6461 display_loclists_list (struct dwarf_section
*section
,
6462 unsigned char **start_ptr
,
6463 unsigned int debug_info_entry
,
6465 dwarf_vma base_address
,
6466 unsigned char **vstart_ptr
,
6469 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6470 unsigned char *section_end
= section
->start
+ section
->size
;
6471 unsigned long cu_offset
;
6472 unsigned int pointer_size
;
6473 unsigned int offset_size
;
6476 /* Initialize it due to a false compiler warning. */
6477 dwarf_vma begin
= -1, vbegin
= -1;
6478 dwarf_vma end
= -1, vend
= -1;
6480 int need_frame_base
;
6482 if (debug_info_entry
>= num_debug_info_entries
)
6484 warn (_("No debug information available for "
6485 "loclists lists of entry: %u\n"),
6490 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6491 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6492 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6493 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6495 if (pointer_size
< 2 || pointer_size
> 8)
6497 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6498 pointer_size
, debug_info_entry
);
6504 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6505 enum dwarf_location_list_entry_type llet
;
6507 if (start
+ 1 > section_end
)
6509 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6510 (unsigned long) offset
);
6514 printf (" %8.8lx ", (unsigned long) off
);
6516 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6518 if (vstart
&& (llet
== DW_LLE_offset_pair
6519 || llet
== DW_LLE_start_end
6520 || llet
== DW_LLE_start_length
))
6522 off
= offset
+ (vstart
- *start_ptr
);
6524 READ_ULEB (vbegin
, vstart
, section_end
);
6525 print_dwarf_view (vbegin
, pointer_size
, 1);
6527 READ_ULEB (vend
, vstart
, section_end
);
6528 print_dwarf_view (vend
, pointer_size
, 1);
6530 printf (_("views at %8.8lx for:\n %*s "),
6531 (unsigned long) off
, 8, "");
6536 case DW_LLE_end_of_list
:
6537 printf (_("<End of list>\n"));
6539 case DW_LLE_offset_pair
:
6540 READ_ULEB (begin
, start
, section_end
);
6541 begin
+= base_address
;
6542 READ_ULEB (end
, start
, section_end
);
6543 end
+= base_address
;
6545 case DW_LLE_start_end
:
6546 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6547 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6549 case DW_LLE_start_length
:
6550 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6551 READ_ULEB (end
, start
, section_end
);
6554 case DW_LLE_base_address
:
6555 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6557 print_dwarf_vma (base_address
, pointer_size
);
6558 printf (_("(base address)\n"));
6560 #ifdef DW_LLE_view_pair
6561 case DW_LLE_view_pair
:
6563 printf (_("View pair entry in loclist with locviews attribute\n"));
6564 READ_ULEB (vbegin
, start
, section_end
);
6565 print_dwarf_view (vbegin
, pointer_size
, 1);
6567 READ_ULEB (vend
, start
, section_end
);
6568 print_dwarf_view (vend
, pointer_size
, 1);
6570 printf (_("views for:\n"));
6574 error (_("Invalid location list entry type %d\n"), llet
);
6577 if (llet
== DW_LLE_end_of_list
)
6579 if (llet
!= DW_LLE_offset_pair
6580 && llet
!= DW_LLE_start_end
6581 && llet
!= DW_LLE_start_length
)
6584 if (start
+ 2 > section_end
)
6586 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6587 (unsigned long) offset
);
6591 READ_ULEB (length
, start
, section_end
);
6593 print_dwarf_vma (begin
, pointer_size
);
6594 print_dwarf_vma (end
, pointer_size
);
6597 need_frame_base
= decode_location_expression (start
,
6602 cu_offset
, section
);
6605 if (need_frame_base
&& !has_frame_base
)
6606 printf (_(" [without DW_AT_frame_base]"));
6608 if (begin
== end
&& vbegin
== vend
)
6609 fputs (_(" (start == end)"), stdout
);
6610 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6611 fputs (_(" (start > end)"), stdout
);
6619 if (vbegin
!= vm1
|| vend
!= vm1
)
6620 printf (_("Trailing view pair not used in a range"));
6623 *vstart_ptr
= vstart
;
6626 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6627 right-adjusted in a field of length LEN, and followed by a space. */
6630 print_addr_index (unsigned int idx
, unsigned int len
)
6632 static char buf
[15];
6633 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6634 printf ("%*s ", len
, buf
);
6637 /* Display a location list from a .dwo section. It uses address indexes rather
6638 than embedded addresses. This code closely follows display_loc_list, but the
6639 two are sufficiently different that combining things is very ugly. */
6642 display_loc_list_dwo (struct dwarf_section
*section
,
6643 unsigned char **start_ptr
,
6644 unsigned int debug_info_entry
,
6646 unsigned char **vstart_ptr
,
6649 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6650 unsigned char *section_end
= section
->start
+ section
->size
;
6651 unsigned long cu_offset
;
6652 unsigned int pointer_size
;
6653 unsigned int offset_size
;
6656 unsigned short length
;
6657 int need_frame_base
;
6660 if (debug_info_entry
>= num_debug_info_entries
)
6662 warn (_("No debug information for loc lists of entry: %u\n"),
6667 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6668 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6669 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6670 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6672 if (pointer_size
< 2 || pointer_size
> 8)
6674 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6675 pointer_size
, debug_info_entry
);
6681 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6683 if (start
>= section_end
)
6685 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6686 (unsigned long) offset
);
6690 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6703 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6705 READ_ULEB (view
, vstart
, section_end
);
6706 print_dwarf_view (view
, 8, 1);
6708 READ_ULEB (view
, vstart
, section_end
);
6709 print_dwarf_view (view
, 8, 1);
6711 printf (_("views at %8.8lx for:\n %*s "),
6712 (unsigned long) off
, 8, "");
6720 case 0: /* A terminating entry. */
6722 *vstart_ptr
= vstart
;
6723 printf (_("<End of list>\n"));
6725 case 1: /* A base-address entry. */
6726 READ_ULEB (idx
, start
, section_end
);
6727 print_addr_index (idx
, 8);
6728 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6729 printf (_("(base address selection entry)\n"));
6731 case 2: /* A start/end entry. */
6732 READ_ULEB (idx
, start
, section_end
);
6733 print_addr_index (idx
, 8);
6734 READ_ULEB (idx
, start
, section_end
);
6735 print_addr_index (idx
, 8);
6737 case 3: /* A start/length entry. */
6738 READ_ULEB (idx
, start
, section_end
);
6739 print_addr_index (idx
, 8);
6740 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6741 printf ("%08x ", idx
);
6743 case 4: /* An offset pair entry. */
6744 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6745 printf ("%08x ", idx
);
6746 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6747 printf ("%08x ", idx
);
6750 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6752 *vstart_ptr
= vstart
;
6756 if (start
+ 2 > section_end
)
6758 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6759 (unsigned long) offset
);
6763 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6764 if (start
+ length
> section_end
)
6766 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6767 (unsigned long) offset
);
6772 need_frame_base
= decode_location_expression (start
,
6777 cu_offset
, section
);
6780 if (need_frame_base
&& !has_frame_base
)
6781 printf (_(" [without DW_AT_frame_base]"));
6789 *vstart_ptr
= vstart
;
6792 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6795 static dwarf_vma
*loc_offsets
, *loc_views
;
6798 loc_offsets_compar (const void *ap
, const void *bp
)
6800 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6801 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6803 int ret
= (a
> b
) - (b
> a
);
6807 a
= loc_views
[*(const unsigned int *) ap
];
6808 b
= loc_views
[*(const unsigned int *) bp
];
6810 ret
= (a
> b
) - (b
> a
);
6816 display_debug_loc (struct dwarf_section
*section
, void *file
)
6818 unsigned char *start
= section
->start
, *vstart
= NULL
;
6819 unsigned long bytes
;
6820 unsigned char *section_begin
= start
;
6821 unsigned int num_loc_list
= 0;
6822 unsigned long last_offset
= 0;
6823 unsigned long last_view
= 0;
6824 unsigned int first
= 0;
6827 int seen_first_offset
= 0;
6828 int locs_sorted
= 1;
6829 unsigned char *next
= start
, *vnext
= vstart
;
6830 unsigned int *array
= NULL
;
6831 const char *suffix
= strrchr (section
->name
, '.');
6832 bool is_dwo
= false;
6833 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6834 dwarf_vma expected_start
= 0;
6836 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6839 bytes
= section
->size
;
6843 printf (_("\nThe %s section is empty.\n"), section
->name
);
6849 unsigned char *hdrptr
= section_begin
;
6850 dwarf_vma ll_length
;
6851 unsigned short ll_version
;
6852 unsigned char *end
= section_begin
+ section
->size
;
6853 unsigned char address_size
, segment_selector_size
;
6854 uint32_t offset_entry_count
;
6856 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6857 if (ll_length
== 0xffffffff)
6858 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6860 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6861 if (ll_version
!= 5)
6863 warn (_("The %s section contains corrupt or "
6864 "unsupported version number: %d.\n"),
6865 section
->name
, ll_version
);
6869 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6871 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6872 if (segment_selector_size
!= 0)
6874 warn (_("The %s section contains "
6875 "unsupported segment selector size: %d.\n"),
6876 section
->name
, segment_selector_size
);
6880 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6881 if (offset_entry_count
!= 0)
6883 warn (_("The %s section contains "
6884 "unsupported offset entry count: %d.\n"),
6885 section
->name
, offset_entry_count
);
6889 expected_start
= hdrptr
- section_begin
;
6892 if (load_debug_info (file
) == 0)
6894 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6899 /* Check the order of location list in .debug_info section. If
6900 offsets of location lists are in the ascending order, we can
6901 use `debug_information' directly. */
6902 for (i
= 0; i
< num_debug_info_entries
; i
++)
6906 num
= debug_information
[i
].num_loc_offsets
;
6907 if (num
> num_loc_list
)
6910 /* Check if we can use `debug_information' directly. */
6911 if (locs_sorted
&& num
!= 0)
6913 if (!seen_first_offset
)
6915 /* This is the first location list. */
6916 last_offset
= debug_information
[i
].loc_offsets
[0];
6917 last_view
= debug_information
[i
].loc_views
[0];
6919 seen_first_offset
= 1;
6925 for (; j
< num
; j
++)
6928 debug_information
[i
].loc_offsets
[j
]
6929 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6930 && last_view
> debug_information
[i
].loc_views
[j
]))
6935 last_offset
= debug_information
[i
].loc_offsets
[j
];
6936 last_view
= debug_information
[i
].loc_views
[j
];
6941 if (!seen_first_offset
)
6942 error (_("No location lists in .debug_info section!\n"));
6944 if (debug_information
[first
].num_loc_offsets
> 0
6945 && debug_information
[first
].loc_offsets
[0] != expected_start
6946 && debug_information
[first
].loc_views
[0] != expected_start
)
6947 warn (_("Location lists in %s section start at 0x%s\n"),
6949 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6952 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6954 introduce (section
, false);
6956 if (reloc_at (section
, 0))
6957 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6959 printf (_(" Offset Begin End Expression\n"));
6961 seen_first_offset
= 0;
6962 for (i
= first
; i
< num_debug_info_entries
; i
++)
6964 dwarf_vma offset
, voffset
;
6965 dwarf_vma base_address
;
6971 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6973 loc_offsets
= debug_information
[i
].loc_offsets
;
6974 loc_views
= debug_information
[i
].loc_views
;
6975 qsort (array
, debug_information
[i
].num_loc_offsets
,
6976 sizeof (*array
), loc_offsets_compar
);
6979 int adjacent_view_loclists
= 1;
6980 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6982 j
= locs_sorted
? k
: array
[k
];
6984 && (debug_information
[i
].loc_offsets
[locs_sorted
6985 ? k
- 1 : array
[k
- 1]]
6986 == debug_information
[i
].loc_offsets
[j
])
6987 && (debug_information
[i
].loc_views
[locs_sorted
6988 ? k
- 1 : array
[k
- 1]]
6989 == debug_information
[i
].loc_views
[j
]))
6991 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6992 offset
= debug_information
[i
].loc_offsets
[j
];
6993 next
= section_begin
+ offset
;
6994 voffset
= debug_information
[i
].loc_views
[j
];
6996 vnext
= section_begin
+ voffset
;
6999 base_address
= debug_information
[i
].base_address
;
7001 if (vnext
&& vnext
< next
)
7004 display_view_pair_list (section
, &vstart
, i
, next
);
7009 if (!seen_first_offset
|| !adjacent_view_loclists
)
7010 seen_first_offset
= 1;
7014 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
7015 (unsigned long) (start
- section_begin
),
7016 (unsigned long) offset
);
7017 else if (start
> next
)
7018 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
7019 (unsigned long) (start
- section_begin
),
7020 (unsigned long) offset
);
7025 if (offset
>= bytes
)
7027 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
7028 (unsigned long) offset
);
7032 if (vnext
&& voffset
>= bytes
)
7034 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
7035 (unsigned long) voffset
);
7042 display_loc_list_dwo (section
, &start
, i
, offset
,
7043 &vstart
, has_frame_base
);
7045 display_loc_list (section
, &start
, i
, offset
, base_address
,
7046 &vstart
, has_frame_base
);
7051 warn (_("DWO is not yet supported.\n"));
7053 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7054 &vstart
, has_frame_base
);
7057 /* FIXME: this arrangement is quite simplistic. Nothing
7058 requires locview lists to be adjacent to corresponding
7059 loclists, and a single loclist could be augmented by
7060 different locview lists, and vice-versa, unlikely as it
7061 is that it would make sense to do so. Hopefully we'll
7062 have view pair support built into loclists before we ever
7063 need to address all these possibilities. */
7064 if (adjacent_view_loclists
&& vnext
7065 && vnext
!= start
&& vstart
!= next
)
7067 adjacent_view_loclists
= 0;
7068 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7071 if (vnext
&& vnext
== start
)
7072 display_view_pair_list (section
, &start
, i
, vstart
);
7076 if (start
< section
->start
+ section
->size
)
7077 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7078 "There are %ld unused bytes at the end of section %s\n",
7079 (long) (section
->start
+ section
->size
- start
)),
7080 (long) (section
->start
+ section
->size
- start
), section
->name
);
7087 display_debug_str (struct dwarf_section
*section
,
7088 void *file ATTRIBUTE_UNUSED
)
7090 unsigned char *start
= section
->start
;
7091 unsigned long bytes
= section
->size
;
7092 dwarf_vma addr
= section
->address
;
7096 printf (_("\nThe %s section is empty.\n"), section
->name
);
7100 introduce (section
, false);
7108 lbytes
= (bytes
> 16 ? 16 : bytes
);
7110 printf (" 0x%8.8lx ", (unsigned long) addr
);
7112 for (j
= 0; j
< 16; j
++)
7115 printf ("%2.2x", start
[j
]);
7123 for (j
= 0; j
< lbytes
; j
++)
7126 if (k
>= ' ' && k
< 0x80)
7145 display_debug_info (struct dwarf_section
*section
, void *file
)
7147 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7151 display_debug_types (struct dwarf_section
*section
, void *file
)
7153 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7157 display_trace_info (struct dwarf_section
*section
, void *file
)
7159 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7163 display_debug_aranges (struct dwarf_section
*section
,
7164 void *file ATTRIBUTE_UNUSED
)
7166 unsigned char *start
= section
->start
;
7167 unsigned char *end
= start
+ section
->size
;
7169 introduce (section
, false);
7171 /* It does not matter if this load fails,
7172 we test for that later on. */
7173 load_debug_info (file
);
7177 unsigned char *hdrptr
;
7178 DWARF2_Internal_ARange arange
;
7179 unsigned char *addr_ranges
;
7182 unsigned long sec_off
;
7183 unsigned char address_size
;
7185 unsigned int offset_size
;
7186 unsigned int initial_length_size
;
7190 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7191 if (arange
.ar_length
== 0xffffffff)
7193 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7195 initial_length_size
= 12;
7200 initial_length_size
= 4;
7203 sec_off
= hdrptr
- section
->start
;
7204 if (sec_off
+ arange
.ar_length
< sec_off
7205 || sec_off
+ arange
.ar_length
> section
->size
)
7207 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7209 sec_off
- initial_length_size
,
7210 dwarf_vmatoa ("x", arange
.ar_length
));
7214 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
7215 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
7217 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7218 && num_debug_info_entries
> 0
7219 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7220 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7221 (unsigned long) arange
.ar_info_offset
, section
->name
);
7223 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
7224 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
7226 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7228 /* PR 19872: A version number of 0 probably means that there is
7229 padding at the end of the .debug_aranges section. Gold puts
7230 it there when performing an incremental link, for example.
7231 So do not generate a warning in this case. */
7232 if (arange
.ar_version
)
7233 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7237 printf (_(" Length: %ld\n"),
7238 (long) arange
.ar_length
);
7239 printf (_(" Version: %d\n"), arange
.ar_version
);
7240 printf (_(" Offset into .debug_info: 0x%lx\n"),
7241 (unsigned long) arange
.ar_info_offset
);
7242 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7243 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7245 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7247 /* PR 17512: file: 001-108546-0.001:0.1. */
7248 if (address_size
== 0 || address_size
> 8)
7250 error (_("Invalid address size in %s section!\n"),
7255 /* The DWARF spec does not require that the address size be a power
7256 of two, but we do. This will have to change if we ever encounter
7257 an uneven architecture. */
7258 if ((address_size
& (address_size
- 1)) != 0)
7260 warn (_("Pointer size + Segment size is not a power of two.\n"));
7264 if (address_size
> 4)
7265 printf (_("\n Address Length\n"));
7267 printf (_("\n Address Length\n"));
7269 addr_ranges
= hdrptr
;
7271 /* Must pad to an alignment boundary that is twice the address size. */
7272 excess
= (hdrptr
- start
) % (2 * address_size
);
7274 addr_ranges
+= (2 * address_size
) - excess
;
7276 start
+= arange
.ar_length
+ initial_length_size
;
7278 while (addr_ranges
+ 2 * address_size
<= start
)
7280 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
7281 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
7284 print_dwarf_vma (address
, address_size
);
7285 print_dwarf_vma (length
, address_size
);
7295 /* Comparison function for qsort. */
7297 comp_addr_base (const void * v0
, const void * v1
)
7299 debug_info
*info0
= *(debug_info
**) v0
;
7300 debug_info
*info1
= *(debug_info
**) v1
;
7301 return info0
->addr_base
- info1
->addr_base
;
7304 /* Display the debug_addr section. */
7306 display_debug_addr (struct dwarf_section
*section
,
7309 debug_info
**debug_addr_info
;
7310 unsigned char *entry
;
7314 unsigned char * header
;
7316 if (section
->size
== 0)
7318 printf (_("\nThe %s section is empty.\n"), section
->name
);
7322 if (load_debug_info (file
) == 0)
7324 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7329 introduce (section
, false);
7331 /* PR 17531: file: cf38d01b.
7332 We use xcalloc because a corrupt file may not have initialised all of the
7333 fields in the debug_info structure, which means that the sort below might
7334 try to move uninitialised data. */
7335 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7336 sizeof (debug_info
*));
7339 for (i
= 0; i
< num_debug_info_entries
; i
++)
7340 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7342 /* PR 17531: file: cf38d01b. */
7343 if (debug_information
[i
].addr_base
>= section
->size
)
7344 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7345 (unsigned long) debug_information
[i
].addr_base
, i
);
7347 debug_addr_info
[count
++] = debug_information
+ i
;
7350 /* Add a sentinel to make iteration convenient. */
7351 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7352 debug_addr_info
[count
]->addr_base
= section
->size
;
7353 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7355 header
= section
->start
;
7356 for (i
= 0; i
< count
; i
++)
7359 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7361 printf (_(" For compilation unit at offset 0x%s:\n"),
7362 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7364 printf (_("\tIndex\tAddress\n"));
7365 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7366 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7368 size_t header_size
= entry
- header
;
7369 unsigned char * curr_header
= header
;
7372 int segment_selector_size
;
7374 if (header_size
!= 8 && header_size
!= 16)
7376 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %ld instead\n"),
7377 section
->name
, (long) header_size
);
7381 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7382 if (length
== 0xffffffff)
7383 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7384 end
= curr_header
+ length
;
7386 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7388 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7389 section
->name
, version
);
7391 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7392 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7393 address_size
+= segment_selector_size
;
7396 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7401 dwarf_vma base
= byte_get (entry
, address_size
);
7402 printf (_("\t%d:\t"), idx
);
7403 print_dwarf_vma (base
, address_size
);
7405 entry
+= address_size
;
7411 free (debug_addr_info
);
7415 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7418 display_debug_str_offsets (struct dwarf_section
*section
,
7419 void *file ATTRIBUTE_UNUSED
)
7423 if (section
->size
== 0)
7425 printf (_("\nThe %s section is empty.\n"), section
->name
);
7429 unsigned char *start
= section
->start
;
7430 unsigned char *end
= start
+ section
->size
;
7431 unsigned char *curr
= start
;
7433 const char *suffix
= strrchr (section
->name
, '.');
7434 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7437 load_debug_section_with_follow (str_dwo
, file
);
7439 load_debug_section_with_follow (str
, file
);
7441 introduce (section
, false);
7446 dwarf_vma entry_length
;
7448 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7449 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7450 if (length
== 0xffffffff)
7452 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7458 unsigned char *entries_end
;
7461 /* This is probably an old style .debug_str_offset section which
7462 just contains offsets and no header (and the first offset is 0). */
7463 length
= section
->size
;
7464 curr
= section
->start
;
7467 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7468 printf (_(" Index Offset [String]\n"));
7472 if (length
<= (dwarf_vma
) (end
- curr
))
7473 entries_end
= curr
+ length
;
7476 warn (_("Section %s is too small %#lx\n"),
7477 section
->name
, (unsigned long) section
->size
);
7482 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
7484 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7487 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
7489 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7491 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7492 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7493 printf (_(" Index Offset [String]\n"));
7496 for (idx
= 0; curr
< entries_end
; idx
++)
7499 const unsigned char * string
;
7501 if ((dwarf_vma
) (entries_end
- curr
) < entry_length
)
7502 /* Not enough space to read one entry_length, give up. */
7505 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7507 string
= (const unsigned char *)
7508 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7510 string
= fetch_indirect_string (offset
);
7512 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7520 /* Each debug_information[x].range_lists[y] gets this representation for
7521 sorting purposes. */
7525 /* The debug_information[x].range_lists[y] value. */
7526 dwarf_vma ranges_offset
;
7528 /* Original debug_information to find parameters of the data. */
7529 debug_info
*debug_info_p
;
7532 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7535 range_entry_compar (const void *ap
, const void *bp
)
7537 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7538 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7539 const dwarf_vma a
= a_re
->ranges_offset
;
7540 const dwarf_vma b
= b_re
->ranges_offset
;
7542 return (a
> b
) - (b
> a
);
7546 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7547 unsigned int pointer_size
, unsigned long offset
,
7548 unsigned long base_address
)
7550 while (start
< finish
)
7555 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7556 if (start
>= finish
)
7558 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7560 printf (" %8.8lx ", offset
);
7562 if (begin
== 0 && end
== 0)
7564 printf (_("<End of list>\n"));
7568 /* Check base address specifiers. */
7569 if (is_max_address (begin
, pointer_size
)
7570 && !is_max_address (end
, pointer_size
))
7573 print_dwarf_vma (begin
, pointer_size
);
7574 print_dwarf_vma (end
, pointer_size
);
7575 printf ("(base address)\n");
7579 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7580 print_dwarf_vma (end
+ base_address
, pointer_size
);
7583 fputs (_("(start == end)"), stdout
);
7584 else if (begin
> end
)
7585 fputs (_("(start > end)"), stdout
);
7592 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7593 unsigned int pointer_size
, unsigned long offset
,
7594 unsigned long base_address
)
7596 unsigned char *next
= start
;
7600 unsigned long off
= offset
+ (start
- next
);
7601 enum dwarf_range_list_entry rlet
;
7602 /* Initialize it due to a false compiler warning. */
7603 dwarf_vma begin
= -1, length
, end
= -1;
7605 if (start
+ 1 > finish
)
7607 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7612 printf (" %8.8lx ", off
);
7614 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7618 case DW_RLE_end_of_list
:
7619 printf (_("<End of list>\n"));
7621 case DW_RLE_base_address
:
7622 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7623 print_dwarf_vma (base_address
, pointer_size
);
7624 printf (_("(base address)\n"));
7626 case DW_RLE_start_length
:
7627 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7628 READ_ULEB (length
, start
, finish
);
7629 end
= begin
+ length
;
7631 case DW_RLE_offset_pair
:
7632 READ_ULEB (begin
, start
, finish
);
7633 READ_ULEB (end
, start
, finish
);
7635 case DW_RLE_start_end
:
7636 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7637 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7640 error (_("Invalid range list entry type %d\n"), rlet
);
7641 rlet
= DW_RLE_end_of_list
;
7644 if (rlet
== DW_RLE_end_of_list
)
7646 if (rlet
== DW_RLE_base_address
)
7649 /* Only a DW_RLE_offset_pair needs the base address added. */
7650 if (rlet
== DW_RLE_offset_pair
)
7652 begin
+= base_address
;
7653 end
+= base_address
;
7656 print_dwarf_vma (begin
, pointer_size
);
7657 print_dwarf_vma (end
, pointer_size
);
7660 fputs (_("(start == end)"), stdout
);
7661 else if (begin
> end
)
7662 fputs (_("(start > end)"), stdout
);
7669 display_debug_ranges (struct dwarf_section
*section
,
7670 void *file ATTRIBUTE_UNUSED
)
7672 unsigned char *start
= section
->start
;
7673 unsigned char *last_start
= start
;
7674 unsigned long bytes
= section
->size
;
7675 unsigned char *section_begin
= start
;
7676 unsigned char *finish
= start
+ bytes
;
7677 unsigned int num_range_list
, i
;
7678 struct range_entry
*range_entries
, *range_entry_fill
;
7679 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7680 /* Initialize it due to a false compiler warning. */
7681 unsigned char address_size
= 0;
7682 dwarf_vma last_offset
= 0;
7686 printf (_("\nThe %s section is empty.\n"), section
->name
);
7692 dwarf_vma initial_length
;
7693 unsigned int initial_length_size
;
7694 unsigned char segment_selector_size
;
7695 unsigned int offset_size
, offset_entry_count
;
7696 unsigned short version
;
7698 /* Get and check the length of the block. */
7699 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7701 if (initial_length
== 0xffffffff)
7703 /* This section is 64-bit DWARF 3. */
7704 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7706 initial_length_size
= 12;
7711 initial_length_size
= 4;
7714 if (initial_length
+ initial_length_size
> section
->size
)
7716 /* If the length field has a relocation against it, then we should
7717 not complain if it is inaccurate (and probably negative).
7718 It is copied from .debug_line handling code. */
7719 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7721 initial_length
= (finish
- start
) - initial_length_size
;
7725 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7726 (long) initial_length
);
7731 /* Get and check the version number. */
7732 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7736 warn (_("Only DWARF version 5 debug_rnglists info "
7737 "is currently supported.\n"));
7741 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7743 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7744 if (segment_selector_size
!= 0)
7746 warn (_("The %s section contains "
7747 "unsupported segment selector size: %d.\n"),
7748 section
->name
, segment_selector_size
);
7752 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7753 if (offset_entry_count
!= 0)
7755 warn (_("The %s section contains "
7756 "unsupported offset entry count: %u.\n"),
7757 section
->name
, offset_entry_count
);
7762 if (load_debug_info (file
) == 0)
7764 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7770 for (i
= 0; i
< num_debug_info_entries
; i
++)
7772 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7773 /* Skip .debug_rnglists reference. */
7775 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7776 /* Skip .debug_range reference. */
7778 num_range_list
+= debug_information
[i
].num_range_lists
;
7781 if (num_range_list
== 0)
7783 /* This can happen when the file was compiled with -gsplit-debug
7784 which removes references to range lists from the primary .o file. */
7785 printf (_("No range lists in .debug_info section.\n"));
7789 range_entries
= (struct range_entry
*)
7790 xmalloc (sizeof (*range_entries
) * num_range_list
);
7791 range_entry_fill
= range_entries
;
7793 for (i
= 0; i
< num_debug_info_entries
; i
++)
7795 debug_info
*debug_info_p
= &debug_information
[i
];
7798 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7799 /* Skip .debug_rnglists reference. */
7801 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7802 /* Skip .debug_range reference. */
7805 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7807 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7808 range_entry_fill
->debug_info_p
= debug_info_p
;
7813 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7814 range_entry_compar
);
7816 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7817 warn (_("Range lists in %s section start at 0x%lx\n"),
7818 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7820 introduce (section
, false);
7822 printf (_(" Offset Begin End\n"));
7824 for (i
= 0; i
< num_range_list
; i
++)
7826 struct range_entry
*range_entry
= &range_entries
[i
];
7827 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7828 unsigned int pointer_size
;
7830 unsigned char *next
;
7831 dwarf_vma base_address
;
7833 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7834 offset
= range_entry
->ranges_offset
;
7835 next
= section_begin
+ offset
;
7836 base_address
= debug_info_p
->base_address
;
7838 /* PR 17512: file: 001-101485-0.001:0.1. */
7839 if (pointer_size
< 2 || pointer_size
> 8)
7841 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7842 pointer_size
, (unsigned long) offset
);
7846 if (next
< section_begin
|| next
>= finish
)
7848 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7849 (unsigned long) offset
, i
);
7853 /* If multiple DWARF entities reference the same range then we will
7854 have multiple entries in the `range_entries' list for the same
7855 offset. Thanks to the sort above these will all be consecutive in
7856 the `range_entries' list, so we can easily ignore duplicates
7858 if (i
> 0 && last_offset
== offset
)
7860 last_offset
= offset
;
7862 if (dwarf_check
!= 0 && i
> 0)
7865 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7866 (unsigned long) (start
- section_begin
),
7867 (unsigned long) (next
- section_begin
), section
->name
);
7868 else if (start
> next
)
7870 if (next
== last_start
)
7872 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7873 (unsigned long) (start
- section_begin
),
7874 (unsigned long) (next
- section_begin
), section
->name
);
7881 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7882 (start
, finish
, pointer_size
, offset
, base_address
);
7886 free (range_entries
);
7891 typedef struct Frame_Chunk
7893 struct Frame_Chunk
*next
;
7894 unsigned char *chunk_start
;
7896 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7897 short int *col_type
;
7900 unsigned int code_factor
;
7904 unsigned int cfa_reg
;
7905 dwarf_vma cfa_offset
;
7907 unsigned char fde_encoding
;
7908 unsigned char cfa_exp
;
7909 unsigned char ptr_size
;
7910 unsigned char segment_size
;
7914 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7915 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7916 static const char *const *dwarf_regnames
;
7917 static unsigned int dwarf_regnames_count
;
7920 /* A marker for a col_type that means this column was never referenced
7921 in the frame info. */
7922 #define DW_CFA_unreferenced (-1)
7924 /* Return 0 if no more space is needed, 1 if more space is needed,
7925 -1 for invalid reg. */
7928 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7930 unsigned int prev
= fc
->ncols
;
7932 if (reg
< (unsigned int) fc
->ncols
)
7935 if (dwarf_regnames_count
> 0
7936 && reg
> dwarf_regnames_count
)
7939 fc
->ncols
= reg
+ 1;
7940 /* PR 17512: file: 10450-2643-0.004.
7941 If reg == -1 then this can happen... */
7945 /* PR 17512: file: 2844a11d. */
7946 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7948 error (_("Unfeasibly large register number: %u\n"), reg
);
7950 /* FIXME: 1024 is an arbitrary limit. Increase it if
7951 we ever encounter a valid binary that exceeds it. */
7955 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7956 sizeof (short int));
7957 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7958 /* PR 17512: file:002-10025-0.005. */
7959 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7961 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7967 while (prev
< fc
->ncols
)
7969 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7970 fc
->col_offset
[prev
] = 0;
7976 static const char *const dwarf_regnames_i386
[] =
7978 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7979 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7980 "eip", "eflags", NULL
, /* 8 - 10 */
7981 "st0", "st1", "st2", "st3", /* 11 - 14 */
7982 "st4", "st5", "st6", "st7", /* 15 - 18 */
7983 NULL
, NULL
, /* 19 - 20 */
7984 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7985 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7986 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7987 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7988 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7989 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7990 "tr", "ldtr", /* 48 - 49 */
7991 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7992 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7993 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7994 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7995 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7996 NULL
, NULL
, NULL
, /* 90 - 92 */
7997 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8000 static const char *const dwarf_regnames_iamcu
[] =
8002 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8003 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8004 "eip", "eflags", NULL
, /* 8 - 10 */
8005 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8006 NULL
, NULL
, /* 19 - 20 */
8007 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8008 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8009 NULL
, NULL
, NULL
, /* 37 - 39 */
8010 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8011 "tr", "ldtr", /* 48 - 49 */
8012 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8013 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8014 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8015 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8016 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8017 NULL
, NULL
, NULL
, /* 90 - 92 */
8018 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8022 init_dwarf_regnames_i386 (void)
8024 dwarf_regnames
= dwarf_regnames_i386
;
8025 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8026 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8030 init_dwarf_regnames_iamcu (void)
8032 dwarf_regnames
= dwarf_regnames_iamcu
;
8033 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8034 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8037 static const char *const dwarf_regnames_x86_64
[] =
8039 "rax", "rdx", "rcx", "rbx",
8040 "rsi", "rdi", "rbp", "rsp",
8041 "r8", "r9", "r10", "r11",
8042 "r12", "r13", "r14", "r15",
8044 "xmm0", "xmm1", "xmm2", "xmm3",
8045 "xmm4", "xmm5", "xmm6", "xmm7",
8046 "xmm8", "xmm9", "xmm10", "xmm11",
8047 "xmm12", "xmm13", "xmm14", "xmm15",
8048 "st0", "st1", "st2", "st3",
8049 "st4", "st5", "st6", "st7",
8050 "mm0", "mm1", "mm2", "mm3",
8051 "mm4", "mm5", "mm6", "mm7",
8053 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8054 "fs.base", "gs.base", NULL
, NULL
,
8056 "mxcsr", "fcw", "fsw",
8057 "xmm16", "xmm17", "xmm18", "xmm19",
8058 "xmm20", "xmm21", "xmm22", "xmm23",
8059 "xmm24", "xmm25", "xmm26", "xmm27",
8060 "xmm28", "xmm29", "xmm30", "xmm31",
8061 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8062 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8063 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8064 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8065 NULL
, NULL
, NULL
, /* 115 - 117 */
8066 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8070 init_dwarf_regnames_x86_64 (void)
8072 dwarf_regnames
= dwarf_regnames_x86_64
;
8073 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8074 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8077 static const char *const dwarf_regnames_aarch64
[] =
8079 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8080 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8081 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8082 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8083 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8084 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8085 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8086 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8087 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8088 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8089 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8090 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8091 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8092 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8093 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8094 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8098 init_dwarf_regnames_aarch64 (void)
8100 dwarf_regnames
= dwarf_regnames_aarch64
;
8101 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8102 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8105 static const char *const dwarf_regnames_s390
[] =
8107 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8108 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8109 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8110 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8111 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8112 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8113 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8114 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8115 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8118 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8119 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8123 init_dwarf_regnames_s390 (void)
8125 dwarf_regnames
= dwarf_regnames_s390
;
8126 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8127 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8130 static const char *const dwarf_regnames_riscv
[] =
8132 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8133 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8134 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8135 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8136 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8137 "fs0", "fs1", /* 40 - 41 */
8138 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8139 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8140 "fs10", "fs11", /* 58 - 59 */
8141 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8144 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8145 the large number of CSRs. */
8148 regname_internal_riscv (unsigned int regno
)
8150 const char *name
= NULL
;
8152 /* Lookup in the table first, this covers GPR and FPR. */
8153 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8154 name
= dwarf_regnames_riscv
[regno
];
8155 else if (regno
>= 4096 && regno
<= 8191)
8157 /* This might be a CSR, these live in a sparse number space from 4096
8158 to 8191 These numbers are defined in the RISC-V ELF ABI
8162 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8163 case VALUE + 4096: name = #NAME; break;
8164 #include "opcode/riscv-opc.h"
8169 static char csr_name
[10];
8170 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8181 init_dwarf_regnames_riscv (void)
8183 dwarf_regnames
= NULL
;
8184 dwarf_regnames_count
= 8192;
8185 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8189 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8191 dwarf_regnames_lookup_func
= NULL
;
8196 init_dwarf_regnames_i386 ();
8200 init_dwarf_regnames_iamcu ();
8206 init_dwarf_regnames_x86_64 ();
8210 init_dwarf_regnames_aarch64 ();
8214 init_dwarf_regnames_s390 ();
8218 init_dwarf_regnames_riscv ();
8226 /* Initialize the DWARF register name lookup state based on the
8227 architecture and specific machine type of a BFD. */
8230 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8233 dwarf_regnames_lookup_func
= NULL
;
8240 case bfd_mach_x86_64
:
8241 case bfd_mach_x86_64_intel_syntax
:
8242 case bfd_mach_x64_32
:
8243 case bfd_mach_x64_32_intel_syntax
:
8244 init_dwarf_regnames_x86_64 ();
8248 init_dwarf_regnames_i386 ();
8253 case bfd_arch_iamcu
:
8254 init_dwarf_regnames_iamcu ();
8257 case bfd_arch_aarch64
:
8258 init_dwarf_regnames_aarch64();
8262 init_dwarf_regnames_s390 ();
8265 case bfd_arch_riscv
:
8266 init_dwarf_regnames_riscv ();
8275 regname_internal_by_table_only (unsigned int regno
)
8277 if (dwarf_regnames
!= NULL
8278 && regno
< dwarf_regnames_count
8279 && dwarf_regnames
[regno
] != NULL
)
8280 return dwarf_regnames
[regno
];
8286 regname (unsigned int regno
, int name_only_p
)
8288 static char reg
[64];
8290 const char *name
= NULL
;
8292 if (dwarf_regnames_lookup_func
!= NULL
)
8293 name
= dwarf_regnames_lookup_func (regno
);
8299 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8302 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8307 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8312 if (*max_regs
!= fc
->ncols
)
8313 *max_regs
= fc
->ncols
;
8315 if (*need_col_headers
)
8317 *need_col_headers
= 0;
8319 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8321 for (r
= 0; r
< *max_regs
; r
++)
8322 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8327 printf ("%-5s ", regname (r
, 1));
8333 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8335 strcpy (tmp
, "exp");
8337 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8338 printf ("%-8s ", tmp
);
8340 for (r
= 0; r
< fc
->ncols
; r
++)
8342 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8344 switch (fc
->col_type
[r
])
8346 case DW_CFA_undefined
:
8349 case DW_CFA_same_value
:
8353 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8355 case DW_CFA_val_offset
:
8356 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8358 case DW_CFA_register
:
8359 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8361 case DW_CFA_expression
:
8362 strcpy (tmp
, "exp");
8364 case DW_CFA_val_expression
:
8365 strcpy (tmp
, "vexp");
8368 strcpy (tmp
, "n/a");
8371 printf ("%-5s ", tmp
);
8377 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8379 static unsigned char *
8380 read_cie (unsigned char *start
, unsigned char *end
,
8381 Frame_Chunk
**p_cie
, int *p_version
,
8382 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8386 unsigned char *augmentation_data
= NULL
;
8387 bfd_size_type augmentation_data_len
= 0;
8390 /* PR 17512: file: 001-228113-0.004. */
8394 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8395 memset (fc
, 0, sizeof (Frame_Chunk
));
8397 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8398 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8402 fc
->augmentation
= (char *) start
;
8403 /* PR 17512: file: 001-228113-0.004.
8404 Skip past augmentation name, but avoid running off the end of the data. */
8406 if (* start
++ == '\0')
8410 warn (_("No terminator for augmentation name\n"));
8414 if (strcmp (fc
->augmentation
, "eh") == 0)
8415 start
+= eh_addr_size
;
8419 GET (fc
->ptr_size
, 1);
8420 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8422 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8426 GET (fc
->segment_size
, 1);
8427 /* PR 17512: file: e99d2804. */
8428 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8430 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8434 eh_addr_size
= fc
->ptr_size
;
8438 fc
->ptr_size
= eh_addr_size
;
8439 fc
->segment_size
= 0;
8442 READ_ULEB (fc
->code_factor
, start
, end
);
8443 READ_SLEB (fc
->data_factor
, start
, end
);
8451 READ_ULEB (fc
->ra
, start
, end
);
8454 if (fc
->augmentation
[0] == 'z')
8456 READ_ULEB (augmentation_data_len
, start
, end
);
8457 augmentation_data
= start
;
8458 /* PR 17512: file: 11042-2589-0.004. */
8459 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8461 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8462 dwarf_vmatoa ("x", augmentation_data_len
),
8463 (unsigned long) (end
- start
));
8466 start
+= augmentation_data_len
;
8469 if (augmentation_data_len
)
8473 unsigned char *qend
;
8475 p
= (unsigned char *) fc
->augmentation
+ 1;
8476 q
= augmentation_data
;
8477 qend
= q
+ augmentation_data_len
;
8479 while (p
< end
&& q
< qend
)
8484 q
+= 1 + size_of_encoded_value (*q
);
8486 fc
->fde_encoding
= *q
++;
8495 /* Note - it is OK if this loop terminates with q < qend.
8496 Padding may have been inserted to align the end of the CIE. */
8501 *p_version
= version
;
8504 *p_aug_len
= augmentation_data_len
;
8505 *p_aug
= augmentation_data
;
8510 free (fc
->col_offset
);
8511 free (fc
->col_type
);
8516 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8517 If do_wide is not enabled, then formats the output to fit into 80 columns.
8518 PRINTED contains the number of characters already written to the current
8522 display_data (bfd_size_type printed
,
8523 const unsigned char * data
,
8524 const bfd_size_type len
)
8526 if (do_wide
|| len
< ((80 - printed
) / 3))
8527 for (printed
= 0; printed
< len
; ++printed
)
8528 printf (" %02x", data
[printed
]);
8531 for (printed
= 0; printed
< len
; ++printed
)
8533 if (printed
% (80 / 3) == 0)
8535 printf (" %02x", data
[printed
]);
8540 /* Prints out the contents on the augmentation data array.
8541 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8544 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8548 i
= printf (_(" Augmentation data: "));
8549 display_data (i
, data
, len
);
8553 display_debug_frames (struct dwarf_section
*section
,
8554 void *file ATTRIBUTE_UNUSED
)
8556 unsigned char *start
= section
->start
;
8557 unsigned char *end
= start
+ section
->size
;
8558 unsigned char *section_start
= start
;
8559 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8560 Frame_Chunk
*remembered_state
= NULL
;
8562 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8563 unsigned int max_regs
= 0;
8564 const char *bad_reg
= _("bad register: ");
8565 unsigned int saved_eh_addr_size
= eh_addr_size
;
8567 introduce (section
, false);
8571 unsigned char *saved_start
;
8572 unsigned char *block_end
;
8577 int need_col_headers
= 1;
8578 unsigned char *augmentation_data
= NULL
;
8579 bfd_size_type augmentation_data_len
= 0;
8580 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8581 unsigned int offset_size
;
8582 unsigned int initial_length_size
;
8584 static Frame_Chunk fde_fc
;
8586 saved_start
= start
;
8588 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8592 printf ("\n%08lx ZERO terminator\n\n",
8593 (unsigned long)(saved_start
- section_start
));
8594 /* Skip any zero terminators that directly follow.
8595 A corrupt section size could have loaded a whole
8596 slew of zero filled memory bytes. eg
8597 PR 17512: file: 070-19381-0.004. */
8598 while (start
< end
&& * start
== 0)
8603 if (length
== 0xffffffff)
8605 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8607 initial_length_size
= 12;
8612 initial_length_size
= 4;
8615 block_end
= saved_start
+ length
+ initial_length_size
;
8616 if (block_end
> end
|| block_end
< start
)
8618 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8619 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8620 (unsigned long) (saved_start
- section_start
));
8624 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8626 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8627 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8632 start
= read_cie (start
, end
, &cie
, &version
,
8633 &augmentation_data_len
, &augmentation_data
);
8634 /* PR 17512: file: 027-135133-0.005. */
8641 fc
->chunk_start
= saved_start
;
8642 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8645 if (frame_need_space (fc
, mreg
) < 0)
8647 if (fc
->fde_encoding
)
8648 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8650 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8651 print_dwarf_vma (length
, fc
->ptr_size
);
8652 print_dwarf_vma (cie_id
, offset_size
);
8654 if (do_debug_frames_interp
)
8656 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8657 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8662 printf (" Version: %d\n", version
);
8663 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8666 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8667 printf (" Segment Size: %u\n", fc
->segment_size
);
8669 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8670 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8671 printf (" Return address column: %d\n", fc
->ra
);
8673 if (augmentation_data_len
)
8674 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8681 unsigned char *look_for
;
8682 unsigned long segment_selector
;
8688 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8689 cie_off
= (cie_off
^ sign
) - sign
;
8690 cie_off
= start
- 4 - section_start
- cie_off
;
8693 look_for
= section_start
+ cie_off
;
8694 if (cie_off
<= (dwarf_vma
) (saved_start
- section_start
))
8696 for (cie
= chunks
; cie
; cie
= cie
->next
)
8697 if (cie
->chunk_start
== look_for
)
8700 else if (cie_off
>= section
->size
)
8704 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8705 if (cie
->chunk_start
== look_for
)
8709 unsigned int off_size
;
8710 unsigned char *cie_scan
;
8712 cie_scan
= look_for
;
8714 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8715 if (length
== 0xffffffff)
8717 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8724 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8727 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8728 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8733 read_cie (cie_scan
, end
, &cie
, &version
,
8734 &augmentation_data_len
, &augmentation_data
);
8735 /* PR 17512: file: 3450-2098-0.004. */
8738 warn (_("Failed to read CIE information\n"));
8741 cie
->next
= forward_refs
;
8743 cie
->chunk_start
= look_for
;
8744 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8747 if (frame_need_space (cie
, mreg
) < 0)
8749 warn (_("Invalid max register\n"));
8752 if (cie
->fde_encoding
)
8754 = size_of_encoded_value (cie
->fde_encoding
);
8761 memset (fc
, 0, sizeof (Frame_Chunk
));
8765 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8766 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8767 (unsigned long) (saved_start
- section_start
));
8769 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8770 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8771 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8773 warn (_("Invalid max register\n"));
8777 fc
->augmentation
= "";
8778 fc
->fde_encoding
= 0;
8779 fc
->ptr_size
= eh_addr_size
;
8780 fc
->segment_size
= 0;
8784 fc
->ncols
= cie
->ncols
;
8785 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8786 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8787 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8788 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8789 fc
->augmentation
= cie
->augmentation
;
8790 fc
->ptr_size
= cie
->ptr_size
;
8791 eh_addr_size
= cie
->ptr_size
;
8792 fc
->segment_size
= cie
->segment_size
;
8793 fc
->code_factor
= cie
->code_factor
;
8794 fc
->data_factor
= cie
->data_factor
;
8795 fc
->cfa_reg
= cie
->cfa_reg
;
8796 fc
->cfa_offset
= cie
->cfa_offset
;
8798 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8800 warn (_("Invalid max register\n"));
8803 fc
->fde_encoding
= cie
->fde_encoding
;
8806 if (fc
->fde_encoding
)
8807 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8809 segment_selector
= 0;
8810 if (fc
->segment_size
)
8812 if (fc
->segment_size
> sizeof (segment_selector
))
8814 /* PR 17512: file: 9e196b3e. */
8815 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8816 fc
->segment_size
= 4;
8818 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8821 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8823 /* FIXME: It appears that sometimes the final pc_range value is
8824 encoded in less than encoded_ptr_size bytes. See the x86_64
8825 run of the "objcopy on compressed debug sections" test for an
8827 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8829 if (cie
->augmentation
[0] == 'z')
8831 READ_ULEB (augmentation_data_len
, start
, end
);
8832 augmentation_data
= start
;
8833 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8834 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8836 warn (_("Augmentation data too long: 0x%s, "
8837 "expected at most %#lx\n"),
8838 dwarf_vmatoa ("x", augmentation_data_len
),
8839 (unsigned long) (end
- start
));
8841 augmentation_data
= NULL
;
8842 augmentation_data_len
= 0;
8844 start
+= augmentation_data_len
;
8847 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8848 (unsigned long)(saved_start
- section_start
),
8849 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8850 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8851 (unsigned long)(cie
->chunk_start
- section_start
));
8853 if (fc
->segment_size
)
8854 printf ("%04lx:", segment_selector
);
8857 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8858 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8860 if (! do_debug_frames_interp
&& augmentation_data_len
)
8862 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8867 /* At this point, fc is the current chunk, cie (if any) is set, and
8868 we're about to interpret instructions for the chunk. */
8869 /* ??? At present we need to do this always, since this sizes the
8870 fc->col_type and fc->col_offset arrays, which we write into always.
8871 We should probably split the interpreted and non-interpreted bits
8872 into two different routines, since there's so much that doesn't
8873 really overlap between them. */
8874 if (1 || do_debug_frames_interp
)
8876 /* Start by making a pass over the chunk, allocating storage
8877 and taking note of what registers are used. */
8878 unsigned char *tmp
= start
;
8880 while (start
< block_end
)
8882 unsigned int reg
, op
, opa
;
8884 unsigned char * new_start
;
8891 /* Warning: if you add any more cases to this switch, be
8892 sure to add them to the corresponding switch below. */
8895 case DW_CFA_advance_loc
:
8898 SKIP_ULEB (start
, end
);
8899 if (frame_need_space (fc
, opa
) >= 0)
8900 fc
->col_type
[opa
] = DW_CFA_undefined
;
8902 case DW_CFA_restore
:
8903 if (frame_need_space (fc
, opa
) >= 0)
8904 fc
->col_type
[opa
] = DW_CFA_undefined
;
8906 case DW_CFA_set_loc
:
8907 start
+= encoded_ptr_size
;
8909 case DW_CFA_advance_loc1
:
8912 case DW_CFA_advance_loc2
:
8915 case DW_CFA_advance_loc4
:
8918 case DW_CFA_offset_extended
:
8919 case DW_CFA_val_offset
:
8920 READ_ULEB (reg
, start
, end
);
8921 SKIP_ULEB (start
, end
);
8922 if (frame_need_space (fc
, reg
) >= 0)
8923 fc
->col_type
[reg
] = DW_CFA_undefined
;
8925 case DW_CFA_restore_extended
:
8926 READ_ULEB (reg
, start
, end
);
8927 if (frame_need_space (fc
, reg
) >= 0)
8928 fc
->col_type
[reg
] = DW_CFA_undefined
;
8930 case DW_CFA_undefined
:
8931 READ_ULEB (reg
, start
, end
);
8932 if (frame_need_space (fc
, reg
) >= 0)
8933 fc
->col_type
[reg
] = DW_CFA_undefined
;
8935 case DW_CFA_same_value
:
8936 READ_ULEB (reg
, start
, end
);
8937 if (frame_need_space (fc
, reg
) >= 0)
8938 fc
->col_type
[reg
] = DW_CFA_undefined
;
8940 case DW_CFA_register
:
8941 READ_ULEB (reg
, start
, end
);
8942 SKIP_ULEB (start
, end
);
8943 if (frame_need_space (fc
, reg
) >= 0)
8944 fc
->col_type
[reg
] = DW_CFA_undefined
;
8946 case DW_CFA_def_cfa
:
8947 SKIP_ULEB (start
, end
);
8948 SKIP_ULEB (start
, end
);
8950 case DW_CFA_def_cfa_register
:
8951 SKIP_ULEB (start
, end
);
8953 case DW_CFA_def_cfa_offset
:
8954 SKIP_ULEB (start
, end
);
8956 case DW_CFA_def_cfa_expression
:
8957 READ_ULEB (temp
, start
, end
);
8958 new_start
= start
+ temp
;
8959 if (new_start
< start
)
8961 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8967 case DW_CFA_expression
:
8968 case DW_CFA_val_expression
:
8969 READ_ULEB (reg
, start
, end
);
8970 READ_ULEB (temp
, start
, end
);
8971 new_start
= start
+ temp
;
8972 if (new_start
< start
)
8974 /* PR 17512: file:306-192417-0.005. */
8975 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8980 if (frame_need_space (fc
, reg
) >= 0)
8981 fc
->col_type
[reg
] = DW_CFA_undefined
;
8983 case DW_CFA_offset_extended_sf
:
8984 case DW_CFA_val_offset_sf
:
8985 READ_ULEB (reg
, start
, end
);
8986 SKIP_SLEB (start
, end
);
8987 if (frame_need_space (fc
, reg
) >= 0)
8988 fc
->col_type
[reg
] = DW_CFA_undefined
;
8990 case DW_CFA_def_cfa_sf
:
8991 SKIP_ULEB (start
, end
);
8992 SKIP_SLEB (start
, end
);
8994 case DW_CFA_def_cfa_offset_sf
:
8995 SKIP_SLEB (start
, end
);
8997 case DW_CFA_MIPS_advance_loc8
:
9000 case DW_CFA_GNU_args_size
:
9001 SKIP_ULEB (start
, end
);
9003 case DW_CFA_GNU_negative_offset_extended
:
9004 READ_ULEB (reg
, start
, end
);
9005 SKIP_ULEB (start
, end
);
9006 if (frame_need_space (fc
, reg
) >= 0)
9007 fc
->col_type
[reg
] = DW_CFA_undefined
;
9018 /* Now we know what registers are used, make a second pass over
9019 the chunk, this time actually printing out the info. */
9021 while (start
< block_end
)
9023 unsigned char * tmp
;
9025 unsigned long ul
, roffs
;
9026 /* Note: It is tempting to use an unsigned long for 'reg' but there
9027 are various functions, notably frame_space_needed() that assume that
9028 reg is an unsigned int. */
9033 const char *reg_prefix
= "";
9040 /* Make a note if something other than DW_CFA_nop happens. */
9041 if (op
!= DW_CFA_nop
)
9044 /* Warning: if you add any more cases to this switch, be
9045 sure to add them to the corresponding switch above. */
9048 case DW_CFA_advance_loc
:
9049 if (do_debug_frames_interp
)
9050 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9052 printf (" DW_CFA_advance_loc: %d to %s\n",
9053 opa
* fc
->code_factor
,
9054 dwarf_vmatoa_1 (NULL
,
9055 fc
->pc_begin
+ opa
* fc
->code_factor
,
9057 fc
->pc_begin
+= opa
* fc
->code_factor
;
9061 READ_ULEB (roffs
, start
, end
);
9062 if (opa
>= (unsigned int) fc
->ncols
)
9063 reg_prefix
= bad_reg
;
9064 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9065 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9066 reg_prefix
, regname (opa
, 0),
9067 roffs
* fc
->data_factor
);
9068 if (*reg_prefix
== '\0')
9070 fc
->col_type
[opa
] = DW_CFA_offset
;
9071 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9075 case DW_CFA_restore
:
9076 if (opa
>= (unsigned int) fc
->ncols
)
9077 reg_prefix
= bad_reg
;
9078 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9079 printf (" DW_CFA_restore: %s%s\n",
9080 reg_prefix
, regname (opa
, 0));
9081 if (*reg_prefix
!= '\0')
9084 if (opa
>= (unsigned int) cie
->ncols
9085 || (do_debug_frames_interp
9086 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
9088 fc
->col_type
[opa
] = DW_CFA_undefined
;
9089 fc
->col_offset
[opa
] = 0;
9093 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9094 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9098 case DW_CFA_set_loc
:
9099 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
9100 if (do_debug_frames_interp
)
9101 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9103 printf (" DW_CFA_set_loc: %s\n",
9104 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
9108 case DW_CFA_advance_loc1
:
9109 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
9110 if (do_debug_frames_interp
)
9111 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9113 printf (" DW_CFA_advance_loc1: %ld to %s\n",
9114 (unsigned long) (ofs
* fc
->code_factor
),
9115 dwarf_vmatoa_1 (NULL
,
9116 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9118 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9121 case DW_CFA_advance_loc2
:
9122 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9123 if (do_debug_frames_interp
)
9124 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9126 printf (" DW_CFA_advance_loc2: %ld to %s\n",
9127 (unsigned long) (ofs
* fc
->code_factor
),
9128 dwarf_vmatoa_1 (NULL
,
9129 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9131 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9134 case DW_CFA_advance_loc4
:
9135 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9136 if (do_debug_frames_interp
)
9137 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9139 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9140 (unsigned long) (ofs
* fc
->code_factor
),
9141 dwarf_vmatoa_1 (NULL
,
9142 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9144 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9147 case DW_CFA_offset_extended
:
9148 READ_ULEB (reg
, start
, end
);
9149 READ_ULEB (roffs
, start
, end
);
9150 if (reg
>= (unsigned int) fc
->ncols
)
9151 reg_prefix
= bad_reg
;
9152 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9153 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9154 reg_prefix
, regname (reg
, 0),
9155 roffs
* fc
->data_factor
);
9156 if (*reg_prefix
== '\0')
9158 fc
->col_type
[reg
] = DW_CFA_offset
;
9159 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9163 case DW_CFA_val_offset
:
9164 READ_ULEB (reg
, start
, end
);
9165 READ_ULEB (roffs
, start
, end
);
9166 if (reg
>= (unsigned int) fc
->ncols
)
9167 reg_prefix
= bad_reg
;
9168 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9169 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9170 reg_prefix
, regname (reg
, 0),
9171 roffs
* fc
->data_factor
);
9172 if (*reg_prefix
== '\0')
9174 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9175 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9179 case DW_CFA_restore_extended
:
9180 READ_ULEB (reg
, start
, end
);
9181 if (reg
>= (unsigned int) fc
->ncols
)
9182 reg_prefix
= bad_reg
;
9183 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9184 printf (" DW_CFA_restore_extended: %s%s\n",
9185 reg_prefix
, regname (reg
, 0));
9186 if (*reg_prefix
!= '\0')
9189 if (reg
>= (unsigned int) cie
->ncols
)
9191 fc
->col_type
[reg
] = DW_CFA_undefined
;
9192 fc
->col_offset
[reg
] = 0;
9196 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9197 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9201 case DW_CFA_undefined
:
9202 READ_ULEB (reg
, start
, end
);
9203 if (reg
>= (unsigned int) fc
->ncols
)
9204 reg_prefix
= bad_reg
;
9205 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9206 printf (" DW_CFA_undefined: %s%s\n",
9207 reg_prefix
, regname (reg
, 0));
9208 if (*reg_prefix
== '\0')
9210 fc
->col_type
[reg
] = DW_CFA_undefined
;
9211 fc
->col_offset
[reg
] = 0;
9215 case DW_CFA_same_value
:
9216 READ_ULEB (reg
, start
, end
);
9217 if (reg
>= (unsigned int) fc
->ncols
)
9218 reg_prefix
= bad_reg
;
9219 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9220 printf (" DW_CFA_same_value: %s%s\n",
9221 reg_prefix
, regname (reg
, 0));
9222 if (*reg_prefix
== '\0')
9224 fc
->col_type
[reg
] = DW_CFA_same_value
;
9225 fc
->col_offset
[reg
] = 0;
9229 case DW_CFA_register
:
9230 READ_ULEB (reg
, start
, end
);
9231 READ_ULEB (roffs
, start
, end
);
9232 if (reg
>= (unsigned int) fc
->ncols
)
9233 reg_prefix
= bad_reg
;
9234 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9236 printf (" DW_CFA_register: %s%s in ",
9237 reg_prefix
, regname (reg
, 0));
9238 puts (regname (roffs
, 0));
9240 if (*reg_prefix
== '\0')
9242 fc
->col_type
[reg
] = DW_CFA_register
;
9243 fc
->col_offset
[reg
] = roffs
;
9247 case DW_CFA_remember_state
:
9248 if (! do_debug_frames_interp
)
9249 printf (" DW_CFA_remember_state\n");
9250 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9251 rs
->cfa_offset
= fc
->cfa_offset
;
9252 rs
->cfa_reg
= fc
->cfa_reg
;
9254 rs
->cfa_exp
= fc
->cfa_exp
;
9255 rs
->ncols
= fc
->ncols
;
9256 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9257 sizeof (* rs
->col_type
));
9258 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9259 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9260 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9261 rs
->next
= remembered_state
;
9262 remembered_state
= rs
;
9265 case DW_CFA_restore_state
:
9266 if (! do_debug_frames_interp
)
9267 printf (" DW_CFA_restore_state\n");
9268 rs
= remembered_state
;
9271 remembered_state
= rs
->next
;
9272 fc
->cfa_offset
= rs
->cfa_offset
;
9273 fc
->cfa_reg
= rs
->cfa_reg
;
9275 fc
->cfa_exp
= rs
->cfa_exp
;
9276 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9278 warn (_("Invalid column number in saved frame state\n"));
9282 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9283 memcpy (fc
->col_offset
, rs
->col_offset
,
9284 rs
->ncols
* sizeof (* rs
->col_offset
));
9285 free (rs
->col_type
);
9286 free (rs
->col_offset
);
9289 else if (do_debug_frames_interp
)
9290 printf ("Mismatched DW_CFA_restore_state\n");
9293 case DW_CFA_def_cfa
:
9294 READ_ULEB (fc
->cfa_reg
, start
, end
);
9295 READ_ULEB (fc
->cfa_offset
, start
, end
);
9297 if (! do_debug_frames_interp
)
9298 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9299 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9302 case DW_CFA_def_cfa_register
:
9303 READ_ULEB (fc
->cfa_reg
, start
, end
);
9305 if (! do_debug_frames_interp
)
9306 printf (" DW_CFA_def_cfa_register: %s\n",
9307 regname (fc
->cfa_reg
, 0));
9310 case DW_CFA_def_cfa_offset
:
9311 READ_ULEB (fc
->cfa_offset
, start
, end
);
9312 if (! do_debug_frames_interp
)
9313 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9317 if (! do_debug_frames_interp
)
9318 printf (" DW_CFA_nop\n");
9321 case DW_CFA_def_cfa_expression
:
9322 READ_ULEB (ul
, start
, end
);
9323 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
9325 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9328 if (! do_debug_frames_interp
)
9330 printf (" DW_CFA_def_cfa_expression (");
9331 decode_location_expression (start
, eh_addr_size
, 0, -1,
9339 case DW_CFA_expression
:
9340 READ_ULEB (reg
, start
, end
);
9341 READ_ULEB (ul
, start
, end
);
9342 if (reg
>= (unsigned int) fc
->ncols
)
9343 reg_prefix
= bad_reg
;
9344 /* PR 17512: file: 069-133014-0.006. */
9345 /* PR 17512: file: 98c02eb4. */
9347 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9349 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9352 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9354 printf (" DW_CFA_expression: %s%s (",
9355 reg_prefix
, regname (reg
, 0));
9356 decode_location_expression (start
, eh_addr_size
, 0, -1,
9360 if (*reg_prefix
== '\0')
9361 fc
->col_type
[reg
] = DW_CFA_expression
;
9365 case DW_CFA_val_expression
:
9366 READ_ULEB (reg
, start
, end
);
9367 READ_ULEB (ul
, start
, end
);
9368 if (reg
>= (unsigned int) fc
->ncols
)
9369 reg_prefix
= bad_reg
;
9371 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9373 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9376 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9378 printf (" DW_CFA_val_expression: %s%s (",
9379 reg_prefix
, regname (reg
, 0));
9380 decode_location_expression (start
, eh_addr_size
, 0, -1,
9384 if (*reg_prefix
== '\0')
9385 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9389 case DW_CFA_offset_extended_sf
:
9390 READ_ULEB (reg
, start
, end
);
9391 READ_SLEB (l
, start
, end
);
9392 if (frame_need_space (fc
, reg
) < 0)
9393 reg_prefix
= bad_reg
;
9394 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9395 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9396 reg_prefix
, regname (reg
, 0),
9397 (long)(l
* fc
->data_factor
));
9398 if (*reg_prefix
== '\0')
9400 fc
->col_type
[reg
] = DW_CFA_offset
;
9401 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9405 case DW_CFA_val_offset_sf
:
9406 READ_ULEB (reg
, start
, end
);
9407 READ_SLEB (l
, start
, end
);
9408 if (frame_need_space (fc
, reg
) < 0)
9409 reg_prefix
= bad_reg
;
9410 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9411 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9412 reg_prefix
, regname (reg
, 0),
9413 (long)(l
* fc
->data_factor
));
9414 if (*reg_prefix
== '\0')
9416 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9417 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9421 case DW_CFA_def_cfa_sf
:
9422 READ_ULEB (fc
->cfa_reg
, start
, end
);
9423 READ_ULEB (fc
->cfa_offset
, start
, end
);
9424 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
9426 if (! do_debug_frames_interp
)
9427 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
9428 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9431 case DW_CFA_def_cfa_offset_sf
:
9432 READ_ULEB (fc
->cfa_offset
, start
, end
);
9433 fc
->cfa_offset
*= fc
->data_factor
;
9434 if (! do_debug_frames_interp
)
9435 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
9438 case DW_CFA_MIPS_advance_loc8
:
9439 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9440 if (do_debug_frames_interp
)
9441 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9443 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9444 (unsigned long) (ofs
* fc
->code_factor
),
9445 dwarf_vmatoa_1 (NULL
,
9446 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9448 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9451 case DW_CFA_GNU_window_save
:
9452 if (! do_debug_frames_interp
)
9453 printf (" DW_CFA_GNU_window_save\n");
9456 case DW_CFA_GNU_args_size
:
9457 READ_ULEB (ul
, start
, end
);
9458 if (! do_debug_frames_interp
)
9459 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9462 case DW_CFA_GNU_negative_offset_extended
:
9463 READ_ULEB (reg
, start
, end
);
9464 READ_SLEB (l
, start
, end
);
9466 if (frame_need_space (fc
, reg
) < 0)
9467 reg_prefix
= bad_reg
;
9468 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9469 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9470 reg_prefix
, regname (reg
, 0),
9471 (long)(l
* fc
->data_factor
));
9472 if (*reg_prefix
== '\0')
9474 fc
->col_type
[reg
] = DW_CFA_offset
;
9475 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9480 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9481 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9483 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9488 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9489 if (do_debug_frames_interp
&& ! all_nops
)
9490 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9492 if (fde_fc
.col_type
!= NULL
)
9494 free (fde_fc
.col_type
);
9495 fde_fc
.col_type
= NULL
;
9497 if (fde_fc
.col_offset
!= NULL
)
9499 free (fde_fc
.col_offset
);
9500 fde_fc
.col_offset
= NULL
;
9504 eh_addr_size
= saved_eh_addr_size
;
9509 while (remembered_state
!= NULL
)
9511 rs
= remembered_state
;
9512 remembered_state
= rs
->next
;
9513 free (rs
->col_type
);
9514 free (rs
->col_offset
);
9515 rs
->next
= NULL
; /* Paranoia. */
9519 while (chunks
!= NULL
)
9523 free (rs
->col_type
);
9524 free (rs
->col_offset
);
9525 rs
->next
= NULL
; /* Paranoia. */
9529 while (forward_refs
!= NULL
)
9532 forward_refs
= rs
->next
;
9533 free (rs
->col_type
);
9534 free (rs
->col_offset
);
9535 rs
->next
= NULL
; /* Paranoia. */
9545 display_debug_names (struct dwarf_section
*section
, void *file
)
9547 unsigned char *hdrptr
= section
->start
;
9548 dwarf_vma unit_length
;
9549 unsigned char *unit_start
;
9550 const unsigned char *const section_end
= section
->start
+ section
->size
;
9551 unsigned char *unit_end
;
9553 introduce (section
, false);
9555 load_debug_section_with_follow (str
, file
);
9557 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9559 unsigned int offset_size
;
9560 uint16_t dwarf_version
, padding
;
9561 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9562 uint32_t bucket_count
, name_count
, abbrev_table_size
;
9563 uint32_t augmentation_string_size
;
9565 unsigned long sec_off
;
9566 bool augmentation_printable
;
9567 const char *augmentation_string
;
9569 unit_start
= hdrptr
;
9571 /* Get and check the length of the block. */
9572 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9574 if (unit_length
== 0xffffffff)
9576 /* This section is 64-bit DWARF. */
9577 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9582 unit_end
= hdrptr
+ unit_length
;
9584 sec_off
= hdrptr
- section
->start
;
9585 if (sec_off
+ unit_length
< sec_off
9586 || sec_off
+ unit_length
> section
->size
)
9588 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9590 (unsigned long) (unit_start
- section
->start
),
9591 dwarf_vmatoa ("x", unit_length
));
9595 /* Get and check the version number. */
9596 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9597 printf (_("Version %ld\n"), (long) dwarf_version
);
9599 /* Prior versions did not exist, and future versions may not be
9600 backwards compatible. */
9601 if (dwarf_version
!= 5)
9603 warn (_("Only DWARF version 5 .debug_names "
9604 "is currently supported.\n"));
9608 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9610 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9613 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9614 if (comp_unit_count
== 0)
9615 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9617 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9618 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9619 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9620 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9621 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9623 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9624 if (augmentation_string_size
% 4 != 0)
9626 warn (_("Augmentation string length %u must be rounded up "
9627 "to a multiple of 4 in .debug_names.\n"),
9628 augmentation_string_size
);
9629 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9632 printf (_("Augmentation string:"));
9634 augmentation_printable
= true;
9635 augmentation_string
= (const char *) hdrptr
;
9637 for (i
= 0; i
< augmentation_string_size
; i
++)
9641 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9642 printf (" %02x", uc
);
9644 if (uc
!= 0 && !ISPRINT (uc
))
9645 augmentation_printable
= false;
9648 if (augmentation_printable
)
9652 i
< augmentation_string_size
&& augmentation_string
[i
];
9654 putchar (augmentation_string
[i
]);
9659 printf (_("CU table:\n"));
9660 for (i
= 0; i
< comp_unit_count
; i
++)
9664 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9665 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9669 printf (_("TU table:\n"));
9670 for (i
= 0; i
< local_type_unit_count
; i
++)
9674 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9675 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9679 printf (_("Foreign TU table:\n"));
9680 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9684 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9685 printf (_("[%3u] "), i
);
9686 print_dwarf_vma (signature
, 8);
9691 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9692 hdrptr
+= bucket_count
* sizeof (uint32_t);
9693 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9694 hdrptr
+= name_count
* sizeof (uint32_t);
9695 unsigned char *const name_table_string_offsets
= hdrptr
;
9696 hdrptr
+= name_count
* offset_size
;
9697 unsigned char *const name_table_entry_offsets
= hdrptr
;
9698 hdrptr
+= name_count
* offset_size
;
9699 unsigned char *const abbrev_table
= hdrptr
;
9700 hdrptr
+= abbrev_table_size
;
9701 const unsigned char *const abbrev_table_end
= hdrptr
;
9702 unsigned char *const entry_pool
= hdrptr
;
9703 if (hdrptr
> unit_end
)
9705 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9706 "for unit 0x%lx in the debug_names\n"),
9707 (long) (hdrptr
- section
->start
),
9708 (long) (unit_end
- section
->start
),
9709 (long) (unit_start
- section
->start
));
9713 size_t buckets_filled
= 0;
9715 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9717 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9722 printf (ngettext ("Used %zu of %lu bucket.\n",
9723 "Used %zu of %lu buckets.\n",
9725 buckets_filled
, (unsigned long) bucket_count
);
9727 uint32_t hash_prev
= 0;
9728 size_t hash_clash_count
= 0;
9729 size_t longest_clash
= 0;
9730 size_t this_length
= 0;
9732 for (hashi
= 0; hashi
< name_count
; hashi
++)
9734 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9738 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9742 longest_clash
= MAX (longest_clash
, this_length
);
9747 hash_prev
= hash_this
;
9749 printf (_("Out of %lu items there are %zu bucket clashes"
9750 " (longest of %zu entries).\n"),
9751 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9752 assert (name_count
== buckets_filled
+ hash_clash_count
);
9754 struct abbrev_lookup_entry
9756 dwarf_vma abbrev_tag
;
9757 unsigned char *abbrev_lookup_ptr
;
9759 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9760 size_t abbrev_lookup_used
= 0;
9761 size_t abbrev_lookup_allocated
= 0;
9763 unsigned char *abbrevptr
= abbrev_table
;
9766 dwarf_vma abbrev_tag
;
9768 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9769 if (abbrev_tag
== 0)
9771 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9773 abbrev_lookup_allocated
= MAX (0x100,
9774 abbrev_lookup_allocated
* 2);
9775 abbrev_lookup
= xrealloc (abbrev_lookup
,
9776 (abbrev_lookup_allocated
9777 * sizeof (*abbrev_lookup
)));
9779 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9780 struct abbrev_lookup_entry
*entry
;
9781 for (entry
= abbrev_lookup
;
9782 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9784 if (entry
->abbrev_tag
== abbrev_tag
)
9786 warn (_("Duplicate abbreviation tag %lu "
9787 "in unit 0x%lx in the debug_names\n"),
9788 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9791 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9792 entry
->abbrev_tag
= abbrev_tag
;
9793 entry
->abbrev_lookup_ptr
= abbrevptr
;
9795 /* Skip DWARF tag. */
9796 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9799 dwarf_vma xindex
, form
;
9801 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9802 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9803 if (xindex
== 0 && form
== 0)
9808 printf (_("\nSymbol table:\n"));
9810 for (namei
= 0; namei
< name_count
; ++namei
)
9812 uint64_t string_offset
, entry_offset
;
9815 p
= name_table_string_offsets
+ namei
* offset_size
;
9816 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
9817 p
= name_table_entry_offsets
+ namei
* offset_size
;
9818 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
9820 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9821 fetch_indirect_string (string_offset
));
9823 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9825 /* We need to scan first whether there is a single or multiple
9826 entries. TAGNO is -2 for the first entry, it is -1 for the
9827 initial tag read of the second entry, then it becomes 0 for the
9828 first entry for real printing etc. */
9830 /* Initialize it due to a false compiler warning. */
9831 dwarf_vma second_abbrev_tag
= -1;
9834 dwarf_vma abbrev_tag
;
9835 dwarf_vma dwarf_tag
;
9836 const struct abbrev_lookup_entry
*entry
;
9838 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9841 second_abbrev_tag
= abbrev_tag
;
9843 entryptr
= entry_pool
+ entry_offset
;
9846 if (abbrev_tag
== 0)
9850 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9851 (unsigned long) abbrev_tag
);
9853 for (entry
= abbrev_lookup
;
9854 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9856 if (entry
->abbrev_tag
== abbrev_tag
)
9858 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9860 warn (_("Undefined abbreviation tag %lu "
9861 "in unit 0x%lx in the debug_names\n"),
9863 (long) (unit_start
- section
->start
));
9866 abbrevptr
= entry
->abbrev_lookup_ptr
;
9867 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9869 printf (" %s", get_TAG_name (dwarf_tag
));
9872 dwarf_vma xindex
, form
;
9874 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9875 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9876 if (xindex
== 0 && form
== 0)
9880 printf (" %s", get_IDX_name (xindex
));
9881 entryptr
= read_and_display_attr_value (0, form
, 0,
9882 unit_start
, entryptr
, unit_end
,
9884 dwarf_version
, NULL
,
9891 printf (_(" <no entries>"));
9895 free (abbrev_lookup
);
9902 display_debug_links (struct dwarf_section
* section
,
9903 void * file ATTRIBUTE_UNUSED
)
9905 const unsigned char * filename
;
9906 unsigned int filelen
;
9908 introduce (section
, false);
9910 /* The .gnu_debuglink section is formatted as:
9911 (c-string) Filename.
9912 (padding) If needed to reach a 4 byte boundary.
9913 (uint32_t) CRC32 value.
9915 The .gun_debugaltlink section is formatted as:
9916 (c-string) Filename.
9917 (binary) Build-ID. */
9919 filename
= section
->start
;
9920 filelen
= strnlen ((const char *) filename
, section
->size
);
9921 if (filelen
== section
->size
)
9923 warn (_("The debuglink filename is corrupt/missing\n"));
9927 printf (_(" Separate debug info file: %s\n"), filename
);
9929 if (startswith (section
->name
, ".gnu_debuglink"))
9932 unsigned int crc_offset
;
9934 crc_offset
= filelen
+ 1;
9935 crc_offset
= (crc_offset
+ 3) & ~3;
9936 if (crc_offset
+ 4 > section
->size
)
9938 warn (_("CRC offset missing/truncated\n"));
9942 crc32
= byte_get (filename
+ crc_offset
, 4);
9944 printf (_(" CRC value: %#x\n"), crc32
);
9946 if (crc_offset
+ 4 < section
->size
)
9948 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9949 (long)(section
->size
- (crc_offset
+ 4)));
9953 else /* startswith (section->name, ".gnu_debugaltlink") */
9955 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9956 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9957 bfd_size_type printed
;
9959 /* FIXME: Should we support smaller build-id notes ? */
9960 if (build_id_len
< 0x14)
9962 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9966 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9967 display_data (printed
, build_id
, build_id_len
);
9976 display_gdb_index (struct dwarf_section
*section
,
9977 void *file ATTRIBUTE_UNUSED
)
9979 unsigned char *start
= section
->start
;
9981 uint32_t cu_list_offset
, tu_list_offset
;
9982 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9983 unsigned int cu_list_elements
, tu_list_elements
;
9984 unsigned int address_table_size
, symbol_table_slots
;
9985 unsigned char *cu_list
, *tu_list
;
9986 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9989 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9991 introduce (section
, false);
9993 if (section
->size
< 6 * sizeof (uint32_t))
9995 warn (_("Truncated header in the %s section.\n"), section
->name
);
9999 version
= byte_get_little_endian (start
, 4);
10000 printf (_("Version %ld\n"), (long) version
);
10002 /* Prior versions are obsolete, and future versions may not be
10003 backwards compatible. */
10004 if (version
< 3 || version
> 8)
10006 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10010 warn (_("The address table data in version 3 may be wrong.\n"));
10012 warn (_("Version 4 does not support case insensitive lookups.\n"));
10014 warn (_("Version 5 does not include inlined functions.\n"));
10016 warn (_("Version 6 does not include symbol attributes.\n"));
10017 /* Version 7 indices generated by Gold have bad type unit references,
10018 PR binutils/15021. But we don't know if the index was generated by
10019 Gold or not, so to avoid worrying users with gdb-generated indices
10020 we say nothing for version 7 here. */
10022 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10023 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10024 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10025 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10026 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10028 if (cu_list_offset
> section
->size
10029 || tu_list_offset
> section
->size
10030 || address_table_offset
> section
->size
10031 || symbol_table_offset
> section
->size
10032 || constant_pool_offset
> section
->size
)
10034 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10038 /* PR 17531: file: 418d0a8a. */
10039 if (tu_list_offset
< cu_list_offset
)
10041 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
10042 tu_list_offset
, cu_list_offset
);
10046 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
10048 if (address_table_offset
< tu_list_offset
)
10050 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
10051 address_table_offset
, tu_list_offset
);
10055 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
10057 /* PR 17531: file: 18a47d3d. */
10058 if (symbol_table_offset
< address_table_offset
)
10060 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
10061 symbol_table_offset
, address_table_offset
);
10065 address_table_size
= symbol_table_offset
- address_table_offset
;
10067 if (constant_pool_offset
< symbol_table_offset
)
10069 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
10070 constant_pool_offset
, symbol_table_offset
);
10074 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10076 cu_list
= start
+ cu_list_offset
;
10077 tu_list
= start
+ tu_list_offset
;
10078 address_table
= start
+ address_table_offset
;
10079 symbol_table
= start
+ symbol_table_offset
;
10080 constant_pool
= start
+ constant_pool_offset
;
10082 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
10084 warn (_("Address table extends beyond end of section.\n"));
10088 printf (_("\nCU table:\n"));
10089 for (i
= 0; i
< cu_list_elements
; i
+= 2)
10091 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
10092 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
10094 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
10095 (unsigned long) cu_offset
,
10096 (unsigned long) (cu_offset
+ cu_length
- 1));
10099 printf (_("\nTU table:\n"));
10100 for (i
= 0; i
< tu_list_elements
; i
+= 3)
10102 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
10103 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
10104 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
10106 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
10107 (unsigned long) tu_offset
,
10108 (unsigned long) type_offset
);
10109 print_dwarf_vma (signature
, 8);
10113 printf (_("\nAddress table:\n"));
10114 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
10117 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
10118 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
10119 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
10121 print_dwarf_vma (low
, 8);
10122 print_dwarf_vma (high
, 8);
10123 printf (_("%lu\n"), (unsigned long) cu_index
);
10126 printf (_("\nSymbol table:\n"));
10127 for (i
= 0; i
< symbol_table_slots
; ++i
)
10129 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10130 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10131 uint32_t num_cus
, cu
;
10133 if (name_offset
!= 0
10134 || cu_vector_offset
!= 0)
10137 unsigned char * adr
;
10139 adr
= constant_pool
+ name_offset
;
10140 /* PR 17531: file: 5b7b07ad. */
10141 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
10143 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10144 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10148 printf ("[%3u] %.*s:", i
,
10149 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10150 constant_pool
+ name_offset
);
10152 adr
= constant_pool
+ cu_vector_offset
;
10153 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
10155 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10156 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10157 cu_vector_offset
, i
);
10161 num_cus
= byte_get_little_endian (adr
, 4);
10163 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
10164 if (num_cus
* 4 < num_cus
10165 || adr
>= section
->start
+ section
->size
10166 || adr
< constant_pool
)
10168 printf ("<invalid number of CUs: %d>\n", num_cus
);
10169 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10177 for (j
= 0; j
< num_cus
; ++j
)
10180 gdb_index_symbol_kind kind
;
10182 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10183 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10184 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10185 cu
= GDB_INDEX_CU_VALUE (cu
);
10186 /* Convert to TU number if it's for a type unit. */
10187 if (cu
>= cu_list_elements
/ 2)
10188 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10189 (unsigned long) (cu
- cu_list_elements
/ 2));
10191 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10193 printf (" [%s, %s]",
10194 is_static
? _("static") : _("global"),
10195 get_gdb_index_symbol_kind_name (kind
));
10207 /* Pre-allocate enough space for the CU/TU sets needed. */
10210 prealloc_cu_tu_list (unsigned int nshndx
)
10212 if (shndx_pool
== NULL
)
10214 shndx_pool_size
= nshndx
;
10215 shndx_pool_used
= 0;
10216 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10217 sizeof (unsigned int));
10221 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10222 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10223 sizeof (unsigned int));
10228 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10230 if (shndx_pool_used
>= shndx_pool_size
)
10232 error (_("Internal error: out of space in the shndx pool.\n"));
10235 shndx_pool
[shndx_pool_used
++] = shndx
;
10239 end_cu_tu_entry (void)
10241 if (shndx_pool_used
>= shndx_pool_size
)
10243 error (_("Internal error: out of space in the shndx pool.\n"));
10246 shndx_pool
[shndx_pool_used
++] = 0;
10249 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10251 static const char *
10252 get_DW_SECT_short_name (unsigned int dw_sect
)
10254 static char buf
[16];
10260 case DW_SECT_TYPES
:
10262 case DW_SECT_ABBREV
:
10268 case DW_SECT_STR_OFFSETS
:
10270 case DW_SECT_MACINFO
:
10272 case DW_SECT_MACRO
:
10278 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10282 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10283 These sections are extensions for Fission.
10284 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10287 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10289 unsigned char *phdr
= section
->start
;
10290 unsigned char *limit
= phdr
+ section
->size
;
10291 unsigned char *phash
;
10292 unsigned char *pindex
;
10293 unsigned char *ppool
;
10294 unsigned int version
;
10295 unsigned int ncols
= 0;
10296 unsigned int nused
;
10297 unsigned int nslots
;
10300 dwarf_vma signature
;
10302 /* PR 17512: file: 002-168123-0.004. */
10305 warn (_("Section %s is empty\n"), section
->name
);
10308 /* PR 17512: file: 002-376-0.004. */
10309 if (section
->size
< 24)
10311 warn (_("Section %s is too small to contain a CU/TU header\n"),
10317 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10319 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10320 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10321 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10323 pindex
= phash
+ (size_t) nslots
* 8;
10324 ppool
= pindex
+ (size_t) nslots
* 4;
10328 introduce (section
, false);
10330 printf (_(" Version: %u\n"), version
);
10332 printf (_(" Number of columns: %u\n"), ncols
);
10333 printf (_(" Number of used entries: %u\n"), nused
);
10334 printf (_(" Number of slots: %u\n\n"), nslots
);
10337 /* PR 17531: file: 45d69832. */
10338 if ((size_t) nslots
* 8 / 8 != nslots
10339 || phash
< phdr
|| phash
> limit
10340 || pindex
< phash
|| pindex
> limit
10341 || ppool
< pindex
|| ppool
> limit
)
10343 warn (ngettext ("Section %s is too small for %u slot\n",
10344 "Section %s is too small for %u slots\n",
10346 section
->name
, nslots
);
10353 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10354 for (i
= 0; i
< nslots
; i
++)
10356 unsigned char *shndx_list
;
10357 unsigned int shndx
;
10359 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10360 if (signature
!= 0)
10362 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10363 shndx_list
= ppool
+ j
* 4;
10364 /* PR 17531: file: 705e010d. */
10365 if (shndx_list
< ppool
)
10367 warn (_("Section index pool located before start of section\n"));
10372 printf (_(" [%3d] Signature: 0x%s Sections: "),
10373 i
, dwarf_vmatoa ("x", signature
));
10376 if (shndx_list
>= limit
)
10378 warn (_("Section %s too small for shndx pool\n"),
10382 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10386 printf (" %d", shndx
);
10388 add_shndx_to_cu_tu_entry (shndx
);
10394 end_cu_tu_entry ();
10400 else if (version
== 2)
10403 unsigned int dw_sect
;
10404 unsigned char *ph
= phash
;
10405 unsigned char *pi
= pindex
;
10406 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10407 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10408 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
10410 struct cu_tu_set
*this_set
= NULL
;
10412 unsigned char *prow
;
10414 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10416 /* PR 17531: file: 0dd159bf.
10417 Check for integer overflow (can occur when size_t is 32-bit)
10418 with overlarge ncols or nused values. */
10420 && ((size_t) ncols
* 4 / 4 != ncols
10421 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
10422 || poffsets
< ppool
|| poffsets
> limit
10423 || psizes
< poffsets
|| psizes
> limit
10424 || pend
< psizes
|| pend
> limit
))
10426 warn (_("Section %s too small for offset and size tables\n"),
10433 printf (_(" Offset table\n"));
10434 printf (" slot %-16s ",
10435 is_tu_index
? _("signature") : _("dwo_id"));
10442 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10443 this_set
= tu_sets
;
10448 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10449 this_set
= cu_sets
;
10455 for (j
= 0; j
< ncols
; j
++)
10457 unsigned char *p
= ppool
+ j
* 4;
10458 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10459 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10464 for (i
= 0; i
< nslots
; i
++)
10466 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10468 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10471 /* PR 17531: file: a05f6ab3. */
10474 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10481 size_t num_copy
= sizeof (uint64_t);
10483 /* PR 23064: Beware of buffer overflow. */
10484 if (ph
+ num_copy
< limit
)
10485 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10488 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
10493 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10494 /* PR 17531: file: b8ce60a8. */
10495 if (prow
< poffsets
|| prow
> limit
)
10497 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
10503 printf (_(" [%3d] 0x%s"),
10504 i
, dwarf_vmatoa ("x", signature
));
10505 for (j
= 0; j
< ncols
; j
++)
10507 unsigned char *p
= prow
+ j
* 4;
10508 SAFE_BYTE_GET (val
, p
, 4, limit
);
10510 printf (" %8d", val
);
10514 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10516 /* PR 17531: file: 10796eb3. */
10517 if (dw_sect
>= DW_SECT_MAX
)
10518 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10520 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10536 printf (_(" Size table\n"));
10537 printf (" slot %-16s ",
10538 is_tu_index
? _("signature") : _("dwo_id"));
10541 for (j
= 0; j
< ncols
; j
++)
10543 unsigned char *p
= ppool
+ j
* 4;
10544 SAFE_BYTE_GET (val
, p
, 4, limit
);
10546 printf (" %8s", get_DW_SECT_short_name (val
));
10552 for (i
= 0; i
< nslots
; i
++)
10554 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10556 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10559 prow
= psizes
+ (row
- 1) * ncols
* 4;
10562 printf (_(" [%3d] 0x%s"),
10563 i
, dwarf_vmatoa ("x", signature
));
10565 for (j
= 0; j
< ncols
; j
++)
10567 unsigned char *p
= prow
+ j
* 4;
10568 SAFE_BYTE_GET (val
, p
, 4, limit
);
10570 printf (" %8d", val
);
10574 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10575 if (dw_sect
>= DW_SECT_MAX
)
10576 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10578 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10590 else if (do_display
)
10591 printf (_(" Unsupported version (%d)\n"), version
);
10599 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10601 /* Load the CU and TU indexes if present. This will build a list of
10602 section sets that we can use to associate a .debug_info.dwo section
10603 with its associated .debug_abbrev.dwo section in a .dwp file. */
10606 load_cu_tu_indexes (void *file
)
10608 /* If we have already loaded (or tried to load) the CU and TU indexes
10609 then do not bother to repeat the task. */
10610 if (cu_tu_indexes_read
== -1)
10612 cu_tu_indexes_read
= true;
10614 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10615 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10616 cu_tu_indexes_read
= false;
10618 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10619 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10620 cu_tu_indexes_read
= false;
10623 return (bool) cu_tu_indexes_read
;
10626 /* Find the set of sections that includes section SHNDX. */
10629 find_cu_tu_set (void *file
, unsigned int shndx
)
10633 if (! load_cu_tu_indexes (file
))
10636 /* Find SHNDX in the shndx pool. */
10637 for (i
= 0; i
< shndx_pool_used
; i
++)
10638 if (shndx_pool
[i
] == shndx
)
10641 if (i
>= shndx_pool_used
)
10644 /* Now backup to find the first entry in the set. */
10645 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10648 return shndx_pool
+ i
;
10651 /* Display a .debug_cu_index or .debug_tu_index section. */
10654 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10656 return process_cu_tu_index (section
, 1);
10660 display_debug_not_supported (struct dwarf_section
*section
,
10661 void *file ATTRIBUTE_UNUSED
)
10663 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10669 /* Like malloc, but takes two parameters like calloc.
10670 Verifies that the first parameter is not too large.
10671 Note: does *not* initialise the allocated memory to zero. */
10674 cmalloc (size_t nmemb
, size_t size
)
10676 /* Check for overflow. */
10677 if (nmemb
>= ~(size_t) 0 / size
)
10680 return xmalloc (nmemb
* size
);
10683 /* Like xmalloc, but takes two parameters like calloc.
10684 Verifies that the first parameter is not too large.
10685 Note: does *not* initialise the allocated memory to zero. */
10688 xcmalloc (size_t nmemb
, size_t size
)
10690 /* Check for overflow. */
10691 if (nmemb
>= ~(size_t) 0 / size
)
10694 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10699 return xmalloc (nmemb
* size
);
10702 /* Like xrealloc, but takes three parameters.
10703 Verifies that the second parameter is not too large.
10704 Note: does *not* initialise any new memory to zero. */
10707 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10709 /* Check for overflow. */
10710 if (nmemb
>= ~(size_t) 0 / size
)
10712 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10717 return xrealloc (ptr
, nmemb
* size
);
10720 /* Like xcalloc, but verifies that the first parameter is not too large. */
10723 xcalloc2 (size_t nmemb
, size_t size
)
10725 /* Check for overflow. */
10726 if (nmemb
>= ~(size_t) 0 / size
)
10728 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10733 return xcalloc (nmemb
, size
);
10736 static unsigned long
10737 calc_gnu_debuglink_crc32 (unsigned long crc
,
10738 const unsigned char * buf
,
10741 static const unsigned long crc32_table
[256] =
10743 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10744 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10745 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10746 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10747 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10748 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10749 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10750 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10751 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10752 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10753 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10754 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10755 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10756 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10757 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10758 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10759 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10760 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10761 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10762 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10763 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10764 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10765 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10766 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10767 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10768 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10769 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10770 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10771 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10772 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10773 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10774 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10775 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10776 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10777 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10778 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10779 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10780 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10781 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10782 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10783 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10784 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10785 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10786 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10787 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10788 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10789 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10790 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10791 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10792 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10793 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10796 const unsigned char *end
;
10798 crc
= ~crc
& 0xffffffff;
10799 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10800 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10801 return ~crc
& 0xffffffff;
10804 typedef bool (*check_func_type
) (const char *, void *);
10805 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
10808 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10810 static unsigned char buffer
[8 * 1024];
10812 bfd_size_type count
;
10813 unsigned long crc
= 0;
10816 sep_data
= open_debug_file (pathname
);
10817 if (sep_data
== NULL
)
10820 /* Yes - we are opening the file twice... */
10821 f
= fopen (pathname
, "rb");
10824 /* Paranoia: This should never happen. */
10825 close_debug_file (sep_data
);
10826 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10830 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10831 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10835 if (crc
!= * (unsigned long *) crc_pointer
)
10837 close_debug_file (sep_data
);
10838 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10846 static const char *
10847 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10850 unsigned int crc_offset
;
10851 unsigned long * crc32
= (unsigned long *) data
;
10853 /* The name is first.
10854 The CRC value is stored after the filename, aligned up to 4 bytes. */
10855 name
= (const char *) section
->start
;
10857 crc_offset
= strnlen (name
, section
->size
) + 1;
10858 if (crc_offset
== 1)
10860 crc_offset
= (crc_offset
+ 3) & ~3;
10861 if (crc_offset
+ 4 > section
->size
)
10864 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10869 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10871 void * sep_data
= open_debug_file (filename
);
10873 if (sep_data
== NULL
)
10876 /* FIXME: We should now extract the build-id in the separate file
10882 typedef struct build_id_data
10885 const unsigned char * data
;
10888 static const char *
10889 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10892 bfd_size_type namelen
;
10893 bfd_size_type id_len
;
10894 Build_id_data
* build_id_data
;
10896 /* The name is first.
10897 The build-id follows immediately, with no padding, up to the section's end. */
10899 name
= (const char *) section
->start
;
10900 namelen
= strnlen (name
, section
->size
) + 1;
10903 if (namelen
>= section
->size
)
10906 id_len
= section
->size
- namelen
;
10910 build_id_data
= (Build_id_data
*) data
;
10911 build_id_data
->len
= id_len
;
10912 build_id_data
->data
= section
->start
+ namelen
;
10918 add_separate_debug_file (const char * filename
, void * handle
)
10920 separate_info
* i
= xmalloc (sizeof * i
);
10922 i
->filename
= filename
;
10923 i
->handle
= handle
;
10924 i
->next
= first_separate_info
;
10925 first_separate_info
= i
;
10928 #if HAVE_LIBDEBUGINFOD
10929 /* Query debuginfod servers for the target debuglink or debugaltlink
10930 file. If successful, store the path of the file in filename and
10931 return TRUE, otherwise return FALSE. */
10934 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10938 size_t build_id_len
;
10939 unsigned char * build_id
;
10941 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10943 /* Get the build-id of file. */
10944 build_id
= get_build_id (file
);
10947 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10949 /* Get the build-id of the debugaltlink file. */
10950 unsigned int filelen
;
10952 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10953 if (filelen
== section
->size
)
10954 /* Corrupt debugaltlink. */
10957 build_id
= section
->start
+ filelen
+ 1;
10958 build_id_len
= section
->size
- (filelen
+ 1);
10960 if (build_id_len
== 0)
10969 debuginfod_client
* client
;
10971 client
= debuginfod_begin ();
10972 if (client
== NULL
)
10975 /* Query debuginfod servers for the target file. If found its path
10976 will be stored in filename. */
10977 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10978 debuginfod_end (client
);
10980 /* Only free build_id if we allocated space for a hex string
10981 in get_build_id (). */
10982 if (build_id_len
== 0)
10987 /* File successfully retrieved. Close fd since we want to
10988 use open_debug_file () on filename instead. */
10999 load_separate_debug_info (const char * main_filename
,
11000 struct dwarf_section
* xlink
,
11001 parse_func_type parse_func
,
11002 check_func_type check_func
,
11004 void * file ATTRIBUTE_UNUSED
)
11006 const char * separate_filename
;
11007 char * debug_filename
;
11009 size_t canon_dirlen
;
11012 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11014 warn (_("Corrupt debuglink section: %s\n"),
11015 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11019 /* Attempt to locate the separate file.
11020 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11022 canon_dir
= lrealpath (main_filename
);
11024 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11025 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11027 canon_dir
[canon_dirlen
] = '\0';
11030 #define DEBUGDIR "/lib/debug"
11032 #ifndef EXTRA_DEBUG_ROOT1
11033 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11035 #ifndef EXTRA_DEBUG_ROOT2
11036 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11039 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11041 + strlen (".debug/")
11042 #ifdef EXTRA_DEBUG_ROOT1
11043 + strlen (EXTRA_DEBUG_ROOT1
)
11045 #ifdef EXTRA_DEBUG_ROOT2
11046 + strlen (EXTRA_DEBUG_ROOT2
)
11048 + strlen (separate_filename
)
11050 if (debug_filename
== NULL
)
11052 warn (_("Out of memory"));
11057 /* First try in the current directory. */
11058 sprintf (debug_filename
, "%s", separate_filename
);
11059 if (check_func (debug_filename
, func_data
))
11062 /* Then try in a subdirectory called .debug. */
11063 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11064 if (check_func (debug_filename
, func_data
))
11067 /* Then try in the same directory as the original file. */
11068 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11069 if (check_func (debug_filename
, func_data
))
11072 /* And the .debug subdirectory of that directory. */
11073 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11074 if (check_func (debug_filename
, func_data
))
11077 #ifdef EXTRA_DEBUG_ROOT1
11078 /* Try the first extra debug file root. */
11079 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11080 if (check_func (debug_filename
, func_data
))
11083 /* Try the first extra debug file root. */
11084 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11085 if (check_func (debug_filename
, func_data
))
11089 #ifdef EXTRA_DEBUG_ROOT2
11090 /* Try the second extra debug file root. */
11091 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11092 if (check_func (debug_filename
, func_data
))
11096 /* Then try in the global debug_filename directory. */
11097 strcpy (debug_filename
, DEBUGDIR
);
11098 dirlen
= strlen (DEBUGDIR
) - 1;
11099 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11100 strcat (debug_filename
, "/");
11101 strcat (debug_filename
, (const char *) separate_filename
);
11103 if (check_func (debug_filename
, func_data
))
11106 #if HAVE_LIBDEBUGINFOD
11108 char * tmp_filename
;
11110 if (debuginfod_fetch_separate_debug_info (xlink
,
11114 /* File successfully downloaded from server, replace
11115 debug_filename with the file's path. */
11116 free (debug_filename
);
11117 debug_filename
= tmp_filename
;
11123 if (do_debug_links
)
11125 /* Failed to find the file. */
11126 warn (_("could not find separate debug file '%s'\n"),
11127 separate_filename
);
11128 warn (_("tried: %s\n"), debug_filename
);
11130 #ifdef EXTRA_DEBUG_ROOT2
11131 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11132 separate_filename
);
11133 warn (_("tried: %s\n"), debug_filename
);
11136 #ifdef EXTRA_DEBUG_ROOT1
11137 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11138 canon_dir
, separate_filename
);
11139 warn (_("tried: %s\n"), debug_filename
);
11141 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11142 separate_filename
);
11143 warn (_("tried: %s\n"), debug_filename
);
11146 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11147 separate_filename
);
11148 warn (_("tried: %s\n"), debug_filename
);
11150 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11151 warn (_("tried: %s\n"), debug_filename
);
11153 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11154 warn (_("tried: %s\n"), debug_filename
);
11156 sprintf (debug_filename
, "%s", separate_filename
);
11157 warn (_("tried: %s\n"), debug_filename
);
11159 #if HAVE_LIBDEBUGINFOD
11161 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11165 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11171 free (debug_filename
);
11177 void * debug_handle
;
11179 /* Now open the file.... */
11180 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11182 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11183 free (debug_filename
);
11187 /* FIXME: We do not check to see if there are any other separate debug info
11188 files that would also match. */
11190 if (do_debug_links
)
11191 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11192 add_separate_debug_file (debug_filename
, debug_handle
);
11194 /* Do not free debug_filename - it might be referenced inside
11195 the structure returned by open_debug_file(). */
11196 return debug_handle
;
11199 /* Attempt to load a separate dwarf object file. */
11202 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11204 char * separate_filename
;
11205 void * separate_handle
;
11207 if (IS_ABSOLUTE_PATH (name
))
11208 separate_filename
= strdup (name
);
11210 /* FIXME: Skip adding / if dwo_dir ends in /. */
11211 separate_filename
= concat (dir
, "/", name
, NULL
);
11212 if (separate_filename
== NULL
)
11214 warn (_("Out of memory allocating dwo filename\n"));
11218 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11220 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11221 free (separate_filename
);
11225 /* FIXME: We should check the dwo_id. */
11227 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11229 add_separate_debug_file (separate_filename
, separate_handle
);
11230 /* Note - separate_filename will be freed in free_debug_memory(). */
11231 return separate_handle
;
11235 load_debug_sup_file (const char * main_filename
, void * file
)
11237 if (! load_debug_section (debug_sup
, file
))
11238 return; /* No .debug_sup section. */
11240 struct dwarf_section
* section
;
11241 section
= & debug_displays
[debug_sup
].section
;
11242 assert (section
!= NULL
);
11244 if (section
->start
== NULL
|| section
->size
< 5)
11246 warn (_(".debug_sup section is corrupt/empty\n"));
11250 if (section
->start
[2] != 0)
11251 return; /* This is a supplementary file. */
11253 const char * filename
= (const char *) section
->start
+ 3;
11254 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11256 warn (_("filename in .debug_sup section is corrupt\n"));
11260 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11265 new_len
= asprintf (& new_name
, "%.*s/%s",
11266 (int) (strrchr (main_filename
, '/') - main_filename
),
11271 warn (_("unable to construct path for supplementary debug file"));
11276 filename
= new_name
;
11280 /* PR 27796: Make sure that we pass a filename that can be free'd to
11281 add_separate_debug_file(). */
11282 filename
= strdup (filename
);
11283 if (filename
== NULL
)
11285 warn (_("out of memory constructing filename for .debug_sup link\n"));
11290 void * handle
= open_debug_file (filename
);
11291 if (handle
== NULL
)
11293 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11294 free ((void *) filename
);
11298 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11300 /* FIXME: Compare the checksums, if present. */
11301 add_separate_debug_file (filename
, handle
);
11304 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11305 Recursively check the loaded files for more of these sections.
11306 Also follow any links in .debug_sup sections.
11307 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11310 check_for_and_load_links (void * file
, const char * filename
)
11312 void * handle
= NULL
;
11314 if (load_debug_section (gnu_debugaltlink
, file
))
11316 Build_id_data build_id_data
;
11318 handle
= load_separate_debug_info (filename
,
11319 & debug_displays
[gnu_debugaltlink
].section
,
11320 parse_gnu_debugaltlink
,
11321 check_gnu_debugaltlink
,
11326 assert (handle
== first_separate_info
->handle
);
11327 check_for_and_load_links (first_separate_info
->handle
,
11328 first_separate_info
->filename
);
11332 if (load_debug_section (gnu_debuglink
, file
))
11334 unsigned long crc32
;
11336 handle
= load_separate_debug_info (filename
,
11337 & debug_displays
[gnu_debuglink
].section
,
11338 parse_gnu_debuglink
,
11339 check_gnu_debuglink
,
11344 assert (handle
== first_separate_info
->handle
);
11345 check_for_and_load_links (first_separate_info
->handle
,
11346 first_separate_info
->filename
);
11350 load_debug_sup_file (filename
, file
);
11353 /* Load the separate debug info file(s) attached to FILE, if any exist.
11354 Returns TRUE if any were found, FALSE otherwise.
11355 If TRUE is returned then the linked list starting at first_separate_info
11356 will be populated with open file handles. */
11359 load_separate_debug_files (void * file
, const char * filename
)
11361 /* Skip this operation if we are not interested in debug links. */
11362 if (! do_follow_links
&& ! do_debug_links
)
11365 /* See if there are any dwo links. */
11366 if (load_debug_section (str
, file
)
11367 && load_debug_section (abbrev
, file
)
11368 && load_debug_section (info
, file
))
11372 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11375 bool introduced
= false;
11377 const char *dir
= NULL
;
11378 const char *id
= NULL
;
11379 const char *name
= NULL
;
11381 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11383 /* Accumulate NAME, DIR and ID fields. */
11384 switch (dwinfo
->type
)
11388 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11389 name
= dwinfo
->value
;
11393 /* There can be multiple DW_AT_comp_dir entries in a CU,
11394 so do not complain. */
11395 dir
= dwinfo
->value
;
11400 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11401 id
= dwinfo
->value
;
11405 error (_("Unexpected DWO INFO type"));
11409 /* If we have reached the end of our list, or we are changing
11410 CUs, then display the information that we have accumulated
11413 && (dwinfo
->next
== NULL
11414 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11416 if (do_debug_links
)
11420 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11421 debug_displays
[info
].section
.uncompressed_name
);
11425 printf (_(" Name: %s\n"), name
);
11426 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11428 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11430 printf (_(" ID: <not specified>\n"));
11434 if (do_follow_links
)
11435 load_dwo_file (filename
, name
, dir
, id
);
11437 name
= dir
= id
= NULL
;
11443 if (! do_follow_links
)
11444 /* The other debug links will be displayed by display_debug_links()
11445 so we do not need to do any further processing here. */
11448 /* FIXME: We do not check for the presence of both link sections in the same file. */
11449 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11450 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11452 check_for_and_load_links (file
, filename
);
11453 if (first_separate_info
!= NULL
)
11456 do_follow_links
= 0;
11461 free_debug_memory (void)
11465 free_all_abbrevs ();
11467 free (cu_abbrev_map
);
11468 cu_abbrev_map
= NULL
;
11469 next_free_abbrev_map_entry
= 0;
11473 shndx_pool_size
= 0;
11474 shndx_pool_used
= 0;
11482 memset (level_type_signed
, 0, sizeof level_type_signed
);
11483 cu_tu_indexes_read
= -1;
11485 for (i
= 0; i
< max
; i
++)
11486 free_debug_section ((enum dwarf_section_display_enum
) i
);
11488 if (debug_information
!= NULL
)
11490 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11492 if (debug_information
[i
].max_loc_offsets
)
11494 free (debug_information
[i
].loc_offsets
);
11495 free (debug_information
[i
].have_frame_base
);
11497 if (debug_information
[i
].max_range_lists
)
11498 free (debug_information
[i
].range_lists
);
11500 free (debug_information
);
11501 debug_information
= NULL
;
11502 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11506 separate_info
* next
;
11508 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11510 close_debug_file (d
->handle
);
11511 free ((void *) d
->filename
);
11515 first_separate_info
= NULL
;
11521 dwarf_select_sections_by_names (const char *names
)
11525 const char * option
;
11529 debug_dump_long_opts
;
11531 static const debug_dump_long_opts opts_table
[] =
11533 /* Please keep this table alpha- sorted. */
11534 { "Ranges", & do_debug_ranges
, 1 },
11535 { "abbrev", & do_debug_abbrevs
, 1 },
11536 { "addr", & do_debug_addr
, 1 },
11537 { "aranges", & do_debug_aranges
, 1 },
11538 { "cu_index", & do_debug_cu_index
, 1 },
11539 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11540 { "follow-links", & do_follow_links
, 1 },
11541 { "frames", & do_debug_frames
, 1 },
11542 { "frames-interp", & do_debug_frames_interp
, 1 },
11543 /* The special .gdb_index section. */
11544 { "gdb_index", & do_gdb_index
, 1 },
11545 { "info", & do_debug_info
, 1 },
11546 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11547 { "links", & do_debug_links
, 1 },
11548 { "loc", & do_debug_loc
, 1 },
11549 { "macro", & do_debug_macinfo
, 1 },
11550 { "no-follow-links", & do_follow_links
, 0 },
11551 { "pubnames", & do_debug_pubnames
, 1 },
11552 { "pubtypes", & do_debug_pubtypes
, 1 },
11553 /* This entry is for compatibility
11554 with earlier versions of readelf. */
11555 { "ranges", & do_debug_aranges
, 1 },
11556 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11557 { "str", & do_debug_str
, 1 },
11558 { "str-offsets", & do_debug_str_offsets
, 1 },
11559 /* These trace_* sections are used by Itanium VMS. */
11560 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11561 { "trace_aranges", & do_trace_aranges
, 1 },
11562 { "trace_info", & do_trace_info
, 1 },
11571 const debug_dump_long_opts
* entry
;
11573 for (entry
= opts_table
; entry
->option
; entry
++)
11575 size_t len
= strlen (entry
->option
);
11577 if (strncmp (p
, entry
->option
, len
) == 0
11578 && (p
[len
] == ',' || p
[len
] == '\0'))
11580 * entry
->variable
= entry
->val
;
11582 /* The --debug-dump=frames-interp option also
11583 enables the --debug-dump=frames option. */
11584 if (do_debug_frames_interp
)
11585 do_debug_frames
= 1;
11592 if (entry
->option
== NULL
)
11594 warn (_("Unrecognized debug option '%s'\n"), p
);
11595 p
= strchr (p
, ',');
11606 dwarf_select_sections_by_letters (const char *letters
)
11608 unsigned int lindex
= 0;
11610 while (letters
[lindex
])
11611 switch (letters
[lindex
++])
11613 case 'A': do_debug_addr
= 1; break;
11614 case 'a': do_debug_abbrevs
= 1; break;
11615 case 'c': do_debug_cu_index
= 1; break;
11616 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11617 case 'f': do_debug_frames
= 1; break;
11618 case 'g': do_gdb_index
= 1; break;
11619 case 'i': do_debug_info
= 1; break;
11620 case 'K': do_follow_links
= 1; break;
11621 case 'N': do_follow_links
= 0; break;
11622 case 'k': do_debug_links
= 1; break;
11623 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11624 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11625 case 'm': do_debug_macinfo
= 1; break;
11626 case 'O': do_debug_str_offsets
= 1; break;
11627 case 'o': do_debug_loc
= 1; break;
11628 case 'p': do_debug_pubnames
= 1; break;
11629 case 'R': do_debug_ranges
= 1; break;
11630 case 'r': do_debug_aranges
= 1; break;
11631 case 's': do_debug_str
= 1; break;
11632 case 'T': do_trace_aranges
= 1; break;
11633 case 't': do_debug_pubtypes
= 1; break;
11634 case 'U': do_trace_info
= 1; break;
11635 case 'u': do_trace_abbrevs
= 1; break;
11638 warn (_("Unrecognized debug option '%s'\n"), letters
);
11644 dwarf_select_sections_all (void)
11647 do_debug_abbrevs
= 1;
11648 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11649 do_debug_pubnames
= 1;
11650 do_debug_pubtypes
= 1;
11651 do_debug_aranges
= 1;
11652 do_debug_ranges
= 1;
11653 do_debug_frames
= 1;
11654 do_debug_macinfo
= 1;
11659 do_trace_abbrevs
= 1;
11660 do_trace_aranges
= 1;
11662 do_debug_cu_index
= 1;
11663 do_follow_links
= 1;
11664 do_debug_links
= 1;
11665 do_debug_str_offsets
= 1;
11668 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
11669 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
11671 /* N.B. The order here must match the order in section_display_enum. */
11673 struct dwarf_section_display debug_displays
[] =
11675 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11676 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
11677 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11678 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
11679 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11680 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
11681 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
11682 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11683 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11684 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11685 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11686 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11687 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11688 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11689 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
11690 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
11691 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11692 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11693 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11694 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11695 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
11696 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11697 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
11698 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
11699 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
11700 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
11701 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
11702 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
11703 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11704 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
11705 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11706 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11707 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11708 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11709 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
11710 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11711 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11712 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
11713 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11714 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11715 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11716 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11717 { { ".debug_sup", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
11718 /* Separate debug info files can containt their own .debug_str section,
11719 and this might be in *addition* to a .debug_str section already present
11720 in the main file. Hence we need to have two entries for .debug_str. */
11721 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11724 /* A static assertion. */
11725 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];