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>
48 #define MAX(a, b) ((a) > (b) ? (a) : (b))
49 #define MIN(a, b) ((a) < (b) ? (a) : (b))
51 static const char *regname (unsigned int regno
, int row
);
52 static const char *regname_internal_by_table_only (unsigned int regno
);
54 static int have_frame_base
;
55 static int need_base_address
;
57 static unsigned int num_debug_info_entries
= 0;
58 static unsigned int alloc_num_debug_info_entries
= 0;
59 static debug_info
*debug_information
= NULL
;
60 /* Special value for num_debug_info_entries to indicate
61 that the .debug_info section could not be loaded/parsed. */
62 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
64 /* A .debug_info section can contain multiple links to separate
65 DWO object files. We use these structures to record these links. */
73 typedef struct dwo_info
78 struct dwo_info
* next
;
81 static dwo_info
* first_dwo_info
= NULL
;
82 static bfd_boolean need_dwo_info
;
84 separate_info
* first_separate_info
= NULL
;
86 unsigned int eh_addr_size
;
91 int do_debug_pubnames
;
92 int do_debug_pubtypes
;
96 int do_debug_frames_interp
;
99 int do_debug_str_offsets
;
103 int do_trace_abbrevs
;
104 int do_trace_aranges
;
106 int do_debug_cu_index
;
109 int do_follow_links
= DEFAULT_FOR_FOLLOW_LINKS
;
110 bfd_boolean do_checks
;
112 int dwarf_cutoff_level
= -1;
113 unsigned long dwarf_start_die
;
117 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
118 testing whether e.g. a locview list is present. */
119 static const dwarf_vma vm1
= -1;
121 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
122 sections. For version 1 package files, each set is stored in SHNDX_POOL
123 as a zero-terminated list of section indexes comprising one set of debug
124 sections from a .dwo file. */
126 static unsigned int *shndx_pool
= NULL
;
127 static unsigned int shndx_pool_size
= 0;
128 static unsigned int shndx_pool_used
= 0;
130 /* For version 2 package files, each set contains an array of section offsets
131 and an array of section sizes, giving the offset and size of the
132 contribution from a CU or TU within one of the debug sections.
133 When displaying debug info from a package file, we need to use these
134 tables to locate the corresponding contributions to each section. */
139 dwarf_vma section_offsets
[DW_SECT_MAX
];
140 size_t section_sizes
[DW_SECT_MAX
];
143 static int cu_count
= 0;
144 static int tu_count
= 0;
145 static struct cu_tu_set
*cu_sets
= NULL
;
146 static struct cu_tu_set
*tu_sets
= NULL
;
148 static bfd_boolean
load_cu_tu_indexes (void *);
150 /* An array that indicates for a given level of CU nesting whether
151 the latest DW_AT_type seen for that level was a signed type or
153 #define MAX_CU_NESTING (1 << 8)
154 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
156 /* Values for do_debug_lines. */
157 #define FLAG_DEBUG_LINES_RAW 1
158 #define FLAG_DEBUG_LINES_DECODED 2
161 size_of_encoded_value (int encoding
)
163 switch (encoding
& 0x7)
166 case 0: return eh_addr_size
;
174 get_encoded_value (unsigned char **pdata
,
176 struct dwarf_section
*section
,
179 unsigned char * data
= * pdata
;
180 unsigned int size
= size_of_encoded_value (encoding
);
183 if (data
+ size
>= end
)
185 warn (_("Encoded value extends past end of section\n"));
190 /* PR 17512: file: 002-829853-0.004. */
193 warn (_("Encoded size of %d is too large to read\n"), size
);
198 /* PR 17512: file: 1085-5603-0.004. */
201 warn (_("Encoded size of 0 is too small to read\n"));
206 if (encoding
& DW_EH_PE_signed
)
207 val
= byte_get_signed (data
, size
);
209 val
= byte_get (data
, size
);
211 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
212 val
+= section
->address
+ (data
- section
->start
);
214 * pdata
= data
+ size
;
218 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
220 # define DWARF_VMA_FMT "ll"
221 # define DWARF_VMA_FMT_LONG "%16.16llx"
223 # define DWARF_VMA_FMT "I64"
224 # define DWARF_VMA_FMT_LONG "%016I64x"
227 # define DWARF_VMA_FMT "l"
228 # define DWARF_VMA_FMT_LONG "%16.16lx"
231 /* Convert a dwarf vma value into a string. Returns a pointer to a static
232 buffer containing the converted VALUE. The value is converted according
233 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
234 it specifies the maximum number of bytes to be displayed in the converted
235 value and FMTCH is ignored - hex is always used. */
238 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
240 /* As dwarf_vmatoa is used more then once in a printf call
241 for output, we are cycling through an fixed array of pointers
242 for return address. */
243 static int buf_pos
= 0;
244 static struct dwarf_vmatoa_buf
250 ret
= buf
[buf_pos
++].place
;
251 buf_pos
%= ARRAY_SIZE (buf
);
255 /* Printf does not have a way of specifying a maximum field width for an
256 integer value, so we print the full value into a buffer and then select
257 the precision we need. */
258 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
261 return ret
+ (16 - 2 * num_bytes
);
268 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
270 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
271 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
276 static inline const char *
277 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
279 return dwarf_vmatoa_1 (fmtch
, value
, 0);
282 /* Print a dwarf_vma value (typically an address, offset or length) in
283 hexadecimal format, followed by a space. The length of the VALUE (and
284 hence the precision displayed) is determined by the NUM_BYTES parameter. */
287 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
289 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
292 /* Print a view number in hexadecimal value, with the same width
293 print_dwarf_vma would have printed it with the same num_bytes.
294 Print blanks for zero view, unless force is nonzero. */
297 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
305 assert (value
== (unsigned long) value
);
307 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
309 printf ("%*s", len
+ 1, "");
312 /* Format a 64-bit value, given as two 32-bit values, in hex.
313 For reentrancy, this uses a buffer provided by the caller. */
316 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
317 unsigned int buf_len
)
322 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
325 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
326 snprintf (buf
+ len
, buf_len
- len
,
327 "%08" DWARF_VMA_FMT
"x", lvalue
);
333 /* Read in a LEB128 encoded value starting at address DATA.
334 If SIGN is true, return a signed LEB128 value.
335 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
336 If STATUS_RETURN is not NULL, return with bit 0 (LSB) set if the
337 terminating byte was not found and with bit 1 set if the value
338 overflows a dwarf_vma.
339 No bytes will be read at address END or beyond. */
342 read_leb128 (unsigned char *data
,
343 const unsigned char *const end
,
345 unsigned int *length_return
,
348 dwarf_vma result
= 0;
349 unsigned int num_read
= 0;
350 unsigned int shift
= 0;
355 unsigned char byte
= *data
++;
356 unsigned char lost
, mask
;
360 if (shift
< CHAR_BIT
* sizeof (result
))
362 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
363 /* These bits overflowed. */
364 lost
= byte
^ (result
>> shift
);
365 /* And this is the mask of possible overflow bits. */
366 mask
= 0x7f ^ ((dwarf_vma
) 0x7f << shift
>> shift
);
374 if ((lost
& mask
) != (sign
&& (dwarf_signed_vma
) result
< 0 ? mask
: 0))
377 if ((byte
& 0x80) == 0)
380 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
381 result
|= -((dwarf_vma
) 1 << shift
);
386 if (length_return
!= NULL
)
387 *length_return
= num_read
;
388 if (status_return
!= NULL
)
389 *status_return
= status
;
394 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
395 Checks to make sure that the read will not reach or pass END
396 and that VAL is big enough to hold AMOUNT bytes. */
397 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
400 unsigned int amount = (AMOUNT); \
401 if (sizeof (VAL) < amount) \
403 error (ngettext ("internal error: attempt to read %d byte " \
404 "of data in to %d sized variable", \
405 "internal error: attempt to read %d bytes " \
406 "of data in to %d sized variable", \
408 amount, (int) sizeof (VAL)); \
409 amount = sizeof (VAL); \
411 if (((PTR) + amount) >= (END)) \
414 amount = (END) - (PTR); \
418 if (amount == 0 || amount > 8) \
421 VAL = byte_get ((PTR), amount); \
425 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
426 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
429 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
434 /* Like SAFE_BYTE_GET, but reads a signed value. */
435 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
438 unsigned int amount = (AMOUNT); \
439 if (((PTR) + amount) >= (END)) \
442 amount = (END) - (PTR); \
447 VAL = byte_get_signed ((PTR), amount); \
453 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
454 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
457 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
462 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
465 if (((PTR) + 8) <= (END)) \
467 byte_get_64 ((PTR), (HIGH), (LOW)); \
471 * (LOW) = * (HIGH) = 0; \
476 typedef struct State_Machine_Registers
485 unsigned char op_index
;
486 unsigned char end_sequence
;
487 /* This variable hold the number of the last entry seen
488 in the File Table. */
489 unsigned int last_file_entry
;
492 static SMR state_machine_regs
;
495 reset_state_machine (int is_stmt
)
497 state_machine_regs
.address
= 0;
498 state_machine_regs
.view
= 0;
499 state_machine_regs
.op_index
= 0;
500 state_machine_regs
.file
= 1;
501 state_machine_regs
.line
= 1;
502 state_machine_regs
.column
= 0;
503 state_machine_regs
.is_stmt
= is_stmt
;
504 state_machine_regs
.basic_block
= 0;
505 state_machine_regs
.end_sequence
= 0;
506 state_machine_regs
.last_file_entry
= 0;
509 /* Handled an extend line op.
510 Returns the number of bytes read. */
513 process_extended_line_op (unsigned char * data
,
517 unsigned char op_code
;
518 size_t len
, header_len
;
520 unsigned char *orig_data
= data
;
523 READ_ULEB (len
, data
, end
);
524 header_len
= data
- orig_data
;
526 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
528 warn (_("Badly formed extended line op encountered!\n"));
534 printf (_(" Extended opcode %d: "), op_code
);
538 case DW_LNE_end_sequence
:
539 printf (_("End of Sequence\n\n"));
540 reset_state_machine (is_stmt
);
543 case DW_LNE_set_address
:
544 /* PR 17512: file: 002-100480-0.004. */
547 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
548 (unsigned long) len
- 1);
552 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
553 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
554 state_machine_regs
.address
= adr
;
555 state_machine_regs
.view
= 0;
556 state_machine_regs
.op_index
= 0;
559 case DW_LNE_define_file
:
560 printf (_("define new File Table entry\n"));
561 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
562 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
568 l
= strnlen ((char *) data
, end
- data
);
570 READ_ULEB (val
, data
, end
);
571 printf ("%s\t", dwarf_vmatoa ("u", val
));
572 READ_ULEB (val
, data
, end
);
573 printf ("%s\t", dwarf_vmatoa ("u", val
));
574 READ_ULEB (val
, data
, end
);
575 printf ("%s\t", dwarf_vmatoa ("u", val
));
576 printf ("%.*s\n\n", (int) l
, name
);
579 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
580 warn (_("DW_LNE_define_file: Bad opcode length\n"));
583 case DW_LNE_set_discriminator
:
584 READ_ULEB (val
, data
, end
);
585 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
589 case DW_LNE_HP_negate_is_UV_update
:
590 printf ("DW_LNE_HP_negate_is_UV_update\n");
592 case DW_LNE_HP_push_context
:
593 printf ("DW_LNE_HP_push_context\n");
595 case DW_LNE_HP_pop_context
:
596 printf ("DW_LNE_HP_pop_context\n");
598 case DW_LNE_HP_set_file_line_column
:
599 printf ("DW_LNE_HP_set_file_line_column\n");
601 case DW_LNE_HP_set_routine_name
:
602 printf ("DW_LNE_HP_set_routine_name\n");
604 case DW_LNE_HP_set_sequence
:
605 printf ("DW_LNE_HP_set_sequence\n");
607 case DW_LNE_HP_negate_post_semantics
:
608 printf ("DW_LNE_HP_negate_post_semantics\n");
610 case DW_LNE_HP_negate_function_exit
:
611 printf ("DW_LNE_HP_negate_function_exit\n");
613 case DW_LNE_HP_negate_front_end_logical
:
614 printf ("DW_LNE_HP_negate_front_end_logical\n");
616 case DW_LNE_HP_define_proc
:
617 printf ("DW_LNE_HP_define_proc\n");
619 case DW_LNE_HP_source_file_correlation
:
621 unsigned char *edata
= data
+ len
- 1;
623 printf ("DW_LNE_HP_source_file_correlation\n");
629 READ_ULEB (opc
, data
, edata
);
633 case DW_LNE_HP_SFC_formfeed
:
634 printf (" DW_LNE_HP_SFC_formfeed\n");
636 case DW_LNE_HP_SFC_set_listing_line
:
637 READ_ULEB (val
, data
, edata
);
638 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
639 dwarf_vmatoa ("u", val
));
641 case DW_LNE_HP_SFC_associate
:
642 printf (" DW_LNE_HP_SFC_associate ");
643 READ_ULEB (val
, data
, edata
);
644 printf ("(%s", dwarf_vmatoa ("u", val
));
645 READ_ULEB (val
, data
, edata
);
646 printf (",%s", dwarf_vmatoa ("u", val
));
647 READ_ULEB (val
, data
, edata
);
648 printf (",%s)\n", dwarf_vmatoa ("u", val
));
651 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
661 unsigned int rlen
= len
- 1;
663 if (op_code
>= DW_LNE_lo_user
664 /* The test against DW_LNW_hi_user is redundant due to
665 the limited range of the unsigned char data type used
667 /*&& op_code <= DW_LNE_hi_user*/)
668 printf (_("user defined: "));
670 printf (_("UNKNOWN: "));
671 printf (_("length %d ["), rlen
);
673 printf (" %02x", *data
++);
679 return len
+ header_len
;
682 static const unsigned char *
683 fetch_indirect_string (dwarf_vma offset
)
685 struct dwarf_section
*section
= &debug_displays
[str
].section
;
686 const unsigned char * ret
;
688 if (section
->start
== NULL
)
689 return (const unsigned char *) _("<no .debug_str section>");
691 if (offset
>= section
->size
)
693 warn (_("DW_FORM_strp offset too big: 0x%s\n"),
694 dwarf_vmatoa ("x", offset
));
695 return (const unsigned char *) _("<offset is too big>");
698 ret
= section
->start
+ offset
;
699 /* Unfortunately we cannot rely upon the .debug_str section ending with a
700 NUL byte. Since our caller is expecting to receive a well formed C
701 string we test for the lack of a terminating byte here. */
702 if (strnlen ((const char *) ret
, section
->size
- offset
)
703 == section
->size
- offset
)
704 ret
= (const unsigned char *)
705 _("<no NUL byte at end of .debug_str section>");
710 static const unsigned char *
711 fetch_indirect_line_string (dwarf_vma offset
)
713 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
714 const unsigned char * ret
;
716 if (section
->start
== NULL
)
717 return (const unsigned char *) _("<no .debug_line_str section>");
719 if (offset
>= section
->size
)
721 warn (_("DW_FORM_line_strp offset too big: 0x%s\n"),
722 dwarf_vmatoa ("x", offset
));
723 return (const unsigned char *) _("<offset is too big>");
726 ret
= section
->start
+ offset
;
727 /* Unfortunately we cannot rely upon the .debug_line_str section ending
728 with a NUL byte. Since our caller is expecting to receive a well formed
729 C string we test for the lack of a terminating byte here. */
730 if (strnlen ((const char *) ret
, section
->size
- offset
)
731 == section
->size
- offset
)
732 ret
= (const unsigned char *)
733 _("<no NUL byte at end of .debug_line_str section>");
739 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
740 dwarf_vma offset_size
, bfd_boolean dwo
)
742 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
743 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
744 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
745 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
746 dwarf_vma index_offset
;
747 dwarf_vma str_offset
;
749 unsigned char *curr
= index_section
->start
;
750 const unsigned char *end
= curr
+ index_section
->size
;
753 if (index_section
->start
== NULL
)
754 return (dwo
? _("<no .debug_str_offsets.dwo section>")
755 : _("<no .debug_str_offsets section>"));
757 if (str_section
->start
== NULL
)
758 return (dwo
? _("<no .debug_str.dwo section>")
759 : _("<no .debug_str section>"));
761 /* FIXME: We should cache the length... */
762 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
763 if (length
== 0xffffffff)
765 if (offset_size
!= 8)
766 warn (_("Expected offset size of 8 but given %s"), dwarf_vmatoa ("x", offset_size
));
767 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
769 else if (offset_size
!= 4)
771 warn (_("Expected offset size of 4 but given %s"), dwarf_vmatoa ("x", offset_size
));
776 /* This is probably an old style .debug_str_offset section which
777 just contains offsets and no header (and the first offset is 0). */
778 curr
= index_section
->start
;
779 length
= index_section
->size
;
783 /* Skip the version and padding bytes.
784 We assume that they are correct. */
787 /* FIXME: The code below assumes that there is only one table
788 in the .debug_str_offsets section, so check that now. */
789 if ((offset_size
== 4 && curr
+ length
< (end
- 8))
790 || (offset_size
== 8 && curr
+ length
< (end
- 16)))
792 warn (_("index table size is too small %s vs %s\n"),
793 dwarf_vmatoa ("x", length
),
794 dwarf_vmatoa ("x", index_section
->size
));
795 return _("<table too small>");
799 index_offset
= idx
* offset_size
;
801 if (this_set
!= NULL
)
802 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
804 if (index_offset
>= length
)
806 warn (_("DW_FORM_GNU_str_index offset too big: 0x%s vs 0x%s\n"),
807 dwarf_vmatoa ("x", index_offset
),
808 dwarf_vmatoa ("x", length
));
809 return _("<index offset is too big>");
812 str_offset
= byte_get (curr
+ index_offset
, offset_size
);
813 str_offset
-= str_section
->address
;
814 if (str_offset
>= str_section
->size
)
816 warn (_("DW_FORM_GNU_str_index indirect offset too big: 0x%s\n"),
817 dwarf_vmatoa ("x", str_offset
));
818 return _("<indirect index offset is too big>");
821 ret
= (const char *) str_section
->start
+ str_offset
;
822 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
823 Since our caller is expecting to receive a well formed C string we test
824 for the lack of a terminating byte here. */
825 if (strnlen (ret
, str_section
->size
- str_offset
)
826 == str_section
->size
- str_offset
)
827 ret
= (const char *) _("<no NUL byte at end of section>");
833 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
835 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
837 if (section
->start
== NULL
)
838 return (_("<no .debug_addr section>"));
840 if (offset
+ bytes
> section
->size
)
842 warn (_("Offset into section %s too big: 0x%s\n"),
843 section
->name
, dwarf_vmatoa ("x", offset
));
844 return "<offset too big>";
847 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
851 /* FIXME: There are better and more efficient ways to handle
852 these structures. For now though, I just want something that
853 is simple to implement. */
854 /* Records a single attribute in an abbrev. */
855 typedef struct abbrev_attr
857 unsigned long attribute
;
859 bfd_signed_vma implicit_const
;
860 struct abbrev_attr
* next
;
864 /* Records a single abbrev. */
865 typedef struct abbrev_entry
867 unsigned long number
;
870 struct abbrev_attr
* first_attr
;
871 struct abbrev_attr
* last_attr
;
872 struct abbrev_entry
* next
;
876 /* Records a set of abbreviations. */
877 typedef struct abbrev_list
879 abbrev_entry
* first_abbrev
;
880 abbrev_entry
* last_abbrev
;
881 dwarf_vma abbrev_base
;
882 dwarf_vma abbrev_offset
;
883 struct abbrev_list
* next
;
884 unsigned char * start_of_next_abbrevs
;
888 /* Records all the abbrevs found so far. */
889 static struct abbrev_list
* abbrev_lists
= NULL
;
891 typedef struct abbrev_map
898 /* Maps between CU offsets and abbrev sets. */
899 static abbrev_map
* cu_abbrev_map
= NULL
;
900 static unsigned long num_abbrev_map_entries
= 0;
901 static unsigned long next_free_abbrev_map_entry
= 0;
903 #define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
904 #define ABBREV_MAP_ENTRIES_INCREMENT 8
907 record_abbrev_list_for_cu (dwarf_vma start
, dwarf_vma end
, abbrev_list
* list
)
909 if (cu_abbrev_map
== NULL
)
911 num_abbrev_map_entries
= INITIAL_NUM_ABBREV_MAP_ENTRIES
;
912 cu_abbrev_map
= xmalloc (num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
914 else if (next_free_abbrev_map_entry
== num_abbrev_map_entries
)
916 num_abbrev_map_entries
+= ABBREV_MAP_ENTRIES_INCREMENT
;
917 cu_abbrev_map
= xrealloc (cu_abbrev_map
, num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
920 cu_abbrev_map
[next_free_abbrev_map_entry
].start
= start
;
921 cu_abbrev_map
[next_free_abbrev_map_entry
].end
= end
;
922 cu_abbrev_map
[next_free_abbrev_map_entry
].list
= list
;
923 next_free_abbrev_map_entry
++;
927 free_all_abbrevs (void)
931 for (list
= abbrev_lists
; list
!= NULL
;)
933 abbrev_list
* next
= list
->next
;
934 abbrev_entry
* abbrv
;
936 for (abbrv
= list
->first_abbrev
; abbrv
!= NULL
;)
938 abbrev_entry
* next_abbrev
= abbrv
->next
;
941 for (attr
= abbrv
->first_attr
; attr
;)
943 abbrev_attr
*next_attr
= attr
->next
;
961 new_abbrev_list (dwarf_vma abbrev_base
, dwarf_vma abbrev_offset
)
963 abbrev_list
* list
= (abbrev_list
*) xcalloc (sizeof * list
, 1);
965 list
->abbrev_base
= abbrev_base
;
966 list
->abbrev_offset
= abbrev_offset
;
968 list
->next
= abbrev_lists
;
975 find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_base
,
976 dwarf_vma abbrev_offset
)
980 for (list
= abbrev_lists
; list
!= NULL
; list
= list
->next
)
981 if (list
->abbrev_base
== abbrev_base
982 && list
->abbrev_offset
== abbrev_offset
)
988 /* Find the abbreviation map for the CU that includes OFFSET.
989 OFFSET is an absolute offset from the start of the .debug_info section. */
990 /* FIXME: This function is going to slow down readelf & objdump.
991 Consider using a better algorithm to mitigate this effect. */
994 find_abbrev_map_by_offset (dwarf_vma offset
)
998 for (i
= 0; i
< next_free_abbrev_map_entry
; i
++)
999 if (cu_abbrev_map
[i
].start
<= offset
1000 && cu_abbrev_map
[i
].end
> offset
)
1001 return cu_abbrev_map
+ i
;
1007 add_abbrev (unsigned long number
,
1012 abbrev_entry
* entry
;
1014 entry
= (abbrev_entry
*) xmalloc (sizeof (*entry
));
1016 entry
->number
= number
;
1018 entry
->children
= children
;
1019 entry
->first_attr
= NULL
;
1020 entry
->last_attr
= NULL
;
1023 assert (list
!= NULL
);
1025 if (list
->first_abbrev
== NULL
)
1026 list
->first_abbrev
= entry
;
1028 list
->last_abbrev
->next
= entry
;
1030 list
->last_abbrev
= entry
;
1034 add_abbrev_attr (unsigned long attribute
,
1036 bfd_signed_vma implicit_const
,
1041 attr
= (abbrev_attr
*) xmalloc (sizeof (*attr
));
1043 attr
->attribute
= attribute
;
1045 attr
->implicit_const
= implicit_const
;
1048 assert (list
!= NULL
&& list
->last_abbrev
!= NULL
);
1050 if (list
->last_abbrev
->first_attr
== NULL
)
1051 list
->last_abbrev
->first_attr
= attr
;
1053 list
->last_abbrev
->last_attr
->next
= attr
;
1055 list
->last_abbrev
->last_attr
= attr
;
1058 /* Processes the (partial) contents of a .debug_abbrev section.
1059 Returns NULL if the end of the section was encountered.
1060 Returns the address after the last byte read if the end of
1061 an abbreviation set was found. */
1063 static unsigned char *
1064 process_abbrev_set (unsigned char * start
,
1065 const unsigned char * end
,
1070 unsigned long entry
;
1072 unsigned long attribute
;
1075 READ_ULEB (entry
, start
, end
);
1077 /* A single zero is supposed to end the set according
1078 to the standard. If there's more, then signal that to
1085 READ_ULEB (tag
, start
, end
);
1089 children
= *start
++;
1091 add_abbrev (entry
, tag
, children
, list
);
1096 /* Initialize it due to a false compiler warning. */
1097 bfd_signed_vma implicit_const
= -1;
1099 READ_ULEB (attribute
, start
, end
);
1103 READ_ULEB (form
, start
, end
);
1107 if (form
== DW_FORM_implicit_const
)
1109 READ_SLEB (implicit_const
, start
, end
);
1114 add_abbrev_attr (attribute
, form
, implicit_const
, list
);
1116 while (attribute
!= 0);
1119 /* Report the missing single zero which ends the section. */
1120 error (_(".debug_abbrev section not zero terminated\n"));
1126 get_TAG_name (unsigned long tag
)
1128 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
1132 static char buffer
[100];
1134 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1135 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
1137 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1145 get_FORM_name (unsigned long form
)
1150 return "DW_FORM value: 0";
1152 name
= get_DW_FORM_name (form
);
1155 static char buffer
[100];
1157 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1165 get_IDX_name (unsigned long idx
)
1167 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1171 static char buffer
[100];
1173 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1180 static unsigned char *
1181 display_block (unsigned char *data
,
1183 const unsigned char * const end
, char delimiter
)
1187 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1189 return (unsigned char *) end
;
1191 maxlen
= (dwarf_vma
) (end
- data
);
1192 length
= length
> maxlen
? maxlen
: length
;
1195 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1201 decode_location_expression (unsigned char * data
,
1202 unsigned int pointer_size
,
1203 unsigned int offset_size
,
1206 dwarf_vma cu_offset
,
1207 struct dwarf_section
* section
)
1211 dwarf_signed_vma svalue
;
1212 unsigned char *end
= data
+ length
;
1213 int need_frame_base
= 0;
1222 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1223 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1226 printf ("DW_OP_deref");
1229 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1230 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1233 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1234 printf ("DW_OP_const1s: %ld", (long) svalue
);
1237 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1238 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1241 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1242 printf ("DW_OP_const2s: %ld", (long) svalue
);
1245 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1246 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1249 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1250 printf ("DW_OP_const4s: %ld", (long) svalue
);
1253 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1254 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1255 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1256 printf ("%lu", (unsigned long) uvalue
);
1259 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1260 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1261 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1262 printf ("%ld", (long) svalue
);
1265 READ_ULEB (uvalue
, data
, end
);
1266 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1269 READ_SLEB (svalue
, data
, end
);
1270 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1273 printf ("DW_OP_dup");
1276 printf ("DW_OP_drop");
1279 printf ("DW_OP_over");
1282 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1283 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1286 printf ("DW_OP_swap");
1289 printf ("DW_OP_rot");
1292 printf ("DW_OP_xderef");
1295 printf ("DW_OP_abs");
1298 printf ("DW_OP_and");
1301 printf ("DW_OP_div");
1304 printf ("DW_OP_minus");
1307 printf ("DW_OP_mod");
1310 printf ("DW_OP_mul");
1313 printf ("DW_OP_neg");
1316 printf ("DW_OP_not");
1319 printf ("DW_OP_or");
1322 printf ("DW_OP_plus");
1324 case DW_OP_plus_uconst
:
1325 READ_ULEB (uvalue
, data
, end
);
1326 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1329 printf ("DW_OP_shl");
1332 printf ("DW_OP_shr");
1335 printf ("DW_OP_shra");
1338 printf ("DW_OP_xor");
1341 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1342 printf ("DW_OP_bra: %ld", (long) svalue
);
1345 printf ("DW_OP_eq");
1348 printf ("DW_OP_ge");
1351 printf ("DW_OP_gt");
1354 printf ("DW_OP_le");
1357 printf ("DW_OP_lt");
1360 printf ("DW_OP_ne");
1363 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1364 printf ("DW_OP_skip: %ld", (long) svalue
);
1399 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1434 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1435 regname (op
- DW_OP_reg0
, 1));
1470 READ_SLEB (svalue
, data
, end
);
1471 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1472 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1476 READ_ULEB (uvalue
, data
, end
);
1477 printf ("DW_OP_regx: %s (%s)",
1478 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1481 need_frame_base
= 1;
1482 READ_SLEB (svalue
, data
, end
);
1483 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1486 READ_ULEB (uvalue
, data
, end
);
1487 READ_SLEB (svalue
, data
, end
);
1488 printf ("DW_OP_bregx: %s (%s) %s",
1489 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1490 dwarf_vmatoa ("d", svalue
));
1493 READ_ULEB (uvalue
, data
, end
);
1494 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1496 case DW_OP_deref_size
:
1497 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1498 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1500 case DW_OP_xderef_size
:
1501 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1502 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1505 printf ("DW_OP_nop");
1508 /* DWARF 3 extensions. */
1509 case DW_OP_push_object_address
:
1510 printf ("DW_OP_push_object_address");
1513 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1514 this ought to be an 8-byte wide computation. */
1515 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1516 printf ("DW_OP_call2: <0x%s>",
1517 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1520 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1521 this ought to be an 8-byte wide computation. */
1522 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1523 printf ("DW_OP_call4: <0x%s>",
1524 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1526 case DW_OP_call_ref
:
1527 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1528 this ought to be an 8-byte wide computation. */
1529 if (dwarf_version
== -1)
1531 printf (_("(DW_OP_call_ref in frame info)"));
1532 /* No way to tell where the next op is, so just bail. */
1533 return need_frame_base
;
1535 if (dwarf_version
== 2)
1537 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1541 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1543 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1545 case DW_OP_form_tls_address
:
1546 printf ("DW_OP_form_tls_address");
1548 case DW_OP_call_frame_cfa
:
1549 printf ("DW_OP_call_frame_cfa");
1551 case DW_OP_bit_piece
:
1552 printf ("DW_OP_bit_piece: ");
1553 READ_ULEB (uvalue
, data
, end
);
1554 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1555 READ_ULEB (uvalue
, data
, end
);
1556 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1559 /* DWARF 4 extensions. */
1560 case DW_OP_stack_value
:
1561 printf ("DW_OP_stack_value");
1564 case DW_OP_implicit_value
:
1565 printf ("DW_OP_implicit_value");
1566 READ_ULEB (uvalue
, data
, end
);
1567 data
= display_block (data
, uvalue
, end
, ' ');
1570 /* GNU extensions. */
1571 case DW_OP_GNU_push_tls_address
:
1572 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1574 case DW_OP_GNU_uninit
:
1575 printf ("DW_OP_GNU_uninit");
1576 /* FIXME: Is there data associated with this OP ? */
1578 case DW_OP_GNU_encoded_addr
:
1585 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1587 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1588 print_dwarf_vma (addr
, pointer_size
);
1591 case DW_OP_implicit_pointer
:
1592 case DW_OP_GNU_implicit_pointer
:
1593 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1594 this ought to be an 8-byte wide computation. */
1595 if (dwarf_version
== -1)
1597 printf (_("(%s in frame info)"),
1598 (op
== DW_OP_implicit_pointer
1599 ? "DW_OP_implicit_pointer"
1600 : "DW_OP_GNU_implicit_pointer"));
1601 /* No way to tell where the next op is, so just bail. */
1602 return need_frame_base
;
1604 if (dwarf_version
== 2)
1606 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1610 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1612 READ_SLEB (svalue
, data
, end
);
1613 printf ("%s: <0x%s> %s",
1614 (op
== DW_OP_implicit_pointer
1615 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1616 dwarf_vmatoa ("x", uvalue
),
1617 dwarf_vmatoa ("d", svalue
));
1619 case DW_OP_entry_value
:
1620 case DW_OP_GNU_entry_value
:
1621 READ_ULEB (uvalue
, data
, end
);
1622 /* PR 17531: file: 0cc9cd00. */
1623 if (uvalue
> (dwarf_vma
) (end
- data
))
1624 uvalue
= end
- data
;
1625 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1626 : "DW_OP_GNU_entry_value"));
1627 if (decode_location_expression (data
, pointer_size
, offset_size
,
1628 dwarf_version
, uvalue
,
1629 cu_offset
, section
))
1630 need_frame_base
= 1;
1636 case DW_OP_const_type
:
1637 case DW_OP_GNU_const_type
:
1638 READ_ULEB (uvalue
, data
, end
);
1639 printf ("%s: <0x%s> ",
1640 (op
== DW_OP_const_type
? "DW_OP_const_type"
1641 : "DW_OP_GNU_const_type"),
1642 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1643 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1644 data
= display_block (data
, uvalue
, end
, ' ');
1646 case DW_OP_regval_type
:
1647 case DW_OP_GNU_regval_type
:
1648 READ_ULEB (uvalue
, data
, end
);
1649 printf ("%s: %s (%s)",
1650 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1651 : "DW_OP_GNU_regval_type"),
1652 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1653 READ_ULEB (uvalue
, data
, end
);
1654 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1656 case DW_OP_deref_type
:
1657 case DW_OP_GNU_deref_type
:
1658 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1660 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1661 : "DW_OP_GNU_deref_type"),
1663 READ_ULEB (uvalue
, data
, end
);
1664 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1667 case DW_OP_GNU_convert
:
1668 READ_ULEB (uvalue
, data
, end
);
1669 printf ("%s <0x%s>",
1670 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1671 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1673 case DW_OP_reinterpret
:
1674 case DW_OP_GNU_reinterpret
:
1675 READ_ULEB (uvalue
, data
, end
);
1676 printf ("%s <0x%s>",
1677 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1678 : "DW_OP_GNU_reinterpret"),
1679 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1681 case DW_OP_GNU_parameter_ref
:
1682 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1683 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1684 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1686 case DW_OP_GNU_addr_index
:
1687 READ_ULEB (uvalue
, data
, end
);
1688 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1690 case DW_OP_GNU_const_index
:
1691 READ_ULEB (uvalue
, data
, end
);
1692 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1694 case DW_OP_GNU_variable_value
:
1695 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1696 this ought to be an 8-byte wide computation. */
1697 if (dwarf_version
== -1)
1699 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1700 /* No way to tell where the next op is, so just bail. */
1701 return need_frame_base
;
1703 if (dwarf_version
== 2)
1705 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1709 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1711 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1714 /* HP extensions. */
1715 case DW_OP_HP_is_value
:
1716 printf ("DW_OP_HP_is_value");
1717 /* FIXME: Is there data associated with this OP ? */
1719 case DW_OP_HP_fltconst4
:
1720 printf ("DW_OP_HP_fltconst4");
1721 /* FIXME: Is there data associated with this OP ? */
1723 case DW_OP_HP_fltconst8
:
1724 printf ("DW_OP_HP_fltconst8");
1725 /* FIXME: Is there data associated with this OP ? */
1727 case DW_OP_HP_mod_range
:
1728 printf ("DW_OP_HP_mod_range");
1729 /* FIXME: Is there data associated with this OP ? */
1731 case DW_OP_HP_unmod_range
:
1732 printf ("DW_OP_HP_unmod_range");
1733 /* FIXME: Is there data associated with this OP ? */
1736 printf ("DW_OP_HP_tls");
1737 /* FIXME: Is there data associated with this OP ? */
1740 /* PGI (STMicroelectronics) extensions. */
1741 case DW_OP_PGI_omp_thread_num
:
1742 /* Pushes the thread number for the current thread as it would be
1743 returned by the standard OpenMP library function:
1744 omp_get_thread_num(). The "current thread" is the thread for
1745 which the expression is being evaluated. */
1746 printf ("DW_OP_PGI_omp_thread_num");
1750 if (op
>= DW_OP_lo_user
1751 && op
<= DW_OP_hi_user
)
1752 printf (_("(User defined location op 0x%x)"), op
);
1754 printf (_("(Unknown location op 0x%x)"), op
);
1755 /* No way to tell where the next op is, so just bail. */
1756 return need_frame_base
;
1759 /* Separate the ops. */
1764 return need_frame_base
;
1767 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1768 This is used for DWARF package files. */
1770 static struct cu_tu_set
*
1771 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1773 struct cu_tu_set
*p
;
1775 unsigned int dw_sect
;
1781 dw_sect
= DW_SECT_TYPES
;
1787 dw_sect
= DW_SECT_INFO
;
1791 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1799 /* Add INC to HIGH_BITS:LOW_BITS. */
1801 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1803 dwarf_vma tmp
= * low_bits
;
1807 /* FIXME: There is probably a better way of handling this:
1809 We need to cope with dwarf_vma being a 32-bit or 64-bit
1810 type. Plus regardless of its size LOW_BITS is meant to
1811 only hold 32-bits, so if there is overflow or wrap around
1812 we must propagate into HIGH_BITS. */
1813 if (tmp
< * low_bits
)
1817 else if (sizeof (tmp
) > 8
1828 fetch_alt_indirect_string (dwarf_vma offset
)
1832 if (! do_follow_links
)
1835 if (first_separate_info
== NULL
)
1836 return _("<no links available>");
1838 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1840 struct dwarf_section
* section
;
1843 if (! load_debug_section (separate_debug_str
, i
->handle
))
1846 section
= &debug_displays
[separate_debug_str
].section
;
1848 if (section
->start
== NULL
)
1851 if (offset
>= section
->size
)
1854 ret
= (const char *) (section
->start
+ offset
);
1855 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1856 NUL byte. Since our caller is expecting to receive a well formed C
1857 string we test for the lack of a terminating byte here. */
1858 if (strnlen ((const char *) ret
, section
->size
- offset
)
1859 == section
->size
- offset
)
1860 return _("<no NUL byte at end of alt .debug_str section>");
1865 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1866 dwarf_vmatoa ("x", offset
));
1867 return _("<offset is too big>");
1871 get_AT_name (unsigned long attribute
)
1876 return "DW_AT value: 0";
1878 /* One value is shared by the MIPS and HP extensions: */
1879 if (attribute
== DW_AT_MIPS_fde
)
1880 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1882 name
= get_DW_AT_name (attribute
);
1886 static char buffer
[100];
1888 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1897 add_dwo_info (const char * value
, dwarf_vma cu_offset
, dwo_type type
)
1899 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1901 dwinfo
->type
= type
;
1902 dwinfo
->value
= value
;
1903 dwinfo
->cu_offset
= cu_offset
;
1904 dwinfo
->next
= first_dwo_info
;
1905 first_dwo_info
= dwinfo
;
1909 add_dwo_name (const char * name
, dwarf_vma cu_offset
)
1911 add_dwo_info (name
, cu_offset
, DWO_NAME
);
1915 add_dwo_dir (const char * dir
, dwarf_vma cu_offset
)
1917 add_dwo_info (dir
, cu_offset
, DWO_DIR
);
1921 add_dwo_id (const char * id
, dwarf_vma cu_offset
)
1923 add_dwo_info (id
, cu_offset
, DWO_ID
);
1927 free_dwo_info (void)
1932 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1934 next
= dwinfo
->next
;
1937 first_dwo_info
= NULL
;
1940 /* Ensure that START + UVALUE is less than END.
1941 Return an adjusted UVALUE if necessary to ensure this relationship. */
1943 static inline dwarf_vma
1944 check_uvalue (const unsigned char * start
,
1946 const unsigned char * end
)
1948 dwarf_vma max_uvalue
= end
- start
;
1950 /* See PR 17512: file: 008-103549-0.001:0.1.
1951 and PR 24829 for examples of where these tests are triggered. */
1952 if (uvalue
> max_uvalue
)
1954 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1955 uvalue
= max_uvalue
;
1961 static unsigned char *
1962 skip_attr_bytes (unsigned long form
,
1963 unsigned char * data
,
1964 unsigned const char * end
,
1965 dwarf_vma pointer_size
,
1966 dwarf_vma offset_size
,
1968 dwarf_vma
* value_return
)
1970 dwarf_signed_vma svalue
;
1971 dwarf_vma uvalue
= 0;
1977 case DW_FORM_ref_addr
:
1978 if (dwarf_version
== 2)
1979 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1980 else if (dwarf_version
> 2)
1981 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1987 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1991 case DW_FORM_line_strp
:
1992 case DW_FORM_sec_offset
:
1993 case DW_FORM_GNU_ref_alt
:
1994 case DW_FORM_GNU_strp_alt
:
1995 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1998 case DW_FORM_flag_present
:
2006 case DW_FORM_addrx1
:
2007 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2011 case DW_FORM_addrx3
:
2012 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2018 case DW_FORM_addrx2
:
2019 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2025 case DW_FORM_addrx4
:
2026 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2030 READ_SLEB (svalue
, data
, end
);
2034 case DW_FORM_ref_udata
:
2036 case DW_FORM_GNU_str_index
:
2038 case DW_FORM_GNU_addr_index
:
2040 READ_ULEB (uvalue
, data
, end
);
2045 dwarf_vma high_bits
;
2047 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2049 if (sizeof (uvalue
) > 4)
2050 uvalue
+= high_bits
<< 32;
2051 else if (high_bits
!= 0)
2053 /* FIXME: What to do ? */
2060 case DW_FORM_ref_sig8
:
2064 case DW_FORM_data16
:
2068 case DW_FORM_string
:
2069 data
+= strnlen ((char *) data
, end
- data
) + 1;
2073 case DW_FORM_exprloc
:
2074 READ_ULEB (uvalue
, data
, end
);
2078 case DW_FORM_block1
:
2079 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
2083 case DW_FORM_block2
:
2084 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
2088 case DW_FORM_block4
:
2089 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
2093 case DW_FORM_indirect
:
2094 READ_ULEB (form
, data
, end
);
2095 if (form
== DW_FORM_implicit_const
)
2096 SKIP_ULEB (data
, end
);
2097 return skip_attr_bytes (form
, data
, end
, pointer_size
, offset_size
, dwarf_version
, value_return
);
2103 * value_return
= uvalue
;
2105 data
= (unsigned char *) end
;
2109 /* Given form FORM with value UVALUE, locate and return the abbreviation
2110 associated with it. */
2112 static abbrev_entry
*
2113 get_type_abbrev_from_form (unsigned long form
,
2114 unsigned long uvalue
,
2115 dwarf_vma cu_offset
,
2116 const struct dwarf_section
* section
,
2117 unsigned long * abbrev_num_return
,
2118 unsigned char ** data_return
,
2119 unsigned long * cu_offset_return
)
2121 unsigned long abbrev_number
;
2123 abbrev_entry
* entry
;
2124 unsigned char * data
;
2126 if (abbrev_num_return
!= NULL
)
2127 * abbrev_num_return
= 0;
2128 if (data_return
!= NULL
)
2129 * data_return
= NULL
;
2133 case DW_FORM_GNU_ref_alt
:
2134 case DW_FORM_ref_sig8
:
2135 /* FIXME: We are unable to handle this form at the moment. */
2138 case DW_FORM_ref_addr
:
2139 if (uvalue
>= section
->size
)
2141 warn (_("Unable to resolve ref_addr form: uvalue %lx > section size %lx (%s)\n"),
2142 uvalue
, (long) section
->size
, section
->name
);
2147 case DW_FORM_ref_sup4
:
2148 case DW_FORM_ref_sup8
:
2155 case DW_FORM_ref_udata
:
2156 if (uvalue
+ cu_offset
> section
->size
)
2158 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %lx > section size %lx\n"),
2159 uvalue
, (long) cu_offset
, (long) section
->size
);
2162 uvalue
+= cu_offset
;
2165 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2168 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2172 data
= (unsigned char *) section
->start
+ uvalue
;
2173 map
= find_abbrev_map_by_offset (uvalue
);
2177 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2180 if (map
->list
== NULL
)
2182 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2186 if (cu_offset_return
!= NULL
)
2188 if (form
== DW_FORM_ref_addr
)
2189 * cu_offset_return
= map
->start
;
2191 * cu_offset_return
= cu_offset
;
2194 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2196 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2197 if (entry
->number
== abbrev_number
)
2200 if (abbrev_num_return
!= NULL
)
2201 * abbrev_num_return
= abbrev_number
;
2203 if (data_return
!= NULL
)
2204 * data_return
= data
;
2207 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2212 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2213 can be determined to be a signed type. The data for ENTRY can be
2214 found starting at DATA. */
2217 get_type_signedness (abbrev_entry
* entry
,
2218 const struct dwarf_section
* section
,
2219 unsigned char * data
,
2220 unsigned const char * end
,
2221 dwarf_vma cu_offset
,
2222 dwarf_vma pointer_size
,
2223 dwarf_vma offset_size
,
2225 bfd_boolean
* is_signed
,
2226 unsigned int nesting
)
2230 * is_signed
= FALSE
;
2232 #define MAX_NESTING 20
2233 if (nesting
> MAX_NESTING
)
2235 /* FIXME: Warn - or is this expected ?
2236 NB/ We need to avoid infinite recursion. */
2240 for (attr
= entry
->first_attr
;
2241 attr
!= NULL
&& attr
->attribute
;
2244 unsigned char * orig_data
= data
;
2245 dwarf_vma uvalue
= 0;
2247 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2248 offset_size
, dwarf_version
, & uvalue
);
2252 switch (attr
->attribute
)
2254 case DW_AT_linkage_name
:
2258 if (attr
->form
== DW_FORM_strp
)
2259 printf (", %s", fetch_indirect_string (uvalue
));
2260 else if (attr
->form
== DW_FORM_string
)
2261 printf (", %s", orig_data
);
2268 abbrev_entry
* type_abbrev
;
2269 unsigned char * type_data
;
2270 unsigned long type_cu_offset
;
2272 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2276 NULL
/* abbrev num return */,
2279 if (type_abbrev
== NULL
)
2282 get_type_signedness (type_abbrev
, section
, type_data
, end
, type_cu_offset
,
2283 pointer_size
, offset_size
, dwarf_version
,
2284 is_signed
, nesting
+ 1);
2288 case DW_AT_encoding
:
2289 /* Determine signness. */
2292 case DW_ATE_address
:
2293 /* FIXME - some architectures have signed addresses. */
2294 case DW_ATE_boolean
:
2295 case DW_ATE_unsigned
:
2296 case DW_ATE_unsigned_char
:
2297 case DW_ATE_unsigned_fixed
:
2298 * is_signed
= FALSE
;
2302 case DW_ATE_complex_float
:
2305 case DW_ATE_signed_char
:
2306 case DW_ATE_imaginary_float
:
2307 case DW_ATE_decimal_float
:
2308 case DW_ATE_signed_fixed
:
2318 read_and_print_leb128 (unsigned char * data
,
2319 unsigned int * bytes_read
,
2320 unsigned const char * end
,
2321 bfd_boolean is_signed
)
2324 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2326 report_leb_status (status
, __FILE__
, __LINE__
);
2328 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2332 display_discr_list (unsigned long form
,
2334 unsigned char * data
,
2335 unsigned const char * end
,
2340 printf ("[default]");
2347 case DW_FORM_block1
:
2348 case DW_FORM_block2
:
2349 case DW_FORM_block4
:
2350 /* Move data pointer back to the start of the byte array. */
2354 printf ("<corrupt>\n");
2355 warn (_("corrupt discr_list - not using a block form\n"));
2361 printf ("<corrupt>\n");
2362 warn (_("corrupt discr_list - block not long enough\n"));
2366 bfd_boolean is_signed
=
2367 (level
> 0 && level
<= MAX_CU_NESTING
)
2368 ? level_type_signed
[level
- 1] : FALSE
;
2373 unsigned char discriminant
;
2374 unsigned int bytes_read
;
2376 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2380 assert (uvalue
> 0);
2381 switch (discriminant
)
2385 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2386 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2387 uvalue
-= bytes_read
;
2393 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2394 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2395 uvalue
-= bytes_read
;
2399 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2400 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2401 uvalue
-= bytes_read
;
2406 printf ("<corrupt>\n");
2407 warn (_("corrupt discr_list - unrecognized discriminant byte %#x\n"),
2417 printf (")(signed)");
2419 printf (")(unsigned)");
2422 static unsigned char *
2423 read_and_display_attr_value (unsigned long attribute
,
2425 dwarf_signed_vma implicit_const
,
2426 unsigned char * start
,
2427 unsigned char * data
,
2428 unsigned char * end
,
2429 dwarf_vma cu_offset
,
2430 dwarf_vma pointer_size
,
2431 dwarf_vma offset_size
,
2433 debug_info
* debug_info_p
,
2435 struct dwarf_section
* section
,
2436 struct cu_tu_set
* this_set
,
2440 dwarf_signed_vma svalue
;
2441 dwarf_vma uvalue
= 0;
2442 unsigned char * block_start
= NULL
;
2443 unsigned char * orig_data
= data
;
2445 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2447 warn (_("Corrupt attribute\n"));
2451 if (do_wide
&& ! do_loc
)
2453 /* PR 26847: Display the name of the form. */
2454 const char * name
= get_FORM_name (form
);
2456 /* For convenience we skip the DW_FORM_ prefix to the name. */
2458 name
+= 8; /* strlen ("DW_FORM_") */
2459 printf ("%c(%s)", delimiter
, name
);
2467 case DW_FORM_ref_addr
:
2468 if (dwarf_version
== 2)
2469 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2470 else if (dwarf_version
> 2)
2471 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2473 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2477 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2480 case DW_FORM_strp_sup
:
2482 case DW_FORM_line_strp
:
2483 case DW_FORM_sec_offset
:
2484 case DW_FORM_GNU_ref_alt
:
2485 case DW_FORM_GNU_strp_alt
:
2486 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2489 case DW_FORM_flag_present
:
2497 case DW_FORM_addrx1
:
2498 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2504 case DW_FORM_addrx2
:
2505 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2509 case DW_FORM_addrx3
:
2510 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2513 case DW_FORM_ref_sup4
:
2517 case DW_FORM_addrx4
:
2518 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2522 READ_SLEB (svalue
, data
, end
);
2526 case DW_FORM_GNU_str_index
:
2528 case DW_FORM_ref_udata
:
2530 case DW_FORM_GNU_addr_index
:
2532 READ_ULEB (uvalue
, data
, end
);
2535 case DW_FORM_indirect
:
2536 READ_ULEB (form
, data
, end
);
2538 printf ("%c%s", delimiter
, get_FORM_name (form
));
2539 if (form
== DW_FORM_implicit_const
)
2540 READ_SLEB (implicit_const
, data
, end
);
2541 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2543 cu_offset
, pointer_size
,
2544 offset_size
, dwarf_version
,
2545 debug_info_p
, do_loc
,
2546 section
, this_set
, delimiter
, level
);
2551 case DW_FORM_ref_addr
:
2553 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2556 case DW_FORM_GNU_ref_alt
:
2560 /* We have already printed the form name. */
2561 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2563 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2565 /* FIXME: Follow the reference... */
2571 case DW_FORM_ref_sup4
:
2572 case DW_FORM_ref_udata
:
2574 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2579 case DW_FORM_sec_offset
:
2581 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2584 case DW_FORM_flag_present
:
2591 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2594 case DW_FORM_implicit_const
:
2596 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2599 case DW_FORM_ref_sup8
:
2604 dwarf_vma high_bits
;
2608 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2610 if (form
== DW_FORM_ref8
)
2611 add64 (& high_bits
, & utmp
, cu_offset
);
2612 printf ("%c0x%s", delimiter
,
2613 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2616 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2617 && num_debug_info_entries
== 0)
2619 if (sizeof (uvalue
) == 8)
2620 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2622 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2628 case DW_FORM_data16
:
2631 dwarf_vma left_high_bits
, left_low_bits
;
2632 dwarf_vma right_high_bits
, right_low_bits
;
2634 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2635 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2636 if (byte_get
== byte_get_little_endian
)
2639 left_high_bits
^= right_high_bits
;
2640 right_high_bits
^= left_high_bits
;
2641 left_high_bits
^= right_high_bits
;
2642 left_low_bits
^= right_low_bits
;
2643 right_low_bits
^= left_low_bits
;
2644 left_low_bits
^= right_low_bits
;
2646 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2647 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2648 left_high_bits
, left_low_bits
, right_high_bits
,
2654 case DW_FORM_string
:
2656 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2657 data
+= strnlen ((char *) data
, end
- data
) + 1;
2661 case DW_FORM_exprloc
:
2662 READ_ULEB (uvalue
, data
, end
);
2665 if (block_start
>= end
)
2667 warn (_("Block ends prematurely\n"));
2672 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2675 data
= block_start
+ uvalue
;
2677 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2680 case DW_FORM_block1
:
2681 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2684 case DW_FORM_block2
:
2685 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2688 case DW_FORM_block4
:
2689 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2696 /* We have already displayed the form name. */
2697 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2698 dwarf_vmatoa ("x", uvalue
),
2699 fetch_indirect_string (uvalue
));
2701 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2702 dwarf_vmatoa ("x", uvalue
),
2703 fetch_indirect_string (uvalue
));
2707 case DW_FORM_line_strp
:
2711 /* We have already displayed the form name. */
2712 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2713 dwarf_vmatoa ("x", uvalue
),
2714 fetch_indirect_line_string (uvalue
));
2716 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2717 dwarf_vmatoa ("x", uvalue
),
2718 fetch_indirect_line_string (uvalue
));
2722 case DW_FORM_GNU_str_index
:
2730 const char *suffix
= strrchr (section
->name
, '.');
2731 bfd_boolean dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2734 /* We have already displayed the form name. */
2735 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2736 dwarf_vmatoa ("x", uvalue
),
2737 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2739 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2740 dwarf_vmatoa ("x", uvalue
),
2741 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2745 case DW_FORM_GNU_strp_alt
:
2749 /* We have already displayed the form name. */
2750 printf (_("%c(offset: 0x%s) %s"), delimiter
,
2751 dwarf_vmatoa ("x", uvalue
),
2752 fetch_alt_indirect_string (uvalue
));
2754 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2755 dwarf_vmatoa ("x", uvalue
),
2756 fetch_alt_indirect_string (uvalue
));
2760 case DW_FORM_indirect
:
2761 /* Handled above. */
2764 case DW_FORM_ref_sig8
:
2767 dwarf_vma high_bits
;
2770 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2772 /* We have already displayed the form name. */
2773 printf ("%c: 0x%s", delimiter
,
2774 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2776 printf ("%csignature: 0x%s", delimiter
,
2777 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2782 case DW_FORM_GNU_addr_index
:
2784 case DW_FORM_addrx1
:
2785 case DW_FORM_addrx2
:
2786 case DW_FORM_addrx3
:
2787 case DW_FORM_addrx4
:
2793 if (debug_info_p
== NULL
)
2795 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2798 base
= debug_info_p
->addr_base
;
2800 offset
= base
+ uvalue
* pointer_size
;
2803 /* We have already displayed the form name. */
2804 printf (_("%c(index: 0x%s): %s"), delimiter
,
2805 dwarf_vmatoa ("x", uvalue
),
2806 fetch_indexed_value (offset
, pointer_size
));
2808 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2809 dwarf_vmatoa ("x", uvalue
),
2810 fetch_indexed_value (offset
, pointer_size
));
2814 case DW_FORM_strp_sup
:
2816 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2820 warn (_("Unrecognized form: 0x%lx\n"), form
);
2824 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2825 && num_debug_info_entries
== 0
2826 && debug_info_p
!= NULL
)
2830 case DW_AT_frame_base
:
2831 have_frame_base
= 1;
2833 case DW_AT_location
:
2834 case DW_AT_GNU_locviews
:
2835 case DW_AT_string_length
:
2836 case DW_AT_return_addr
:
2837 case DW_AT_data_member_location
:
2838 case DW_AT_vtable_elem_location
:
2840 case DW_AT_static_link
:
2841 case DW_AT_use_location
:
2842 case DW_AT_call_value
:
2843 case DW_AT_GNU_call_site_value
:
2844 case DW_AT_call_data_value
:
2845 case DW_AT_GNU_call_site_data_value
:
2846 case DW_AT_call_target
:
2847 case DW_AT_GNU_call_site_target
:
2848 case DW_AT_call_target_clobbered
:
2849 case DW_AT_GNU_call_site_target_clobbered
:
2850 if ((dwarf_version
< 4
2851 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2852 || form
== DW_FORM_sec_offset
)
2854 /* Process location list. */
2855 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2856 unsigned int num
= debug_info_p
->num_loc_offsets
;
2858 if (lmax
== 0 || num
>= lmax
)
2861 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2862 xcrealloc (debug_info_p
->loc_offsets
,
2863 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2864 debug_info_p
->loc_views
= (dwarf_vma
*)
2865 xcrealloc (debug_info_p
->loc_views
,
2866 lmax
, sizeof (*debug_info_p
->loc_views
));
2867 debug_info_p
->have_frame_base
= (int *)
2868 xcrealloc (debug_info_p
->have_frame_base
,
2869 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2870 debug_info_p
->max_loc_offsets
= lmax
;
2872 if (this_set
!= NULL
)
2873 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2874 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2875 if (attribute
!= DW_AT_GNU_locviews
)
2877 /* Corrupt DWARF info can produce more offsets than views.
2878 See PR 23062 for an example. */
2879 if (debug_info_p
->num_loc_offsets
2880 > debug_info_p
->num_loc_views
)
2881 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2884 debug_info_p
->loc_offsets
[num
] = uvalue
;
2885 debug_info_p
->num_loc_offsets
++;
2890 assert (debug_info_p
->num_loc_views
<= num
);
2891 num
= debug_info_p
->num_loc_views
;
2892 if (num
> debug_info_p
->num_loc_offsets
)
2893 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2896 debug_info_p
->loc_views
[num
] = uvalue
;
2897 debug_info_p
->num_loc_views
++;
2904 if (need_base_address
)
2905 debug_info_p
->base_address
= uvalue
;
2908 case DW_AT_GNU_addr_base
:
2909 case DW_AT_addr_base
:
2910 debug_info_p
->addr_base
= uvalue
;
2913 case DW_AT_GNU_ranges_base
:
2914 debug_info_p
->ranges_base
= uvalue
;
2918 if ((dwarf_version
< 4
2919 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2920 || form
== DW_FORM_sec_offset
)
2922 /* Process range list. */
2923 unsigned int lmax
= debug_info_p
->max_range_lists
;
2924 unsigned int num
= debug_info_p
->num_range_lists
;
2926 if (lmax
== 0 || num
>= lmax
)
2929 debug_info_p
->range_lists
= (dwarf_vma
*)
2930 xcrealloc (debug_info_p
->range_lists
,
2931 lmax
, sizeof (*debug_info_p
->range_lists
));
2932 debug_info_p
->max_range_lists
= lmax
;
2934 debug_info_p
->range_lists
[num
] = uvalue
;
2935 debug_info_p
->num_range_lists
++;
2939 case DW_AT_GNU_dwo_name
:
2940 case DW_AT_dwo_name
:
2945 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2947 case DW_FORM_GNU_strp_alt
:
2948 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2950 case DW_FORM_GNU_str_index
:
2956 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
), cu_offset
);
2958 case DW_FORM_string
:
2959 add_dwo_name ((const char *) orig_data
, cu_offset
);
2962 warn (_("Unsupported form (%s) for attribute %s\n"),
2963 get_FORM_name (form
), get_AT_name (attribute
));
2968 case DW_AT_comp_dir
:
2969 /* FIXME: Also extract a build-id in a CU/TU. */
2974 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2976 case DW_FORM_GNU_strp_alt
:
2977 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2979 case DW_FORM_line_strp
:
2980 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2982 case DW_FORM_GNU_str_index
:
2988 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
), cu_offset
);
2990 case DW_FORM_string
:
2991 add_dwo_dir ((const char *) orig_data
, cu_offset
);
2994 warn (_("Unsupported form (%s) for attribute %s\n"),
2995 get_FORM_name (form
), get_AT_name (attribute
));
3000 case DW_AT_GNU_dwo_id
:
3005 /* FIXME: Record the length of the ID as well ? */
3006 add_dwo_id ((const char *) (data
- 8), cu_offset
);
3009 warn (_("Unsupported form (%s) for attribute %s\n"),
3010 get_FORM_name (form
), get_AT_name (attribute
));
3020 if (do_loc
|| attribute
== 0)
3023 /* For some attributes we can display further information. */
3027 if (level
>= 0 && level
< MAX_CU_NESTING
3028 && uvalue
< (size_t) (end
- start
))
3030 bfd_boolean is_signed
= FALSE
;
3031 abbrev_entry
* type_abbrev
;
3032 unsigned char * type_data
;
3033 unsigned long type_cu_offset
;
3035 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
3036 section
, NULL
, & type_data
, & type_cu_offset
);
3037 if (type_abbrev
!= NULL
)
3039 get_type_signedness (type_abbrev
, section
, type_data
, end
, type_cu_offset
,
3040 pointer_size
, offset_size
, dwarf_version
,
3043 level_type_signed
[level
] = is_signed
;
3051 case DW_INL_not_inlined
:
3052 printf (_("(not inlined)"));
3054 case DW_INL_inlined
:
3055 printf (_("(inlined)"));
3057 case DW_INL_declared_not_inlined
:
3058 printf (_("(declared as inline but ignored)"));
3060 case DW_INL_declared_inlined
:
3061 printf (_("(declared as inline and inlined)"));
3064 printf (_(" (Unknown inline attribute value: %s)"),
3065 dwarf_vmatoa ("x", uvalue
));
3070 case DW_AT_language
:
3074 /* Ordered by the numeric value of these constants. */
3075 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3076 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3077 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3078 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3079 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3080 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3081 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3082 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3083 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3084 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3085 /* DWARF 2.1 values. */
3086 case DW_LANG_Java
: printf ("(Java)"); break;
3087 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3088 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3089 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3090 /* DWARF 3 values. */
3091 case DW_LANG_PLI
: printf ("(PLI)"); break;
3092 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3093 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3094 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3095 case DW_LANG_D
: printf ("(D)"); break;
3096 /* DWARF 4 values. */
3097 case DW_LANG_Python
: printf ("(Python)"); break;
3098 /* DWARF 5 values. */
3099 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3100 case DW_LANG_Go
: printf ("(Go)"); break;
3101 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3102 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3103 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3104 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3105 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3106 case DW_LANG_Rust
: printf ("(Rust)"); break;
3107 case DW_LANG_C11
: printf ("(C11)"); break;
3108 case DW_LANG_Swift
: printf ("(Swift)"); break;
3109 case DW_LANG_Julia
: printf ("(Julia)"); break;
3110 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3111 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3112 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3113 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3114 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3115 /* MIPS extension. */
3116 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3117 /* UPC extension. */
3118 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3120 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3121 printf (_("(implementation defined: %s)"),
3122 dwarf_vmatoa ("x", uvalue
));
3124 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3129 case DW_AT_encoding
:
3133 case DW_ATE_void
: printf ("(void)"); break;
3134 case DW_ATE_address
: printf ("(machine address)"); break;
3135 case DW_ATE_boolean
: printf ("(boolean)"); break;
3136 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3137 case DW_ATE_float
: printf ("(float)"); break;
3138 case DW_ATE_signed
: printf ("(signed)"); break;
3139 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3140 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3141 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3142 /* DWARF 2.1 values: */
3143 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3144 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3145 /* DWARF 3 values: */
3146 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3147 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3148 case DW_ATE_edited
: printf ("(edited)"); break;
3149 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3150 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3151 /* DWARF 4 values: */
3152 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3153 /* DWARF 5 values: */
3154 case DW_ATE_UCS
: printf ("(UCS)"); break;
3155 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3157 /* HP extensions: */
3158 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3159 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3160 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3161 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3162 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3163 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3164 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3167 if (uvalue
>= DW_ATE_lo_user
3168 && uvalue
<= DW_ATE_hi_user
)
3169 printf (_("(user defined type)"));
3171 printf (_("(unknown type)"));
3176 case DW_AT_accessibility
:
3180 case DW_ACCESS_public
: printf ("(public)"); break;
3181 case DW_ACCESS_protected
: printf ("(protected)"); break;
3182 case DW_ACCESS_private
: printf ("(private)"); break;
3184 printf (_("(unknown accessibility)"));
3189 case DW_AT_visibility
:
3193 case DW_VIS_local
: printf ("(local)"); break;
3194 case DW_VIS_exported
: printf ("(exported)"); break;
3195 case DW_VIS_qualified
: printf ("(qualified)"); break;
3196 default: printf (_("(unknown visibility)")); break;
3200 case DW_AT_endianity
:
3204 case DW_END_default
: printf ("(default)"); break;
3205 case DW_END_big
: printf ("(big)"); break;
3206 case DW_END_little
: printf ("(little)"); break;
3208 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3209 printf (_("(user specified)"));
3211 printf (_("(unknown endianity)"));
3216 case DW_AT_virtuality
:
3220 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3221 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3222 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3223 default: printf (_("(unknown virtuality)")); break;
3227 case DW_AT_identifier_case
:
3231 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3232 case DW_ID_up_case
: printf ("(up_case)"); break;
3233 case DW_ID_down_case
: printf ("(down_case)"); break;
3234 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3235 default: printf (_("(unknown case)")); break;
3239 case DW_AT_calling_convention
:
3243 case DW_CC_normal
: printf ("(normal)"); break;
3244 case DW_CC_program
: printf ("(program)"); break;
3245 case DW_CC_nocall
: printf ("(nocall)"); break;
3246 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3247 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3248 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3249 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3251 if (uvalue
>= DW_CC_lo_user
3252 && uvalue
<= DW_CC_hi_user
)
3253 printf (_("(user defined)"));
3255 printf (_("(unknown convention)"));
3259 case DW_AT_ordering
:
3264 case -1: printf (_("(undefined)")); break;
3265 case 0: printf ("(row major)"); break;
3266 case 1: printf ("(column major)"); break;
3270 case DW_AT_decimal_sign
:
3274 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3275 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3276 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3277 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3278 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3279 default: printf (_("(unrecognised)")); break;
3283 case DW_AT_defaulted
:
3287 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3288 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3289 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3290 default: printf (_("(unrecognised)")); break;
3294 case DW_AT_discr_list
:
3296 display_discr_list (form
, uvalue
, data
, end
, level
);
3299 case DW_AT_frame_base
:
3300 have_frame_base
= 1;
3302 case DW_AT_location
:
3303 case DW_AT_string_length
:
3304 case DW_AT_return_addr
:
3305 case DW_AT_data_member_location
:
3306 case DW_AT_vtable_elem_location
:
3308 case DW_AT_static_link
:
3309 case DW_AT_use_location
:
3310 case DW_AT_call_value
:
3311 case DW_AT_GNU_call_site_value
:
3312 case DW_AT_call_data_value
:
3313 case DW_AT_GNU_call_site_data_value
:
3314 case DW_AT_call_target
:
3315 case DW_AT_GNU_call_site_target
:
3316 case DW_AT_call_target_clobbered
:
3317 case DW_AT_GNU_call_site_target_clobbered
:
3318 if ((dwarf_version
< 4
3319 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3320 || form
== DW_FORM_sec_offset
)
3321 printf (_(" (location list)"));
3323 case DW_AT_allocated
:
3324 case DW_AT_associated
:
3325 case DW_AT_data_location
:
3327 case DW_AT_upper_bound
:
3328 case DW_AT_lower_bound
:
3331 int need_frame_base
;
3334 need_frame_base
= decode_location_expression (block_start
,
3339 cu_offset
, section
);
3341 if (need_frame_base
&& !have_frame_base
)
3342 printf (_(" [without DW_AT_frame_base]"));
3346 case DW_AT_data_bit_offset
:
3347 case DW_AT_byte_size
:
3348 case DW_AT_bit_size
:
3349 case DW_AT_string_length_byte_size
:
3350 case DW_AT_string_length_bit_size
:
3351 case DW_AT_bit_stride
:
3352 if (form
== DW_FORM_exprloc
)
3355 (void) decode_location_expression (block_start
, pointer_size
,
3356 offset_size
, dwarf_version
,
3357 uvalue
, cu_offset
, section
);
3364 unsigned long abbrev_number
;
3365 abbrev_entry
*entry
;
3367 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
3368 section
, & abbrev_number
, NULL
, NULL
);
3371 if (form
!= DW_FORM_GNU_ref_alt
)
3372 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3373 dwarf_vmatoa ("x", uvalue
),
3374 (unsigned long) (orig_data
- section
->start
));
3378 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3379 printf (" (%s)", get_TAG_name (entry
->tag
));
3392 static unsigned char *
3393 read_and_display_attr (unsigned long attribute
,
3395 dwarf_signed_vma implicit_const
,
3396 unsigned char * start
,
3397 unsigned char * data
,
3398 unsigned char * end
,
3399 dwarf_vma cu_offset
,
3400 dwarf_vma pointer_size
,
3401 dwarf_vma offset_size
,
3403 debug_info
* debug_info_p
,
3405 struct dwarf_section
* section
,
3406 struct cu_tu_set
* this_set
,
3410 printf (" %-18s:", get_AT_name (attribute
));
3411 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3413 cu_offset
, pointer_size
, offset_size
,
3414 dwarf_version
, debug_info_p
,
3415 do_loc
, section
, this_set
, ' ', level
);
3421 /* Like load_debug_section, but if the ordinary call fails, and we are
3422 following debug links, then attempt to load the requested section
3423 from one of the separate debug info files. */
3426 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3429 if (load_debug_section (sec_enum
, handle
))
3431 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3433 /* See if we can associate a filename with this section. */
3436 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3437 if (i
->handle
== handle
)
3439 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3447 if (do_follow_links
)
3451 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3453 if (load_debug_section (sec_enum
, i
->handle
))
3455 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3457 /* FIXME: We should check to see if any of the remaining debug info
3458 files also contain this section, and, umm, do something about it. */
3468 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3472 if (do_follow_links
&& section
->filename
)
3473 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3474 section
->name
, section
->filename
);
3476 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3480 if (do_follow_links
&& section
->filename
)
3481 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3482 section
->name
, section
->filename
);
3484 printf (_("Contents of the %s section:\n\n"), section
->name
);
3488 /* Process the contents of a .debug_info section.
3489 If do_loc is TRUE then we are scanning for location lists and dwo tags
3490 and we do not want to display anything to the user.
3491 If do_types is TRUE, we are processing a .debug_types section instead of
3492 a .debug_info section.
3493 The information displayed is restricted by the values in DWARF_START_DIE
3494 and DWARF_CUTOFF_LEVEL.
3495 Returns TRUE upon success. Otherwise an error or warning message is
3496 printed and FALSE is returned. */
3499 process_debug_info (struct dwarf_section
* section
,
3501 enum dwarf_section_display_enum abbrev_sec
,
3503 bfd_boolean do_types
)
3505 unsigned char *start
= section
->start
;
3506 unsigned char *end
= start
+ section
->size
;
3507 unsigned char *section_begin
;
3509 unsigned int num_units
= 0;
3511 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3512 && num_debug_info_entries
== 0
3517 /* First scan the section to get the number of comp units. */
3518 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3521 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3522 will be the length. For a 64-bit DWARF section, it'll be
3523 the escape code 0xffffffff followed by an 8 byte length. */
3524 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3526 if (length
== 0xffffffff)
3528 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3529 section_begin
+= length
+ 12;
3531 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3533 warn (_("Reserved length value (0x%s) found in section %s\n"),
3534 dwarf_vmatoa ("x", length
), section
->name
);
3538 section_begin
+= length
+ 4;
3540 /* Negative values are illegal, they may even cause infinite
3541 looping. This can happen if we can't accurately apply
3542 relocations to an object file, or if the file is corrupt. */
3543 if ((signed long) length
<= 0 || section_begin
< start
)
3545 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3546 dwarf_vmatoa ("x", length
), section
->name
);
3553 error (_("No comp units in %s section ?\n"), section
->name
);
3557 /* Then allocate an array to hold the information. */
3558 debug_information
= (debug_info
*) cmalloc (num_units
,
3559 sizeof (* debug_information
));
3560 if (debug_information
== NULL
)
3562 error (_("Not enough memory for a debug info array of %u entries\n"),
3564 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3568 /* PR 17531: file: 92ca3797.
3569 We cannot rely upon the debug_information array being initialised
3570 before it is used. A corrupt file could easily contain references
3571 to a unit for which information has not been made available. So
3572 we ensure that the array is zeroed here. */
3573 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3575 alloc_num_debug_info_entries
= num_units
;
3580 load_debug_section_with_follow (str
, file
);
3581 load_debug_section_with_follow (line_str
, file
);
3582 load_debug_section_with_follow (str_dwo
, file
);
3583 load_debug_section_with_follow (str_index
, file
);
3584 load_debug_section_with_follow (str_index_dwo
, file
);
3585 load_debug_section_with_follow (debug_addr
, file
);
3588 load_debug_section_with_follow (abbrev_sec
, file
);
3589 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3591 warn (_("Unable to locate %s section!\n"),
3592 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3596 if (!do_loc
&& dwarf_start_die
== 0)
3597 introduce (section
, FALSE
);
3599 free_all_abbrevs ();
3600 free (cu_abbrev_map
);
3601 cu_abbrev_map
= NULL
;
3602 next_free_abbrev_map_entry
= 0;
3604 /* In order to be able to resolve DW_FORM_ref_attr forms we need
3605 to load *all* of the abbrevs for all CUs in this .debug_info
3606 section. This does effectively mean that we (partially) read
3607 every CU header twice. */
3608 for (section_begin
= start
; start
< end
;)
3610 DWARF2_Internal_CompUnit compunit
;
3611 unsigned char * hdrptr
;
3612 dwarf_vma abbrev_base
;
3614 dwarf_vma cu_offset
;
3615 unsigned int offset_size
;
3616 unsigned int initial_length_size
;
3617 struct cu_tu_set
* this_set
;
3622 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3624 if (compunit
.cu_length
== 0xffffffff)
3626 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3628 initial_length_size
= 12;
3633 initial_length_size
= 4;
3636 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3638 cu_offset
= start
- section_begin
;
3640 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3642 if (compunit
.cu_version
< 5)
3644 compunit
.cu_unit_type
= DW_UT_compile
;
3645 /* Initialize it due to a false compiler warning. */
3646 compunit
.cu_pointer_size
= -1;
3650 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3651 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3653 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3656 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3658 if (compunit
.cu_unit_type
== DW_UT_split_compile
3659 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3662 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end
);
3665 if (this_set
== NULL
)
3668 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3672 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3673 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3676 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3677 compunit
.cu_abbrev_offset
);
3680 unsigned char * next
;
3682 list
= new_abbrev_list (abbrev_base
,
3683 compunit
.cu_abbrev_offset
);
3684 next
= process_abbrev_set
3685 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3686 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3687 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3688 + abbrev_base
+ abbrev_size
),
3690 list
->start_of_next_abbrevs
= next
;
3693 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3694 + initial_length_size
;
3695 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
, list
);
3698 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3700 DWARF2_Internal_CompUnit compunit
;
3701 unsigned char *hdrptr
;
3702 unsigned char *tags
;
3703 int level
, last_level
, saved_level
;
3704 dwarf_vma cu_offset
;
3705 unsigned long sec_off
;
3706 unsigned int offset_size
;
3707 unsigned int initial_length_size
;
3708 dwarf_vma signature_high
= 0;
3709 dwarf_vma signature_low
= 0;
3710 dwarf_vma type_offset
= 0;
3711 struct cu_tu_set
*this_set
;
3712 dwarf_vma abbrev_base
;
3714 abbrev_list
* list
= NULL
;
3718 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3720 if (compunit
.cu_length
== 0xffffffff)
3722 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3724 initial_length_size
= 12;
3729 initial_length_size
= 4;
3732 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3734 cu_offset
= start
- section_begin
;
3736 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3738 if (compunit
.cu_version
< 5)
3740 compunit
.cu_unit_type
= DW_UT_compile
;
3741 /* Initialize it due to a false compiler warning. */
3742 compunit
.cu_pointer_size
= -1;
3746 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3747 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3749 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3752 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3754 if (this_set
== NULL
)
3757 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3761 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3762 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3765 if (compunit
.cu_version
< 5)
3766 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3768 bfd_boolean do_dwo_id
= FALSE
;
3769 uint64_t dwo_id
= 0;
3770 if (compunit
.cu_unit_type
== DW_UT_split_compile
3771 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3773 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end
);
3777 /* PR 17512: file: 001-108546-0.001:0.1. */
3778 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3780 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3781 compunit
.cu_pointer_size
, offset_size
);
3782 compunit
.cu_pointer_size
= offset_size
;
3787 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3789 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3792 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3793 + initial_length_size
))
3795 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3796 + initial_length_size
;
3800 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3801 && num_debug_info_entries
== 0
3802 && alloc_num_debug_info_entries
> unit
3805 debug_information
[unit
].cu_offset
= cu_offset
;
3806 debug_information
[unit
].pointer_size
3807 = compunit
.cu_pointer_size
;
3808 debug_information
[unit
].offset_size
= offset_size
;
3809 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3810 debug_information
[unit
].base_address
= 0;
3811 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3812 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3813 debug_information
[unit
].loc_offsets
= NULL
;
3814 debug_information
[unit
].have_frame_base
= NULL
;
3815 debug_information
[unit
].max_loc_offsets
= 0;
3816 debug_information
[unit
].num_loc_offsets
= 0;
3817 debug_information
[unit
].range_lists
= NULL
;
3818 debug_information
[unit
].max_range_lists
= 0;
3819 debug_information
[unit
].num_range_lists
= 0;
3822 if (!do_loc
&& dwarf_start_die
== 0)
3824 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3825 dwarf_vmatoa ("x", cu_offset
));
3826 printf (_(" Length: 0x%s (%s)\n"),
3827 dwarf_vmatoa ("x", compunit
.cu_length
),
3828 offset_size
== 8 ? "64-bit" : "32-bit");
3829 printf (_(" Version: %d\n"), compunit
.cu_version
);
3830 if (compunit
.cu_version
>= 5)
3831 printf (_(" Unit Type: %s (%x)\n"),
3832 get_DW_UT_name (compunit
.cu_unit_type
) ?: "???",
3833 compunit
.cu_unit_type
);
3834 printf (_(" Abbrev Offset: 0x%s\n"),
3835 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3836 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3841 printf (_(" Signature: 0x%s\n"),
3842 dwarf_vmatoa64 (signature_high
, signature_low
,
3843 buf
, sizeof (buf
)));
3844 printf (_(" Type Offset: 0x%s\n"),
3845 dwarf_vmatoa ("x", type_offset
));
3848 printf (_(" DWO ID: 0x%s\n"), dwarf_vmatoa ("x", dwo_id
));
3849 if (this_set
!= NULL
)
3851 dwarf_vma
*offsets
= this_set
->section_offsets
;
3852 size_t *sizes
= this_set
->section_sizes
;
3854 printf (_(" Section contributions:\n"));
3855 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3856 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3857 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3858 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3859 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3860 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3861 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3862 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3863 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3864 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3865 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3866 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3870 sec_off
= cu_offset
+ initial_length_size
;
3871 if (sec_off
+ compunit
.cu_length
< sec_off
3872 || sec_off
+ compunit
.cu_length
> section
->size
)
3874 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3876 (unsigned long) cu_offset
,
3877 dwarf_vmatoa ("x", compunit
.cu_length
));
3883 start
+= compunit
.cu_length
+ initial_length_size
;
3885 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3887 warn (_("CU at offset %s contains corrupt or "
3888 "unsupported version number: %d.\n"),
3889 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3893 if (compunit
.cu_unit_type
!= DW_UT_compile
3894 && compunit
.cu_unit_type
!= DW_UT_partial
3895 && compunit
.cu_unit_type
!= DW_UT_type
3896 && compunit
.cu_unit_type
!= DW_UT_split_compile
3897 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3899 warn (_("CU at offset %s contains corrupt or "
3900 "unsupported unit type: %d.\n"),
3901 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3905 /* Process the abbrevs used by this compilation unit. */
3906 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3907 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3908 (unsigned long) compunit
.cu_abbrev_offset
,
3909 (unsigned long) abbrev_size
);
3910 /* PR 17531: file:4bcd9ce9. */
3911 else if ((abbrev_base
+ abbrev_size
)
3912 > debug_displays
[abbrev_sec
].section
.size
)
3913 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3914 (unsigned long) abbrev_base
+ abbrev_size
,
3915 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3918 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3919 compunit
.cu_abbrev_offset
);
3922 unsigned char * next
;
3924 list
= new_abbrev_list (abbrev_base
,
3925 compunit
.cu_abbrev_offset
);
3926 next
= process_abbrev_set
3927 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3928 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3929 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3930 + abbrev_base
+ abbrev_size
),
3932 list
->start_of_next_abbrevs
= next
;
3939 while (tags
< start
)
3941 unsigned long abbrev_number
;
3942 unsigned long die_offset
;
3943 abbrev_entry
*entry
;
3945 int do_printing
= 1;
3947 die_offset
= tags
- section_begin
;
3949 READ_ULEB (abbrev_number
, tags
, start
);
3951 /* A null DIE marks the end of a list of siblings or it may also be
3952 a section padding. */
3953 if (abbrev_number
== 0)
3955 /* Check if it can be a section padding for the last CU. */
3956 if (level
== 0 && start
== end
)
3960 for (chk
= tags
; chk
< start
; chk
++)
3967 if (!do_loc
&& die_offset
>= dwarf_start_die
3968 && (dwarf_cutoff_level
== -1
3969 || level
< dwarf_cutoff_level
))
3970 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3976 static unsigned num_bogus_warns
= 0;
3978 if (num_bogus_warns
< 3)
3980 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3981 die_offset
, section
->name
);
3983 if (num_bogus_warns
== 3)
3984 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3987 if (dwarf_start_die
!= 0 && level
< saved_level
)
3994 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3998 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3999 saved_level
= level
;
4000 do_printing
= (dwarf_cutoff_level
== -1
4001 || level
< dwarf_cutoff_level
);
4003 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
4004 level
, die_offset
, abbrev_number
);
4005 else if (dwarf_cutoff_level
== -1
4006 || last_level
< dwarf_cutoff_level
)
4007 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
4012 /* Scan through the abbreviation list until we reach the
4017 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
4018 if (entry
->number
== abbrev_number
)
4023 if (!do_loc
&& do_printing
)
4028 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
4029 die_offset
, abbrev_number
);
4033 if (!do_loc
&& do_printing
)
4034 printf (" (%s)\n", get_TAG_name (entry
->tag
));
4039 need_base_address
= 0;
4041 case DW_TAG_compile_unit
:
4042 need_base_address
= 1;
4043 need_dwo_info
= do_loc
;
4045 case DW_TAG_entry_point
:
4046 case DW_TAG_subprogram
:
4047 need_base_address
= 0;
4048 /* Assuming that there is no DW_AT_frame_base. */
4049 have_frame_base
= 0;
4053 debug_info
*debug_info_p
=
4054 (debug_information
&& unit
< alloc_num_debug_info_entries
)
4055 ? debug_information
+ unit
: NULL
;
4057 assert (!debug_info_p
4058 || (debug_info_p
->num_loc_offsets
4059 == debug_info_p
->num_loc_views
));
4061 for (attr
= entry
->first_attr
;
4062 attr
&& attr
->attribute
;
4065 if (! do_loc
&& do_printing
)
4066 /* Show the offset from where the tag was extracted. */
4067 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
4068 tags
= read_and_display_attr (attr
->attribute
,
4070 attr
->implicit_const
,
4075 compunit
.cu_pointer_size
,
4077 compunit
.cu_version
,
4079 do_loc
|| ! do_printing
,
4085 /* If a locview attribute appears before a location one,
4086 make sure we don't associate it with an earlier
4089 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
4092 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
4093 debug_info_p
->num_loc_views
++;
4094 assert (debug_info_p
->num_loc_views
4095 == debug_info_p
->num_loc_offsets
);
4102 warn(_("DIE has locviews without loclist\n"));
4103 debug_info_p
->num_loc_views
--;
4110 if (entry
->children
)
4115 /* Set num_debug_info_entries here so that it can be used to check if
4116 we need to process .debug_loc and .debug_ranges sections. */
4117 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
4118 && num_debug_info_entries
== 0
4121 if (num_units
> alloc_num_debug_info_entries
)
4122 num_debug_info_entries
= alloc_num_debug_info_entries
;
4124 num_debug_info_entries
= num_units
;
4133 /* Locate and scan the .debug_info section in the file and record the pointer
4134 sizes and offsets for the compilation units in it. Usually an executable
4135 will have just one pointer size, but this is not guaranteed, and so we try
4136 not to make any assumptions. Returns zero upon failure, or the number of
4137 compilation units upon success. */
4140 load_debug_info (void * file
)
4142 /* If we have already tried and failed to load the .debug_info
4143 section then do not bother to repeat the task. */
4144 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4147 /* If we already have the information there is nothing else to do. */
4148 if (num_debug_info_entries
> 0)
4149 return num_debug_info_entries
;
4151 /* If this is a DWARF package file, load the CU and TU indexes. */
4152 (void) load_cu_tu_indexes (file
);
4154 if (load_debug_section_with_follow (info
, file
)
4155 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
4156 return num_debug_info_entries
;
4158 if (load_debug_section_with_follow (info_dwo
, file
)
4159 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4160 abbrev_dwo
, TRUE
, FALSE
))
4161 return num_debug_info_entries
;
4163 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4167 /* Read a DWARF .debug_line section header starting at DATA.
4168 Upon success returns an updated DATA pointer and the LINFO
4169 structure and the END_OF_SEQUENCE pointer will be filled in.
4170 Otherwise returns NULL. */
4172 static unsigned char *
4173 read_debug_line_header (struct dwarf_section
* section
,
4174 unsigned char * data
,
4175 unsigned char * end
,
4176 DWARF2_Internal_LineInfo
* linfo
,
4177 unsigned char ** end_of_sequence
)
4179 unsigned char *hdrptr
;
4180 unsigned int initial_length_size
;
4182 /* Extract information from the Line Number Program Header.
4183 (section 6.2.4 in the Dwarf3 doc). */
4186 /* Get and check the length of the block. */
4187 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4189 if (linfo
->li_length
== 0xffffffff)
4191 /* This section is 64-bit DWARF 3. */
4192 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4193 linfo
->li_offset_size
= 8;
4194 initial_length_size
= 12;
4198 linfo
->li_offset_size
= 4;
4199 initial_length_size
= 4;
4202 if (linfo
->li_length
+ initial_length_size
> section
->size
)
4204 /* If the length field has a relocation against it, then we should
4205 not complain if it is inaccurate (and probably negative). This
4206 happens in object files when the .debug_line section is actually
4207 comprised of several different .debug_line.* sections, (some of
4208 which may be removed by linker garbage collection), and a relocation
4209 is used to compute the correct length once that is done. */
4210 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4212 linfo
->li_length
= (end
- data
) - initial_length_size
;
4216 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
4217 (long) linfo
->li_length
);
4222 /* Get and check the version number. */
4223 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4225 if (linfo
->li_version
!= 2
4226 && linfo
->li_version
!= 3
4227 && linfo
->li_version
!= 4
4228 && linfo
->li_version
!= 5)
4230 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4231 "is currently supported.\n"));
4235 if (linfo
->li_version
>= 5)
4237 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4239 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4240 if (linfo
->li_segment_size
!= 0)
4242 warn (_("The %s section contains "
4243 "unsupported segment selector size: %d.\n"),
4244 section
->name
, linfo
->li_segment_size
);
4249 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4250 linfo
->li_offset_size
, end
);
4251 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4253 if (linfo
->li_version
>= 4)
4255 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4257 if (linfo
->li_max_ops_per_insn
== 0)
4259 warn (_("Invalid maximum operations per insn.\n"));
4264 linfo
->li_max_ops_per_insn
= 1;
4266 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4267 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4268 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4269 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4271 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
4272 /* PR 17512: file:002-117414-0.004. */
4273 if (* end_of_sequence
> end
)
4275 warn (_("Line length %s extends beyond end of section\n"),
4276 dwarf_vmatoa ("u", linfo
->li_length
));
4277 * end_of_sequence
= end
;
4284 static unsigned char *
4285 display_formatted_table (unsigned char * data
,
4286 unsigned char * start
,
4287 unsigned char * end
,
4288 const DWARF2_Internal_LineInfo
* linfo
,
4289 struct dwarf_section
* section
,
4292 unsigned char *format_start
, format_count
, *format
, formati
;
4293 dwarf_vma data_count
, datai
;
4294 unsigned int namepass
, last_entry
= 0;
4295 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4297 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4298 if (do_checks
&& format_count
> 5)
4299 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4300 table_name
, format_count
);
4302 format_start
= data
;
4303 for (formati
= 0; formati
< format_count
; formati
++)
4305 SKIP_ULEB (data
, end
);
4306 SKIP_ULEB (data
, end
);
4309 warn (_("%s: Corrupt format description entry\n"), table_name
);
4314 READ_ULEB (data_count
, data
, end
);
4315 if (data_count
== 0)
4317 printf (_("\n The %s is empty.\n"), table_name
);
4320 else if (data
== end
)
4322 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
4323 table_name
, dwarf_vmatoa ("x", data_count
));
4327 else if (format_count
== 0)
4329 warn (_("%s: format count is zero, but the table is not empty\n"),
4334 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
4335 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
4338 printf (_(" Entry"));
4339 /* Delay displaying name as the last entry for better screen layout. */
4340 for (namepass
= 0; namepass
< 2; namepass
++)
4342 format
= format_start
;
4343 for (formati
= 0; formati
< format_count
; formati
++)
4345 dwarf_vma content_type
;
4347 READ_ULEB (content_type
, format
, end
);
4348 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4349 switch (content_type
)
4352 printf (_("\tName"));
4354 case DW_LNCT_directory_index
:
4355 printf (_("\tDir"));
4357 case DW_LNCT_timestamp
:
4358 printf (_("\tTime"));
4361 printf (_("\tSize"));
4364 printf (_("\tMD5\t\t\t"));
4367 printf (_("\t(Unknown format content type %s)"),
4368 dwarf_vmatoa ("u", content_type
));
4370 SKIP_ULEB (format
, end
);
4375 for (datai
= 0; datai
< data_count
; datai
++)
4377 unsigned char *datapass
= data
;
4379 printf (" %d", last_entry
++);
4380 /* Delay displaying name as the last entry for better screen layout. */
4381 for (namepass
= 0; namepass
< 2; namepass
++)
4383 format
= format_start
;
4385 for (formati
= 0; formati
< format_count
; formati
++)
4387 dwarf_vma content_type
, form
;
4389 READ_ULEB (content_type
, format
, end
);
4390 READ_ULEB (form
, format
, end
);
4391 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4392 0, 0, linfo
->li_offset_size
,
4393 linfo
->li_version
, NULL
,
4394 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4395 section
, NULL
, '\t', -1);
4399 if (data
== end
&& (datai
< data_count
- 1))
4401 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4410 display_debug_sup (struct dwarf_section
* section
,
4411 void * file ATTRIBUTE_UNUSED
)
4413 unsigned char * start
= section
->start
;
4414 unsigned char * end
= section
->start
+ section
->size
;
4415 unsigned int version
;
4416 char is_supplementary
;
4417 const unsigned char * sup_filename
;
4418 size_t sup_filename_len
;
4419 unsigned int num_read
;
4421 dwarf_vma checksum_len
;
4424 introduce (section
, TRUE
);
4425 if (section
->size
< 4)
4427 error (_("corrupt .debug_sup section: size is too small\n"));
4431 /* Read the data. */
4432 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4434 warn (_("corrupt .debug_sup section: version < 5"));
4436 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4437 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4438 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4440 sup_filename
= start
;
4441 if (is_supplementary
&& sup_filename
[0] != 0)
4442 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4444 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4445 if (sup_filename_len
== (size_t) (end
- start
))
4447 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4450 start
+= sup_filename_len
+ 1;
4452 checksum_len
= read_leb128 (start
, end
, FALSE
/* unsigned */, & num_read
, & status
);
4455 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4459 if (checksum_len
> (dwarf_vma
) (end
- start
))
4461 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4462 checksum_len
= end
- start
;
4464 else if (checksum_len
< (dwarf_vma
) (end
- start
))
4466 warn (_("corrupt .debug_sup section: there are 0x%lx extra, unused bytes at the end of the section\n"),
4467 (long) ((end
- start
) - checksum_len
));
4470 printf (_(" Version: %u\n"), version
);
4471 printf (_(" Is Supp: %u\n"), is_supplementary
);
4472 printf (_(" Filename: %s\n"), sup_filename
);
4473 printf (_(" Checksum Len: %lu\n"), (long) checksum_len
);
4474 if (checksum_len
> 0)
4476 printf (_(" Checksum: "));
4477 while (checksum_len
--)
4478 printf ("0x%x ", * start
++ );
4485 display_debug_lines_raw (struct dwarf_section
* section
,
4486 unsigned char * data
,
4487 unsigned char * end
,
4490 unsigned char *start
= section
->start
;
4491 int verbose_view
= 0;
4493 introduce (section
, TRUE
);
4497 static DWARF2_Internal_LineInfo saved_linfo
;
4498 DWARF2_Internal_LineInfo linfo
;
4499 unsigned char *standard_opcodes
;
4500 unsigned char *end_of_sequence
;
4503 if (const_strneq (section
->name
, ".debug_line.")
4504 /* Note: the following does not apply to .debug_line.dwo sections.
4505 These are full debug_line sections. */
4506 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4508 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4509 section containing just the Line Number Statements. They are
4510 created by the assembler and intended to be used alongside gcc's
4511 -ffunction-sections command line option. When the linker's
4512 garbage collection decides to discard a .text.<foo> section it
4513 can then also discard the line number information in .debug_line.<foo>.
4515 Since the section is a fragment it does not have the details
4516 needed to fill out a LineInfo structure, so instead we use the
4517 details from the last full debug_line section that we processed. */
4518 end_of_sequence
= end
;
4519 standard_opcodes
= NULL
;
4520 linfo
= saved_linfo
;
4521 /* PR 17531: file: 0522b371. */
4522 if (linfo
.li_line_range
== 0)
4524 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4527 reset_state_machine (linfo
.li_default_is_stmt
);
4531 unsigned char * hdrptr
;
4533 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4534 & end_of_sequence
)) == NULL
)
4537 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4538 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4539 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4540 if (linfo
.li_version
>= 5)
4542 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4543 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4545 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4546 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4547 if (linfo
.li_version
>= 4)
4548 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4549 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4550 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4551 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4552 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4554 /* PR 17512: file: 1665-6428-0.004. */
4555 if (linfo
.li_line_range
== 0)
4557 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4558 linfo
.li_line_range
= 1;
4561 reset_state_machine (linfo
.li_default_is_stmt
);
4563 /* Display the contents of the Opcodes table. */
4564 standard_opcodes
= hdrptr
;
4566 /* PR 17512: file: 002-417945-0.004. */
4567 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4569 warn (_("Line Base extends beyond end of section\n"));
4573 printf (_("\n Opcodes:\n"));
4575 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4576 printf (ngettext (" Opcode %d has %d arg\n",
4577 " Opcode %d has %d args\n",
4578 standard_opcodes
[i
- 1]),
4579 i
, standard_opcodes
[i
- 1]);
4581 /* Display the contents of the Directory table. */
4582 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4584 if (linfo
.li_version
>= 5)
4586 load_debug_section_with_follow (line_str
, file
);
4588 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4590 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4596 printf (_("\n The Directory Table is empty.\n"));
4599 unsigned int last_dir_entry
= 0;
4601 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4602 (long)(data
- start
));
4604 while (data
< end
&& *data
!= 0)
4606 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4608 data
+= strnlen ((char *) data
, end
- data
) + 1;
4611 /* PR 17512: file: 002-132094-0.004. */
4612 if (data
>= end
- 1)
4616 /* Skip the NUL at the end of the table. */
4619 /* Display the contents of the File Name table. */
4621 printf (_("\n The File Name Table is empty.\n"));
4624 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4625 (long)(data
- start
));
4626 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4628 while (data
< end
&& *data
!= 0)
4630 unsigned char *name
;
4633 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4635 data
+= strnlen ((char *) data
, end
- data
) + 1;
4637 READ_ULEB (val
, data
, end
);
4638 printf ("%s\t", dwarf_vmatoa ("u", val
));
4639 READ_ULEB (val
, data
, end
);
4640 printf ("%s\t", dwarf_vmatoa ("u", val
));
4641 READ_ULEB (val
, data
, end
);
4642 printf ("%s\t", dwarf_vmatoa ("u", val
));
4643 printf ("%.*s\n", (int)(end
- name
), name
);
4647 warn (_("Corrupt file name table entry\n"));
4653 /* Skip the NUL at the end of the table. */
4658 saved_linfo
= linfo
;
4661 /* Now display the statements. */
4662 if (data
>= end_of_sequence
)
4663 printf (_(" No Line Number Statements.\n"));
4666 printf (_(" Line Number Statements:\n"));
4668 while (data
< end_of_sequence
)
4670 unsigned char op_code
;
4671 dwarf_signed_vma adv
;
4674 printf (" [0x%08lx]", (long)(data
- start
));
4678 if (op_code
>= linfo
.li_opcode_base
)
4680 op_code
-= linfo
.li_opcode_base
;
4681 uladv
= (op_code
/ linfo
.li_line_range
);
4682 if (linfo
.li_max_ops_per_insn
== 1)
4684 uladv
*= linfo
.li_min_insn_length
;
4685 state_machine_regs
.address
+= uladv
;
4687 state_machine_regs
.view
= 0;
4688 printf (_(" Special opcode %d: "
4689 "advance Address by %s to 0x%s%s"),
4690 op_code
, dwarf_vmatoa ("u", uladv
),
4691 dwarf_vmatoa ("x", state_machine_regs
.address
),
4692 verbose_view
&& uladv
4693 ? _(" (reset view)") : "");
4698 = ((state_machine_regs
.op_index
+ uladv
)
4699 / linfo
.li_max_ops_per_insn
)
4700 * linfo
.li_min_insn_length
;
4702 state_machine_regs
.address
+= addrdelta
;
4703 state_machine_regs
.op_index
4704 = (state_machine_regs
.op_index
+ uladv
)
4705 % linfo
.li_max_ops_per_insn
;
4707 state_machine_regs
.view
= 0;
4708 printf (_(" Special opcode %d: "
4709 "advance Address by %s to 0x%s[%d]%s"),
4710 op_code
, dwarf_vmatoa ("u", uladv
),
4711 dwarf_vmatoa ("x", state_machine_regs
.address
),
4712 state_machine_regs
.op_index
,
4713 verbose_view
&& addrdelta
4714 ? _(" (reset view)") : "");
4716 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4717 state_machine_regs
.line
+= adv
;
4718 printf (_(" and Line by %s to %d"),
4719 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4720 if (verbose_view
|| state_machine_regs
.view
)
4721 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4724 state_machine_regs
.view
++;
4729 case DW_LNS_extended_op
:
4730 data
+= process_extended_line_op (data
,
4731 linfo
.li_default_is_stmt
,
4736 printf (_(" Copy"));
4737 if (verbose_view
|| state_machine_regs
.view
)
4738 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4741 state_machine_regs
.view
++;
4744 case DW_LNS_advance_pc
:
4745 READ_ULEB (uladv
, data
, end
);
4746 if (linfo
.li_max_ops_per_insn
== 1)
4748 uladv
*= linfo
.li_min_insn_length
;
4749 state_machine_regs
.address
+= uladv
;
4751 state_machine_regs
.view
= 0;
4752 printf (_(" Advance PC by %s to 0x%s%s\n"),
4753 dwarf_vmatoa ("u", uladv
),
4754 dwarf_vmatoa ("x", state_machine_regs
.address
),
4755 verbose_view
&& uladv
4756 ? _(" (reset view)") : "");
4761 = ((state_machine_regs
.op_index
+ uladv
)
4762 / linfo
.li_max_ops_per_insn
)
4763 * linfo
.li_min_insn_length
;
4764 state_machine_regs
.address
4766 state_machine_regs
.op_index
4767 = (state_machine_regs
.op_index
+ uladv
)
4768 % linfo
.li_max_ops_per_insn
;
4770 state_machine_regs
.view
= 0;
4771 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4772 dwarf_vmatoa ("u", uladv
),
4773 dwarf_vmatoa ("x", state_machine_regs
.address
),
4774 state_machine_regs
.op_index
,
4775 verbose_view
&& addrdelta
4776 ? _(" (reset view)") : "");
4780 case DW_LNS_advance_line
:
4781 READ_SLEB (adv
, data
, end
);
4782 state_machine_regs
.line
+= adv
;
4783 printf (_(" Advance Line by %s to %d\n"),
4784 dwarf_vmatoa ("d", adv
),
4785 state_machine_regs
.line
);
4788 case DW_LNS_set_file
:
4789 READ_ULEB (uladv
, data
, end
);
4790 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4791 dwarf_vmatoa ("u", uladv
));
4792 state_machine_regs
.file
= uladv
;
4795 case DW_LNS_set_column
:
4796 READ_ULEB (uladv
, data
, end
);
4797 printf (_(" Set column to %s\n"),
4798 dwarf_vmatoa ("u", uladv
));
4799 state_machine_regs
.column
= uladv
;
4802 case DW_LNS_negate_stmt
:
4803 adv
= state_machine_regs
.is_stmt
;
4805 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4806 state_machine_regs
.is_stmt
= adv
;
4809 case DW_LNS_set_basic_block
:
4810 printf (_(" Set basic block\n"));
4811 state_machine_regs
.basic_block
= 1;
4814 case DW_LNS_const_add_pc
:
4815 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4816 if (linfo
.li_max_ops_per_insn
)
4818 uladv
*= linfo
.li_min_insn_length
;
4819 state_machine_regs
.address
+= uladv
;
4821 state_machine_regs
.view
= 0;
4822 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4823 dwarf_vmatoa ("u", uladv
),
4824 dwarf_vmatoa ("x", state_machine_regs
.address
),
4825 verbose_view
&& uladv
4826 ? _(" (reset view)") : "");
4831 = ((state_machine_regs
.op_index
+ uladv
)
4832 / linfo
.li_max_ops_per_insn
)
4833 * linfo
.li_min_insn_length
;
4834 state_machine_regs
.address
4836 state_machine_regs
.op_index
4837 = (state_machine_regs
.op_index
+ uladv
)
4838 % linfo
.li_max_ops_per_insn
;
4840 state_machine_regs
.view
= 0;
4841 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4842 dwarf_vmatoa ("u", uladv
),
4843 dwarf_vmatoa ("x", state_machine_regs
.address
),
4844 state_machine_regs
.op_index
,
4845 verbose_view
&& addrdelta
4846 ? _(" (reset view)") : "");
4850 case DW_LNS_fixed_advance_pc
:
4851 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4852 state_machine_regs
.address
+= uladv
;
4853 state_machine_regs
.op_index
= 0;
4854 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4855 dwarf_vmatoa ("u", uladv
),
4856 dwarf_vmatoa ("x", state_machine_regs
.address
));
4857 /* Do NOT reset view. */
4860 case DW_LNS_set_prologue_end
:
4861 printf (_(" Set prologue_end to true\n"));
4864 case DW_LNS_set_epilogue_begin
:
4865 printf (_(" Set epilogue_begin to true\n"));
4868 case DW_LNS_set_isa
:
4869 READ_ULEB (uladv
, data
, end
);
4870 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4874 printf (_(" Unknown opcode %d with operands: "), op_code
);
4876 if (standard_opcodes
!= NULL
)
4877 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4879 READ_ULEB (uladv
, data
, end
);
4880 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4881 i
== 1 ? "" : ", ");
4896 unsigned char *name
;
4897 unsigned int directory_index
;
4898 unsigned int modification_date
;
4899 unsigned int length
;
4902 /* Output a decoded representation of the .debug_line section. */
4905 display_debug_lines_decoded (struct dwarf_section
* section
,
4906 unsigned char * start
,
4907 unsigned char * data
,
4908 unsigned char * end
,
4911 static DWARF2_Internal_LineInfo saved_linfo
;
4913 introduce (section
, FALSE
);
4917 /* This loop amounts to one iteration per compilation unit. */
4918 DWARF2_Internal_LineInfo linfo
;
4919 unsigned char *standard_opcodes
;
4920 unsigned char *end_of_sequence
;
4922 File_Entry
*file_table
= NULL
;
4923 unsigned int n_files
= 0;
4924 unsigned char **directory_table
= NULL
;
4925 dwarf_vma n_directories
= 0;
4927 if (const_strneq (section
->name
, ".debug_line.")
4928 /* Note: the following does not apply to .debug_line.dwo sections.
4929 These are full debug_line sections. */
4930 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4932 /* See comment in display_debug_lines_raw(). */
4933 end_of_sequence
= end
;
4934 standard_opcodes
= NULL
;
4935 linfo
= saved_linfo
;
4936 /* PR 17531: file: 0522b371. */
4937 if (linfo
.li_line_range
== 0)
4939 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4942 reset_state_machine (linfo
.li_default_is_stmt
);
4946 unsigned char *hdrptr
;
4948 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4949 & end_of_sequence
)) == NULL
)
4952 /* PR 17531: file: 0522b371. */
4953 if (linfo
.li_line_range
== 0)
4955 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4956 linfo
.li_line_range
= 1;
4958 reset_state_machine (linfo
.li_default_is_stmt
);
4960 /* Save a pointer to the contents of the Opcodes table. */
4961 standard_opcodes
= hdrptr
;
4963 /* Traverse the Directory table just to count entries. */
4964 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4968 warn (_("opcode base of %d extends beyond end of section\n"),
4969 linfo
.li_opcode_base
);
4973 if (linfo
.li_version
>= 5)
4975 unsigned char *format_start
, format_count
, *format
;
4976 dwarf_vma formati
, entryi
;
4978 load_debug_section_with_follow (line_str
, fileptr
);
4980 /* Skip directories format. */
4981 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4982 if (do_checks
&& format_count
> 1)
4983 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4985 format_start
= data
;
4986 for (formati
= 0; formati
< format_count
; formati
++)
4988 SKIP_ULEB (data
, end
);
4989 SKIP_ULEB (data
, end
);
4992 READ_ULEB (n_directories
, data
, end
);
4995 warn (_("Corrupt directories list\n"));
4999 if (n_directories
== 0)
5000 directory_table
= NULL
;
5002 directory_table
= (unsigned char **)
5003 xmalloc (n_directories
* sizeof (unsigned char *));
5005 for (entryi
= 0; entryi
< n_directories
; entryi
++)
5007 unsigned char **pathp
= &directory_table
[entryi
];
5009 format
= format_start
;
5010 for (formati
= 0; formati
< format_count
; formati
++)
5012 dwarf_vma content_type
, form
;
5015 READ_ULEB (content_type
, format
, end
);
5016 READ_ULEB (form
, format
, end
);
5019 warn (_("Corrupt directories list\n"));
5022 switch (content_type
)
5027 case DW_FORM_string
:
5030 case DW_FORM_line_strp
:
5031 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
5033 /* Remove const by the cast. */
5034 *pathp
= (unsigned char *)
5035 fetch_indirect_line_string (uvalue
);
5040 data
= read_and_display_attr_value (0, form
, 0, start
,
5042 linfo
.li_offset_size
,
5049 warn (_("Corrupt directories list\n"));
5054 /* Skip files format. */
5055 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
5056 if (do_checks
&& format_count
> 5)
5057 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
5059 format_start
= data
;
5060 for (formati
= 0; formati
< format_count
; formati
++)
5062 SKIP_ULEB (data
, end
);
5063 SKIP_ULEB (data
, end
);
5066 READ_ULEB (n_files
, data
, end
);
5067 if (data
== end
&& n_files
> 0)
5069 warn (_("Corrupt file name list\n"));
5076 file_table
= (File_Entry
*) xcalloc (1, n_files
5077 * sizeof (File_Entry
));
5079 for (entryi
= 0; entryi
< n_files
; entryi
++)
5081 File_Entry
*file
= &file_table
[entryi
];
5083 format
= format_start
;
5084 for (formati
= 0; formati
< format_count
; formati
++)
5086 dwarf_vma content_type
, form
;
5090 READ_ULEB (content_type
, format
, end
);
5091 READ_ULEB (form
, format
, end
);
5094 warn (_("Corrupt file name list\n"));
5097 switch (content_type
)
5102 case DW_FORM_string
:
5105 case DW_FORM_line_strp
:
5106 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
5108 /* Remove const by the cast. */
5109 file
->name
= (unsigned char *)
5110 fetch_indirect_line_string (uvalue
);
5114 case DW_LNCT_directory_index
:
5118 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5122 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5127 READ_ULEB (file
->directory_index
, tmp
, end
);
5132 data
= read_and_display_attr_value (0, form
, 0, start
,
5134 linfo
.li_offset_size
,
5141 warn (_("Corrupt file name list\n"));
5150 unsigned char *ptr_directory_table
= data
;
5152 while (data
< end
&& *data
!= 0)
5154 data
+= strnlen ((char *) data
, end
- data
) + 1;
5161 warn (_("directory table ends unexpectedly\n"));
5166 /* Go through the directory table again to save the directories. */
5167 directory_table
= (unsigned char **)
5168 xmalloc (n_directories
* sizeof (unsigned char *));
5171 while (*ptr_directory_table
!= 0)
5173 directory_table
[i
] = ptr_directory_table
;
5174 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
5175 ptr_directory_table
- end
) + 1;
5179 /* Skip the NUL at the end of the table. */
5182 /* Traverse the File Name table just to count the entries. */
5183 if (data
< end
&& *data
!= 0)
5185 unsigned char *ptr_file_name_table
= data
;
5187 while (data
< end
&& *data
!= 0)
5189 /* Skip Name, directory index, last modification
5190 time and length of file. */
5191 data
+= strnlen ((char *) data
, end
- data
) + 1;
5192 SKIP_ULEB (data
, end
);
5193 SKIP_ULEB (data
, end
);
5194 SKIP_ULEB (data
, end
);
5200 warn (_("file table ends unexpectedly\n"));
5205 /* Go through the file table again to save the strings. */
5206 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5209 while (*ptr_file_name_table
!= 0)
5211 file_table
[i
].name
= ptr_file_name_table
;
5212 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
5213 end
- ptr_file_name_table
) + 1;
5215 /* We are not interested in directory, time or size. */
5216 READ_ULEB (file_table
[i
].directory_index
,
5217 ptr_file_name_table
, end
);
5218 READ_ULEB (file_table
[i
].modification_date
,
5219 ptr_file_name_table
, end
);
5220 READ_ULEB (file_table
[i
].length
,
5221 ptr_file_name_table
, end
);
5227 /* Skip the NUL at the end of the table. */
5231 /* Print the Compilation Unit's name and a header. */
5232 if (file_table
== NULL
)
5233 printf (_("CU: No directory table\n"));
5234 else if (directory_table
== NULL
)
5235 printf (_("CU: %s:\n"), file_table
[0].name
);
5238 unsigned int ix
= file_table
[0].directory_index
;
5239 const char *directory
;
5244 else if (n_directories
== 0)
5245 directory
= _("<unknown>");
5246 else if (ix
> n_directories
)
5248 warn (_("directory index %u > number of directories %s\n"),
5249 ix
, dwarf_vmatoa ("u", n_directories
));
5250 directory
= _("<corrupt>");
5253 directory
= (char *) directory_table
[ix
- 1];
5255 if (do_wide
|| strlen (directory
) < 76)
5256 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5258 printf ("%s:\n", file_table
[0].name
);
5262 printf (_("File name Line number Starting address View Stmt\n"));
5264 printf (_("CU: Empty file name table\n"));
5265 saved_linfo
= linfo
;
5268 /* This loop iterates through the Dwarf Line Number Program. */
5269 while (data
< end_of_sequence
)
5271 unsigned char op_code
;
5274 unsigned long int uladv
;
5275 int is_special_opcode
= 0;
5280 if (op_code
>= linfo
.li_opcode_base
)
5282 op_code
-= linfo
.li_opcode_base
;
5283 uladv
= (op_code
/ linfo
.li_line_range
);
5284 if (linfo
.li_max_ops_per_insn
== 1)
5286 uladv
*= linfo
.li_min_insn_length
;
5287 state_machine_regs
.address
+= uladv
;
5289 state_machine_regs
.view
= 0;
5294 = ((state_machine_regs
.op_index
+ uladv
)
5295 / linfo
.li_max_ops_per_insn
)
5296 * linfo
.li_min_insn_length
;
5297 state_machine_regs
.address
5299 state_machine_regs
.op_index
5300 = (state_machine_regs
.op_index
+ uladv
)
5301 % linfo
.li_max_ops_per_insn
;
5303 state_machine_regs
.view
= 0;
5306 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5307 state_machine_regs
.line
+= adv
;
5308 is_special_opcode
= 1;
5309 /* Increment view after printing this row. */
5314 case DW_LNS_extended_op
:
5316 unsigned int ext_op_code_len
;
5317 unsigned char ext_op_code
;
5318 unsigned char *op_code_end
;
5319 unsigned char *op_code_data
= data
;
5321 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5322 op_code_end
= op_code_data
+ ext_op_code_len
;
5323 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5325 warn (_("Badly formed extended line op encountered!\n"));
5328 ext_op_code
= *op_code_data
++;
5332 switch (ext_op_code
)
5334 case DW_LNE_end_sequence
:
5335 /* Reset stuff after printing this row. */
5337 case DW_LNE_set_address
:
5338 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5340 op_code_end
- op_code_data
,
5342 state_machine_regs
.op_index
= 0;
5343 state_machine_regs
.view
= 0;
5345 case DW_LNE_define_file
:
5346 file_table
= (File_Entry
*) xrealloc
5347 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5349 ++state_machine_regs
.last_file_entry
;
5350 /* Source file name. */
5351 file_table
[n_files
].name
= op_code_data
;
5352 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5353 /* Directory index. */
5354 READ_ULEB (file_table
[n_files
].directory_index
,
5355 op_code_data
, op_code_end
);
5356 /* Last modification time. */
5357 READ_ULEB (file_table
[n_files
].modification_date
,
5358 op_code_data
, op_code_end
);
5360 READ_ULEB (file_table
[n_files
].length
,
5361 op_code_data
, op_code_end
);
5365 case DW_LNE_set_discriminator
:
5366 case DW_LNE_HP_set_sequence
:
5367 /* Simply ignored. */
5371 printf (_("UNKNOWN (%u): length %ld\n"),
5372 ext_op_code
, (long int) (op_code_data
- data
));
5379 /* Increment view after printing this row. */
5382 case DW_LNS_advance_pc
:
5383 READ_ULEB (uladv
, data
, end
);
5384 if (linfo
.li_max_ops_per_insn
== 1)
5386 uladv
*= linfo
.li_min_insn_length
;
5387 state_machine_regs
.address
+= uladv
;
5389 state_machine_regs
.view
= 0;
5394 = ((state_machine_regs
.op_index
+ uladv
)
5395 / linfo
.li_max_ops_per_insn
)
5396 * linfo
.li_min_insn_length
;
5397 state_machine_regs
.address
5399 state_machine_regs
.op_index
5400 = (state_machine_regs
.op_index
+ uladv
)
5401 % linfo
.li_max_ops_per_insn
;
5403 state_machine_regs
.view
= 0;
5407 case DW_LNS_advance_line
:
5408 READ_SLEB (adv
, data
, end
);
5409 state_machine_regs
.line
+= adv
;
5412 case DW_LNS_set_file
:
5413 READ_ULEB (uladv
, data
, end
);
5414 state_machine_regs
.file
= uladv
;
5417 unsigned file
= state_machine_regs
.file
- 1;
5420 if (file_table
== NULL
|| n_files
== 0)
5421 printf (_("\n [Use file table entry %d]\n"), file
);
5423 else if (file
>= n_files
)
5425 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
5426 printf (_("\n <over large file table index %u>"), file
);
5428 else if ((dir
= file_table
[file
].directory_index
) == 0)
5429 /* If directory index is 0, that means current directory. */
5430 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5431 else if (directory_table
== NULL
|| n_directories
== 0)
5432 printf (_("\n [Use file %s in directory table entry %d]\n"),
5433 file_table
[file
].name
, dir
);
5435 else if (dir
> n_directories
)
5437 warn (_("directory index %u > number of directories %s\n"),
5438 dir
, dwarf_vmatoa ("u", n_directories
));
5439 printf (_("\n <over large directory table entry %u>\n"), dir
);
5442 printf ("\n%s/%s:\n",
5443 /* The directory index starts counting at 1. */
5444 directory_table
[dir
- 1], file_table
[file
].name
);
5448 case DW_LNS_set_column
:
5449 READ_ULEB (uladv
, data
, end
);
5450 state_machine_regs
.column
= uladv
;
5453 case DW_LNS_negate_stmt
:
5454 adv
= state_machine_regs
.is_stmt
;
5456 state_machine_regs
.is_stmt
= adv
;
5459 case DW_LNS_set_basic_block
:
5460 state_machine_regs
.basic_block
= 1;
5463 case DW_LNS_const_add_pc
:
5464 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5465 if (linfo
.li_max_ops_per_insn
== 1)
5467 uladv
*= linfo
.li_min_insn_length
;
5468 state_machine_regs
.address
+= uladv
;
5470 state_machine_regs
.view
= 0;
5475 = ((state_machine_regs
.op_index
+ uladv
)
5476 / linfo
.li_max_ops_per_insn
)
5477 * linfo
.li_min_insn_length
;
5478 state_machine_regs
.address
5480 state_machine_regs
.op_index
5481 = (state_machine_regs
.op_index
+ uladv
)
5482 % linfo
.li_max_ops_per_insn
;
5484 state_machine_regs
.view
= 0;
5488 case DW_LNS_fixed_advance_pc
:
5489 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5490 state_machine_regs
.address
+= uladv
;
5491 state_machine_regs
.op_index
= 0;
5492 /* Do NOT reset view. */
5495 case DW_LNS_set_prologue_end
:
5498 case DW_LNS_set_epilogue_begin
:
5501 case DW_LNS_set_isa
:
5502 READ_ULEB (uladv
, data
, end
);
5503 printf (_(" Set ISA to %lu\n"), uladv
);
5507 printf (_(" Unknown opcode %d with operands: "), op_code
);
5509 if (standard_opcodes
!= NULL
)
5510 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5514 READ_ULEB (val
, data
, end
);
5515 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5516 i
== 1 ? "" : ", ");
5522 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5523 to the DWARF address/line matrix. */
5524 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5525 || (xop
== DW_LNS_copy
))
5527 const unsigned int MAX_FILENAME_LENGTH
= 35;
5529 char *newFileName
= NULL
;
5530 size_t fileNameLength
;
5534 unsigned indx
= state_machine_regs
.file
- 1;
5536 if (indx
>= n_files
)
5538 warn (_("corrupt file index %u encountered\n"), indx
);
5539 fileName
= _("<corrupt>");
5542 fileName
= (char *) file_table
[indx
].name
;
5545 fileName
= _("<unknown>");
5547 fileNameLength
= strlen (fileName
);
5549 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
5551 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5552 /* Truncate file name */
5553 strncpy (newFileName
,
5554 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5555 MAX_FILENAME_LENGTH
+ 1);
5556 /* FIXME: This is to pacify gcc-10 which can warn that the
5557 strncpy above might leave a non-NUL terminated string
5558 in newFileName. It won't, but gcc's analysis doesn't
5559 quite go far enough to discover this. */
5560 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5564 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
5565 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
5568 /* A row with end_seq set to true has a meaningful address, but
5569 the other information in the same row is not significant.
5570 In such a row, print line as "-", and don't print
5572 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
5574 if (linfo
.li_max_ops_per_insn
== 1)
5576 if (xop
== -DW_LNE_end_sequence
)
5577 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5579 state_machine_regs
.address
);
5581 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5582 newFileName
, state_machine_regs
.line
,
5583 state_machine_regs
.address
);
5587 if (xop
== -DW_LNE_end_sequence
)
5588 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5590 state_machine_regs
.address
,
5591 state_machine_regs
.op_index
);
5593 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5594 newFileName
, state_machine_regs
.line
,
5595 state_machine_regs
.address
,
5596 state_machine_regs
.op_index
);
5601 if (linfo
.li_max_ops_per_insn
== 1)
5603 if (xop
== -DW_LNE_end_sequence
)
5604 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5606 state_machine_regs
.address
);
5608 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5609 newFileName
, state_machine_regs
.line
,
5610 state_machine_regs
.address
);
5614 if (xop
== -DW_LNE_end_sequence
)
5615 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5617 state_machine_regs
.address
,
5618 state_machine_regs
.op_index
);
5620 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5621 newFileName
, state_machine_regs
.line
,
5622 state_machine_regs
.address
,
5623 state_machine_regs
.op_index
);
5627 if (xop
!= -DW_LNE_end_sequence
)
5629 if (state_machine_regs
.view
)
5630 printf (" %6u", state_machine_regs
.view
);
5634 if (state_machine_regs
.is_stmt
)
5639 state_machine_regs
.view
++;
5641 if (xop
== -DW_LNE_end_sequence
)
5643 reset_state_machine (linfo
.li_default_is_stmt
);
5658 if (directory_table
)
5660 free (directory_table
);
5661 directory_table
= NULL
;
5672 display_debug_lines (struct dwarf_section
*section
, void *file
)
5674 unsigned char *data
= section
->start
;
5675 unsigned char *end
= data
+ section
->size
;
5677 int retValDecoded
= 1;
5679 if (do_debug_lines
== 0)
5680 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5682 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5683 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5685 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5686 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5688 if (!retValRaw
|| !retValDecoded
)
5695 find_debug_info_for_offset (unsigned long offset
)
5699 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5702 for (i
= 0; i
< num_debug_info_entries
; i
++)
5703 if (debug_information
[i
].cu_offset
== offset
)
5704 return debug_information
+ i
;
5710 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5712 /* See gdb/gdb-index.h. */
5713 static const char * const kinds
[] =
5725 return _ (kinds
[kind
]);
5729 display_debug_pubnames_worker (struct dwarf_section
*section
,
5730 void *file ATTRIBUTE_UNUSED
,
5733 DWARF2_Internal_PubNames names
;
5734 unsigned char *start
= section
->start
;
5735 unsigned char *end
= start
+ section
->size
;
5737 /* It does not matter if this load fails,
5738 we test for that later on. */
5739 load_debug_info (file
);
5741 introduce (section
, FALSE
);
5745 unsigned char *data
;
5746 unsigned long sec_off
;
5747 unsigned int offset_size
, initial_length_size
;
5749 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5750 if (names
.pn_length
== 0xffffffff)
5752 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5754 initial_length_size
= 12;
5759 initial_length_size
= 4;
5762 sec_off
= start
- section
->start
;
5763 if (sec_off
+ names
.pn_length
< sec_off
5764 || sec_off
+ names
.pn_length
> section
->size
)
5766 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5768 sec_off
- initial_length_size
,
5769 dwarf_vmatoa ("x", names
.pn_length
));
5774 start
+= names
.pn_length
;
5776 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5777 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5779 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5780 && num_debug_info_entries
> 0
5781 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5782 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5783 (unsigned long) names
.pn_offset
, section
->name
);
5785 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5787 printf (_(" Length: %ld\n"),
5788 (long) names
.pn_length
);
5789 printf (_(" Version: %d\n"),
5791 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5792 (unsigned long) names
.pn_offset
);
5793 printf (_(" Size of area in .debug_info section: %ld\n"),
5794 (long) names
.pn_size
);
5796 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5798 static int warned
= 0;
5802 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5810 printf (_("\n Offset Kind Name\n"));
5812 printf (_("\n Offset\tName\n"));
5816 bfd_size_type maxprint
;
5819 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5824 data
+= offset_size
;
5827 maxprint
= (end
- data
) - 1;
5831 unsigned int kind_data
;
5832 gdb_index_symbol_kind kind
;
5833 const char *kind_name
;
5836 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5839 /* GCC computes the kind as the upper byte in the CU index
5840 word, and then right shifts it by the CU index size.
5841 Left shift KIND to where the gdb-index.h accessor macros
5843 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5844 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5845 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5846 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5847 printf (" %-6lx %s,%-10s %.*s\n",
5848 (unsigned long) offset
, is_static
? _("s") : _("g"),
5849 kind_name
, (int) maxprint
, data
);
5852 printf (" %-6lx\t%.*s\n",
5853 (unsigned long) offset
, (int) maxprint
, data
);
5855 data
+= strnlen ((char *) data
, maxprint
) + 1;
5866 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5868 return display_debug_pubnames_worker (section
, file
, 0);
5872 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5874 return display_debug_pubnames_worker (section
, file
, 1);
5878 display_debug_macinfo (struct dwarf_section
*section
,
5879 void *file ATTRIBUTE_UNUSED
)
5881 unsigned char *start
= section
->start
;
5882 unsigned char *end
= start
+ section
->size
;
5883 unsigned char *curr
= start
;
5884 enum dwarf_macinfo_record_type op
;
5886 introduce (section
, FALSE
);
5890 unsigned int lineno
;
5891 const unsigned char *string
;
5893 op
= (enum dwarf_macinfo_record_type
) *curr
;
5898 case DW_MACINFO_start_file
:
5900 unsigned int filenum
;
5902 READ_ULEB (lineno
, curr
, end
);
5903 READ_ULEB (filenum
, curr
, end
);
5904 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5909 case DW_MACINFO_end_file
:
5910 printf (_(" DW_MACINFO_end_file\n"));
5913 case DW_MACINFO_define
:
5914 READ_ULEB (lineno
, curr
, end
);
5916 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5917 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5921 case DW_MACINFO_undef
:
5922 READ_ULEB (lineno
, curr
, end
);
5924 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5925 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5929 case DW_MACINFO_vendor_ext
:
5931 unsigned int constant
;
5933 READ_ULEB (constant
, curr
, end
);
5935 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5936 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5946 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5947 filename and dirname corresponding to file name table entry with index
5948 FILEIDX. Return NULL on failure. */
5950 static unsigned char *
5951 get_line_filename_and_dirname (dwarf_vma line_offset
,
5953 unsigned char **dir_name
)
5955 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5956 unsigned char *hdrptr
, *dirtable
, *file_name
;
5957 unsigned int offset_size
, initial_length_size
;
5958 unsigned int version
, opcode_base
;
5959 dwarf_vma length
, diridx
;
5960 const unsigned char * end
;
5963 if (section
->start
== NULL
5964 || line_offset
>= section
->size
5968 hdrptr
= section
->start
+ line_offset
;
5969 end
= section
->start
+ section
->size
;
5971 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5972 if (length
== 0xffffffff)
5974 /* This section is 64-bit DWARF 3. */
5975 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5977 initial_length_size
= 12;
5982 initial_length_size
= 4;
5984 if (length
+ initial_length_size
< length
5985 || length
+ initial_length_size
> section
->size
)
5988 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5989 if (version
!= 2 && version
!= 3 && version
!= 4)
5991 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5993 hdrptr
++; /* Skip max_ops_per_insn. */
5994 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5996 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5997 if (opcode_base
== 0)
6000 hdrptr
+= opcode_base
- 1;
6005 /* Skip over dirname table. */
6006 while (*hdrptr
!= '\0')
6008 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
6012 hdrptr
++; /* Skip the NUL at the end of the table. */
6014 /* Now skip over preceding filename table entries. */
6015 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
6017 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
6018 SKIP_ULEB (hdrptr
, end
);
6019 SKIP_ULEB (hdrptr
, end
);
6020 SKIP_ULEB (hdrptr
, end
);
6022 if (hdrptr
>= end
|| *hdrptr
== '\0')
6026 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
6029 READ_ULEB (diridx
, hdrptr
, end
);
6032 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
6033 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
6034 if (dirtable
>= end
|| *dirtable
== '\0')
6036 *dir_name
= dirtable
;
6041 display_debug_macro (struct dwarf_section
*section
,
6044 unsigned char *start
= section
->start
;
6045 unsigned char *end
= start
+ section
->size
;
6046 unsigned char *curr
= start
;
6047 unsigned char *extended_op_buf
[256];
6048 bfd_boolean is_dwo
= FALSE
;
6049 const char *suffix
= strrchr (section
->name
, '.');
6051 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6054 load_debug_section_with_follow (str
, file
);
6055 load_debug_section_with_follow (line
, file
);
6056 load_debug_section_with_follow (str_index
, file
);
6058 introduce (section
, FALSE
);
6062 unsigned int lineno
, version
, flags
;
6063 unsigned int offset_size
;
6064 const unsigned char *string
;
6065 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
6066 unsigned char **extended_ops
= NULL
;
6068 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6069 if (version
!= 4 && version
!= 5)
6071 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
6072 section
->name
, version
);
6076 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
6077 offset_size
= (flags
& 1) ? 8 : 4;
6078 printf (_(" Offset: 0x%lx\n"),
6079 (unsigned long) sec_offset
);
6080 printf (_(" Version: %d\n"), version
);
6081 printf (_(" Offset size: %d\n"), offset_size
);
6084 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
6085 printf (_(" Offset into .debug_line: 0x%lx\n"),
6086 (unsigned long) line_offset
);
6090 unsigned int i
, count
, op
;
6093 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
6095 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
6096 extended_ops
= extended_op_buf
;
6099 printf (_(" Extension opcode arguments:\n"));
6100 for (i
= 0; i
< count
; i
++)
6102 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6103 extended_ops
[op
] = curr
;
6104 READ_ULEB (nargs
, curr
, end
);
6106 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
6109 printf (_(" DW_MACRO_%02x arguments: "), op
);
6110 for (n
= 0; n
< nargs
; n
++)
6114 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6115 printf ("%s%s", get_FORM_name (form
),
6116 n
== nargs
- 1 ? "\n" : ", ");
6126 case DW_FORM_block1
:
6127 case DW_FORM_block2
:
6128 case DW_FORM_block4
:
6130 case DW_FORM_string
:
6132 case DW_FORM_sec_offset
:
6135 error (_("Invalid extension opcode form %s\n"),
6136 get_FORM_name (form
));
6152 error (_(".debug_macro section not zero terminated\n"));
6156 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6162 case DW_MACRO_define
:
6163 READ_ULEB (lineno
, curr
, end
);
6165 curr
+= strnlen ((char *) string
, end
- string
) + 1;
6166 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
6170 case DW_MACRO_undef
:
6171 READ_ULEB (lineno
, curr
, end
);
6173 curr
+= strnlen ((char *) string
, end
- string
) + 1;
6174 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
6178 case DW_MACRO_start_file
:
6180 unsigned int filenum
;
6181 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6183 READ_ULEB (lineno
, curr
, end
);
6184 READ_ULEB (filenum
, curr
, end
);
6186 if ((flags
& 2) == 0)
6187 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6190 = get_line_filename_and_dirname (line_offset
, filenum
,
6192 if (file_name
== NULL
)
6193 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6196 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6198 dir_name
!= NULL
? (const char *) dir_name
: "",
6199 dir_name
!= NULL
? "/" : "", file_name
);
6203 case DW_MACRO_end_file
:
6204 printf (_(" DW_MACRO_end_file\n"));
6207 case DW_MACRO_define_strp
:
6208 READ_ULEB (lineno
, curr
, end
);
6209 if (version
== 4 && is_dwo
)
6210 READ_ULEB (offset
, curr
, end
);
6212 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6213 string
= fetch_indirect_string (offset
);
6214 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6218 case DW_MACRO_undef_strp
:
6219 READ_ULEB (lineno
, curr
, end
);
6220 if (version
== 4 && is_dwo
)
6221 READ_ULEB (offset
, curr
, end
);
6223 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6224 string
= fetch_indirect_string (offset
);
6225 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6229 case DW_MACRO_import
:
6230 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6231 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6232 (unsigned long) offset
);
6235 case DW_MACRO_define_sup
:
6236 READ_ULEB (lineno
, curr
, end
);
6237 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6238 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6239 lineno
, (unsigned long) offset
);
6242 case DW_MACRO_undef_sup
:
6243 READ_ULEB (lineno
, curr
, end
);
6244 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6245 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6246 lineno
, (unsigned long) offset
);
6249 case DW_MACRO_import_sup
:
6250 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6251 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6252 (unsigned long) offset
);
6255 case DW_MACRO_define_strx
:
6256 case DW_MACRO_undef_strx
:
6257 READ_ULEB (lineno
, curr
, end
);
6258 READ_ULEB (offset
, curr
, end
);
6259 string
= (const unsigned char *)
6260 fetch_indexed_string (offset
, NULL
, offset_size
, FALSE
);
6261 if (op
== DW_MACRO_define_strx
)
6262 printf (" DW_MACRO_define_strx ");
6264 printf (" DW_MACRO_undef_strx ");
6266 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6267 printf (_("lineno : %d macro : %s\n"),
6272 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6274 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6278 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6280 error (_(" Unknown macro opcode %02x seen\n"), op
);
6285 /* Skip over unhandled opcodes. */
6287 unsigned char *desc
= extended_ops
[op
];
6288 READ_ULEB (nargs
, desc
, end
);
6291 printf (_(" DW_MACRO_%02x\n"), op
);
6294 printf (_(" DW_MACRO_%02x -"), op
);
6295 for (n
= 0; n
< nargs
; n
++)
6299 /* DW_FORM_implicit_const is not expected here. */
6300 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6302 = read_and_display_attr_value (0, val
, 0,
6303 start
, curr
, end
, 0, 0, offset_size
,
6304 version
, NULL
, 0, NULL
,
6322 display_debug_abbrev (struct dwarf_section
*section
,
6323 void *file ATTRIBUTE_UNUSED
)
6325 abbrev_entry
*entry
;
6326 unsigned char *start
= section
->start
;
6327 const unsigned char *end
= start
+ section
->size
;
6329 introduce (section
, FALSE
);
6336 offset
= start
- section
->start
;
6337 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6340 list
= new_abbrev_list (0, offset
);
6341 start
= process_abbrev_set (start
, end
, list
);
6342 list
->start_of_next_abbrevs
= start
;
6345 start
= list
->start_of_next_abbrevs
;
6347 if (list
->first_abbrev
== NULL
)
6350 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6352 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6356 printf (" %ld %s [%s]\n",
6358 get_TAG_name (entry
->tag
),
6359 entry
->children
? _("has children") : _("no children"));
6361 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6363 printf (" %-18s %s",
6364 get_AT_name (attr
->attribute
),
6365 get_FORM_name (attr
->form
));
6366 if (attr
->form
== DW_FORM_implicit_const
)
6367 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
6379 /* Return true when ADDR is the maximum address, when addresses are
6380 POINTER_SIZE bytes long. */
6383 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6385 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6386 return ((addr
& mask
) == mask
);
6389 /* Display a view pair list starting at *VSTART_PTR and ending at
6390 VLISTEND within SECTION. */
6393 display_view_pair_list (struct dwarf_section
*section
,
6394 unsigned char **vstart_ptr
,
6395 unsigned int debug_info_entry
,
6396 unsigned char *vlistend
)
6398 unsigned char *vstart
= *vstart_ptr
;
6399 unsigned char *section_end
= section
->start
+ section
->size
;
6400 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6402 if (vlistend
< section_end
)
6403 section_end
= vlistend
;
6407 while (vstart
< section_end
)
6409 dwarf_vma off
= vstart
- section
->start
;
6410 dwarf_vma vbegin
, vend
;
6412 READ_ULEB (vbegin
, vstart
, section_end
);
6413 if (vstart
== section_end
)
6416 READ_ULEB (vend
, vstart
, section_end
);
6417 printf (" %8.8lx ", (unsigned long) off
);
6419 print_dwarf_view (vbegin
, pointer_size
, 1);
6420 print_dwarf_view (vend
, pointer_size
, 1);
6421 printf (_("location view pair\n"));
6425 *vstart_ptr
= vstart
;
6428 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6431 display_loc_list (struct dwarf_section
*section
,
6432 unsigned char **start_ptr
,
6433 unsigned int debug_info_entry
,
6435 dwarf_vma base_address
,
6436 unsigned char **vstart_ptr
,
6439 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6440 unsigned char *section_end
= section
->start
+ section
->size
;
6441 unsigned long cu_offset
;
6442 unsigned int pointer_size
;
6443 unsigned int offset_size
;
6448 unsigned short length
;
6449 int need_frame_base
;
6451 if (debug_info_entry
>= num_debug_info_entries
)
6453 warn (_("No debug information available for loc lists of entry: %u\n"),
6458 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6459 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6460 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6461 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6463 if (pointer_size
< 2 || pointer_size
> 8)
6465 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6466 pointer_size
, debug_info_entry
);
6472 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6473 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6475 if (start
+ 2 * pointer_size
> section_end
)
6477 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6478 (unsigned long) offset
);
6482 printf (" %8.8lx ", (unsigned long) off
);
6484 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6485 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6487 if (begin
== 0 && end
== 0)
6489 /* PR 18374: In a object file we can have a location list that
6490 starts with a begin and end of 0 because there are relocations
6491 that need to be applied to the addresses. Actually applying
6492 the relocations now does not help as they will probably resolve
6493 to 0, since the object file has not been fully linked. Real
6494 end of list markers will not have any relocations against them. */
6495 if (! reloc_at (section
, off
)
6496 && ! reloc_at (section
, off
+ pointer_size
))
6498 printf (_("<End of list>\n"));
6503 /* Check base address specifiers. */
6504 if (is_max_address (begin
, pointer_size
)
6505 && !is_max_address (end
, pointer_size
))
6508 print_dwarf_vma (begin
, pointer_size
);
6509 print_dwarf_vma (end
, pointer_size
);
6510 printf (_("(base address)\n"));
6516 off
= offset
+ (vstart
- *start_ptr
);
6518 READ_ULEB (vbegin
, vstart
, section_end
);
6519 print_dwarf_view (vbegin
, pointer_size
, 1);
6521 READ_ULEB (vend
, vstart
, section_end
);
6522 print_dwarf_view (vend
, pointer_size
, 1);
6524 printf (_("views at %8.8lx for:\n %*s "),
6525 (unsigned long) off
, 8, "");
6528 if (start
+ 2 > section_end
)
6530 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6531 (unsigned long) offset
);
6535 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6537 if (start
+ length
> section_end
)
6539 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6540 (unsigned long) offset
);
6544 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6545 print_dwarf_vma (end
+ base_address
, pointer_size
);
6548 need_frame_base
= decode_location_expression (start
,
6553 cu_offset
, section
);
6556 if (need_frame_base
&& !has_frame_base
)
6557 printf (_(" [without DW_AT_frame_base]"));
6559 if (begin
== end
&& vbegin
== vend
)
6560 fputs (_(" (start == end)"), stdout
);
6561 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6562 fputs (_(" (start > end)"), stdout
);
6570 *vstart_ptr
= vstart
;
6573 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6576 display_loclists_list (struct dwarf_section
*section
,
6577 unsigned char **start_ptr
,
6578 unsigned int debug_info_entry
,
6580 dwarf_vma base_address
,
6581 unsigned char **vstart_ptr
,
6584 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6585 unsigned char *section_end
= section
->start
+ section
->size
;
6586 unsigned long cu_offset
;
6587 unsigned int pointer_size
;
6588 unsigned int offset_size
;
6591 /* Initialize it due to a false compiler warning. */
6592 dwarf_vma begin
= -1, vbegin
= -1;
6593 dwarf_vma end
= -1, vend
= -1;
6595 int need_frame_base
;
6597 if (debug_info_entry
>= num_debug_info_entries
)
6599 warn (_("No debug information available for "
6600 "loclists lists of entry: %u\n"),
6605 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6606 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6607 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6608 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6610 if (pointer_size
< 2 || pointer_size
> 8)
6612 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6613 pointer_size
, debug_info_entry
);
6619 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6620 enum dwarf_location_list_entry_type llet
;
6622 if (start
+ 1 > section_end
)
6624 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6625 (unsigned long) offset
);
6629 printf (" %8.8lx ", (unsigned long) off
);
6631 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6633 if (vstart
&& (llet
== DW_LLE_offset_pair
6634 || llet
== DW_LLE_start_end
6635 || llet
== DW_LLE_start_length
))
6637 off
= offset
+ (vstart
- *start_ptr
);
6639 READ_ULEB (vbegin
, vstart
, section_end
);
6640 print_dwarf_view (vbegin
, pointer_size
, 1);
6642 READ_ULEB (vend
, vstart
, section_end
);
6643 print_dwarf_view (vend
, pointer_size
, 1);
6645 printf (_("views at %8.8lx for:\n %*s "),
6646 (unsigned long) off
, 8, "");
6651 case DW_LLE_end_of_list
:
6652 printf (_("<End of list>\n"));
6654 case DW_LLE_offset_pair
:
6655 READ_ULEB (begin
, start
, section_end
);
6656 begin
+= base_address
;
6657 READ_ULEB (end
, start
, section_end
);
6658 end
+= base_address
;
6660 case DW_LLE_start_end
:
6661 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6662 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6664 case DW_LLE_start_length
:
6665 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6666 READ_ULEB (end
, start
, section_end
);
6669 case DW_LLE_base_address
:
6670 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6672 print_dwarf_vma (base_address
, pointer_size
);
6673 printf (_("(base address)\n"));
6675 #ifdef DW_LLE_view_pair
6676 case DW_LLE_view_pair
:
6678 printf (_("View pair entry in loclist with locviews attribute\n"));
6679 READ_ULEB (vbegin
, start
, section_end
);
6680 print_dwarf_view (vbegin
, pointer_size
, 1);
6682 READ_ULEB (vend
, start
, section_end
);
6683 print_dwarf_view (vend
, pointer_size
, 1);
6685 printf (_("views for:\n"));
6689 error (_("Invalid location list entry type %d\n"), llet
);
6692 if (llet
== DW_LLE_end_of_list
)
6694 if (llet
!= DW_LLE_offset_pair
6695 && llet
!= DW_LLE_start_end
6696 && llet
!= DW_LLE_start_length
)
6699 if (start
+ 2 > section_end
)
6701 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6702 (unsigned long) offset
);
6706 READ_ULEB (length
, start
, section_end
);
6708 print_dwarf_vma (begin
, pointer_size
);
6709 print_dwarf_vma (end
, pointer_size
);
6712 need_frame_base
= decode_location_expression (start
,
6717 cu_offset
, section
);
6720 if (need_frame_base
&& !has_frame_base
)
6721 printf (_(" [without DW_AT_frame_base]"));
6723 if (begin
== end
&& vbegin
== vend
)
6724 fputs (_(" (start == end)"), stdout
);
6725 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6726 fputs (_(" (start > end)"), stdout
);
6734 if (vbegin
!= vm1
|| vend
!= vm1
)
6735 printf (_("Trailing view pair not used in a range"));
6738 *vstart_ptr
= vstart
;
6741 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6742 right-adjusted in a field of length LEN, and followed by a space. */
6745 print_addr_index (unsigned int idx
, unsigned int len
)
6747 static char buf
[15];
6748 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6749 printf ("%*s ", len
, buf
);
6752 /* Display a location list from a .dwo section. It uses address indexes rather
6753 than embedded addresses. This code closely follows display_loc_list, but the
6754 two are sufficiently different that combining things is very ugly. */
6757 display_loc_list_dwo (struct dwarf_section
*section
,
6758 unsigned char **start_ptr
,
6759 unsigned int debug_info_entry
,
6761 unsigned char **vstart_ptr
,
6764 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6765 unsigned char *section_end
= section
->start
+ section
->size
;
6766 unsigned long cu_offset
;
6767 unsigned int pointer_size
;
6768 unsigned int offset_size
;
6771 unsigned short length
;
6772 int need_frame_base
;
6775 if (debug_info_entry
>= num_debug_info_entries
)
6777 warn (_("No debug information for loc lists of entry: %u\n"),
6782 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6783 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6784 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6785 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6787 if (pointer_size
< 2 || pointer_size
> 8)
6789 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6790 pointer_size
, debug_info_entry
);
6796 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6798 if (start
>= section_end
)
6800 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6801 (unsigned long) offset
);
6805 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6818 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6820 READ_ULEB (view
, vstart
, section_end
);
6821 print_dwarf_view (view
, 8, 1);
6823 READ_ULEB (view
, vstart
, section_end
);
6824 print_dwarf_view (view
, 8, 1);
6826 printf (_("views at %8.8lx for:\n %*s "),
6827 (unsigned long) off
, 8, "");
6835 case 0: /* A terminating entry. */
6837 *vstart_ptr
= vstart
;
6838 printf (_("<End of list>\n"));
6840 case 1: /* A base-address entry. */
6841 READ_ULEB (idx
, start
, section_end
);
6842 print_addr_index (idx
, 8);
6843 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6844 printf (_("(base address selection entry)\n"));
6846 case 2: /* A start/end entry. */
6847 READ_ULEB (idx
, start
, section_end
);
6848 print_addr_index (idx
, 8);
6849 READ_ULEB (idx
, start
, section_end
);
6850 print_addr_index (idx
, 8);
6852 case 3: /* A start/length entry. */
6853 READ_ULEB (idx
, start
, section_end
);
6854 print_addr_index (idx
, 8);
6855 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6856 printf ("%08x ", idx
);
6858 case 4: /* An offset pair entry. */
6859 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6860 printf ("%08x ", idx
);
6861 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6862 printf ("%08x ", idx
);
6865 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6867 *vstart_ptr
= vstart
;
6871 if (start
+ 2 > section_end
)
6873 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6874 (unsigned long) offset
);
6878 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6879 if (start
+ length
> section_end
)
6881 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6882 (unsigned long) offset
);
6887 need_frame_base
= decode_location_expression (start
,
6892 cu_offset
, section
);
6895 if (need_frame_base
&& !has_frame_base
)
6896 printf (_(" [without DW_AT_frame_base]"));
6904 *vstart_ptr
= vstart
;
6907 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6910 static dwarf_vma
*loc_offsets
, *loc_views
;
6913 loc_offsets_compar (const void *ap
, const void *bp
)
6915 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6916 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6918 int ret
= (a
> b
) - (b
> a
);
6922 a
= loc_views
[*(const unsigned int *) ap
];
6923 b
= loc_views
[*(const unsigned int *) bp
];
6925 ret
= (a
> b
) - (b
> a
);
6931 display_debug_loc (struct dwarf_section
*section
, void *file
)
6933 unsigned char *start
= section
->start
, *vstart
= NULL
;
6934 unsigned long bytes
;
6935 unsigned char *section_begin
= start
;
6936 unsigned int num_loc_list
= 0;
6937 unsigned long last_offset
= 0;
6938 unsigned long last_view
= 0;
6939 unsigned int first
= 0;
6942 int seen_first_offset
= 0;
6943 int locs_sorted
= 1;
6944 unsigned char *next
= start
, *vnext
= vstart
;
6945 unsigned int *array
= NULL
;
6946 const char *suffix
= strrchr (section
->name
, '.');
6947 bfd_boolean is_dwo
= FALSE
;
6948 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6949 dwarf_vma expected_start
= 0;
6951 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6954 bytes
= section
->size
;
6958 printf (_("\nThe %s section is empty.\n"), section
->name
);
6964 unsigned char *hdrptr
= section_begin
;
6965 dwarf_vma ll_length
;
6966 unsigned short ll_version
;
6967 unsigned char *end
= section_begin
+ section
->size
;
6968 unsigned char address_size
, segment_selector_size
;
6969 uint32_t offset_entry_count
;
6971 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6972 if (ll_length
== 0xffffffff)
6973 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6975 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6976 if (ll_version
!= 5)
6978 warn (_("The %s section contains corrupt or "
6979 "unsupported version number: %d.\n"),
6980 section
->name
, ll_version
);
6984 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6986 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6987 if (segment_selector_size
!= 0)
6989 warn (_("The %s section contains "
6990 "unsupported segment selector size: %d.\n"),
6991 section
->name
, segment_selector_size
);
6995 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6996 if (offset_entry_count
!= 0)
6998 warn (_("The %s section contains "
6999 "unsupported offset entry count: %d.\n"),
7000 section
->name
, offset_entry_count
);
7004 expected_start
= hdrptr
- section_begin
;
7007 if (load_debug_info (file
) == 0)
7009 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7014 /* Check the order of location list in .debug_info section. If
7015 offsets of location lists are in the ascending order, we can
7016 use `debug_information' directly. */
7017 for (i
= 0; i
< num_debug_info_entries
; i
++)
7021 num
= debug_information
[i
].num_loc_offsets
;
7022 if (num
> num_loc_list
)
7025 /* Check if we can use `debug_information' directly. */
7026 if (locs_sorted
&& num
!= 0)
7028 if (!seen_first_offset
)
7030 /* This is the first location list. */
7031 last_offset
= debug_information
[i
].loc_offsets
[0];
7032 last_view
= debug_information
[i
].loc_views
[0];
7034 seen_first_offset
= 1;
7040 for (; j
< num
; j
++)
7043 debug_information
[i
].loc_offsets
[j
]
7044 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
7045 && last_view
> debug_information
[i
].loc_views
[j
]))
7050 last_offset
= debug_information
[i
].loc_offsets
[j
];
7051 last_view
= debug_information
[i
].loc_views
[j
];
7056 if (!seen_first_offset
)
7057 error (_("No location lists in .debug_info section!\n"));
7059 if (debug_information
[first
].num_loc_offsets
> 0
7060 && debug_information
[first
].loc_offsets
[0] != expected_start
7061 && debug_information
[first
].loc_views
[0] != expected_start
)
7062 warn (_("Location lists in %s section start at 0x%s\n"),
7064 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
7067 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
7069 introduce (section
, FALSE
);
7071 if (reloc_at (section
, 0))
7072 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
7074 printf (_(" Offset Begin End Expression\n"));
7076 seen_first_offset
= 0;
7077 for (i
= first
; i
< num_debug_info_entries
; i
++)
7079 dwarf_vma offset
, voffset
;
7080 dwarf_vma base_address
;
7086 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
7088 loc_offsets
= debug_information
[i
].loc_offsets
;
7089 loc_views
= debug_information
[i
].loc_views
;
7090 qsort (array
, debug_information
[i
].num_loc_offsets
,
7091 sizeof (*array
), loc_offsets_compar
);
7094 int adjacent_view_loclists
= 1;
7095 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
7097 j
= locs_sorted
? k
: array
[k
];
7099 && (debug_information
[i
].loc_offsets
[locs_sorted
7100 ? k
- 1 : array
[k
- 1]]
7101 == debug_information
[i
].loc_offsets
[j
])
7102 && (debug_information
[i
].loc_views
[locs_sorted
7103 ? k
- 1 : array
[k
- 1]]
7104 == debug_information
[i
].loc_views
[j
]))
7106 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
7107 offset
= debug_information
[i
].loc_offsets
[j
];
7108 next
= section_begin
+ offset
;
7109 voffset
= debug_information
[i
].loc_views
[j
];
7111 vnext
= section_begin
+ voffset
;
7114 base_address
= debug_information
[i
].base_address
;
7116 if (vnext
&& vnext
< next
)
7119 display_view_pair_list (section
, &vstart
, i
, next
);
7124 if (!seen_first_offset
|| !adjacent_view_loclists
)
7125 seen_first_offset
= 1;
7129 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
7130 (unsigned long) (start
- section_begin
),
7131 (unsigned long) offset
);
7132 else if (start
> next
)
7133 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
7134 (unsigned long) (start
- section_begin
),
7135 (unsigned long) offset
);
7140 if (offset
>= bytes
)
7142 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
7143 (unsigned long) offset
);
7147 if (vnext
&& voffset
>= bytes
)
7149 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
7150 (unsigned long) voffset
);
7157 display_loc_list_dwo (section
, &start
, i
, offset
,
7158 &vstart
, has_frame_base
);
7160 display_loc_list (section
, &start
, i
, offset
, base_address
,
7161 &vstart
, has_frame_base
);
7166 warn (_("DWO is not yet supported.\n"));
7168 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7169 &vstart
, has_frame_base
);
7172 /* FIXME: this arrangement is quite simplistic. Nothing
7173 requires locview lists to be adjacent to corresponding
7174 loclists, and a single loclist could be augmented by
7175 different locview lists, and vice-versa, unlikely as it
7176 is that it would make sense to do so. Hopefully we'll
7177 have view pair support built into loclists before we ever
7178 need to address all these possibilities. */
7179 if (adjacent_view_loclists
&& vnext
7180 && vnext
!= start
&& vstart
!= next
)
7182 adjacent_view_loclists
= 0;
7183 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7186 if (vnext
&& vnext
== start
)
7187 display_view_pair_list (section
, &start
, i
, vstart
);
7191 if (start
< section
->start
+ section
->size
)
7192 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7193 "There are %ld unused bytes at the end of section %s\n",
7194 (long) (section
->start
+ section
->size
- start
)),
7195 (long) (section
->start
+ section
->size
- start
), section
->name
);
7202 display_debug_str (struct dwarf_section
*section
,
7203 void *file ATTRIBUTE_UNUSED
)
7205 unsigned char *start
= section
->start
;
7206 unsigned long bytes
= section
->size
;
7207 dwarf_vma addr
= section
->address
;
7211 printf (_("\nThe %s section is empty.\n"), section
->name
);
7215 introduce (section
, FALSE
);
7223 lbytes
= (bytes
> 16 ? 16 : bytes
);
7225 printf (" 0x%8.8lx ", (unsigned long) addr
);
7227 for (j
= 0; j
< 16; j
++)
7230 printf ("%2.2x", start
[j
]);
7238 for (j
= 0; j
< lbytes
; j
++)
7241 if (k
>= ' ' && k
< 0x80)
7260 display_debug_info (struct dwarf_section
*section
, void *file
)
7262 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
7266 display_debug_types (struct dwarf_section
*section
, void *file
)
7268 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
7272 display_trace_info (struct dwarf_section
*section
, void *file
)
7274 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
7278 display_debug_aranges (struct dwarf_section
*section
,
7279 void *file ATTRIBUTE_UNUSED
)
7281 unsigned char *start
= section
->start
;
7282 unsigned char *end
= start
+ section
->size
;
7284 introduce (section
, FALSE
);
7286 /* It does not matter if this load fails,
7287 we test for that later on. */
7288 load_debug_info (file
);
7292 unsigned char *hdrptr
;
7293 DWARF2_Internal_ARange arange
;
7294 unsigned char *addr_ranges
;
7297 unsigned long sec_off
;
7298 unsigned char address_size
;
7300 unsigned int offset_size
;
7301 unsigned int initial_length_size
;
7305 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7306 if (arange
.ar_length
== 0xffffffff)
7308 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7310 initial_length_size
= 12;
7315 initial_length_size
= 4;
7318 sec_off
= hdrptr
- section
->start
;
7319 if (sec_off
+ arange
.ar_length
< sec_off
7320 || sec_off
+ arange
.ar_length
> section
->size
)
7322 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7324 sec_off
- initial_length_size
,
7325 dwarf_vmatoa ("x", arange
.ar_length
));
7329 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
7330 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
7332 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7333 && num_debug_info_entries
> 0
7334 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7335 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7336 (unsigned long) arange
.ar_info_offset
, section
->name
);
7338 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
7339 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
7341 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7343 /* PR 19872: A version number of 0 probably means that there is
7344 padding at the end of the .debug_aranges section. Gold puts
7345 it there when performing an incremental link, for example.
7346 So do not generate a warning in this case. */
7347 if (arange
.ar_version
)
7348 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7352 printf (_(" Length: %ld\n"),
7353 (long) arange
.ar_length
);
7354 printf (_(" Version: %d\n"), arange
.ar_version
);
7355 printf (_(" Offset into .debug_info: 0x%lx\n"),
7356 (unsigned long) arange
.ar_info_offset
);
7357 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7358 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7360 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7362 /* PR 17512: file: 001-108546-0.001:0.1. */
7363 if (address_size
== 0 || address_size
> 8)
7365 error (_("Invalid address size in %s section!\n"),
7370 /* The DWARF spec does not require that the address size be a power
7371 of two, but we do. This will have to change if we ever encounter
7372 an uneven architecture. */
7373 if ((address_size
& (address_size
- 1)) != 0)
7375 warn (_("Pointer size + Segment size is not a power of two.\n"));
7379 if (address_size
> 4)
7380 printf (_("\n Address Length\n"));
7382 printf (_("\n Address Length\n"));
7384 addr_ranges
= hdrptr
;
7386 /* Must pad to an alignment boundary that is twice the address size. */
7387 excess
= (hdrptr
- start
) % (2 * address_size
);
7389 addr_ranges
+= (2 * address_size
) - excess
;
7391 start
+= arange
.ar_length
+ initial_length_size
;
7393 while (addr_ranges
+ 2 * address_size
<= start
)
7395 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
7396 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
7399 print_dwarf_vma (address
, address_size
);
7400 print_dwarf_vma (length
, address_size
);
7410 /* Comparison function for qsort. */
7412 comp_addr_base (const void * v0
, const void * v1
)
7414 debug_info
*info0
= *(debug_info
**) v0
;
7415 debug_info
*info1
= *(debug_info
**) v1
;
7416 return info0
->addr_base
- info1
->addr_base
;
7419 /* Display the debug_addr section. */
7421 display_debug_addr (struct dwarf_section
*section
,
7424 debug_info
**debug_addr_info
;
7425 unsigned char *entry
;
7429 unsigned char * header
;
7431 if (section
->size
== 0)
7433 printf (_("\nThe %s section is empty.\n"), section
->name
);
7437 if (load_debug_info (file
) == 0)
7439 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7444 introduce (section
, FALSE
);
7446 /* PR 17531: file: cf38d01b.
7447 We use xcalloc because a corrupt file may not have initialised all of the
7448 fields in the debug_info structure, which means that the sort below might
7449 try to move uninitialised data. */
7450 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7451 sizeof (debug_info
*));
7454 for (i
= 0; i
< num_debug_info_entries
; i
++)
7455 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7457 /* PR 17531: file: cf38d01b. */
7458 if (debug_information
[i
].addr_base
>= section
->size
)
7459 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7460 (unsigned long) debug_information
[i
].addr_base
, i
);
7462 debug_addr_info
[count
++] = debug_information
+ i
;
7465 /* Add a sentinel to make iteration convenient. */
7466 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7467 debug_addr_info
[count
]->addr_base
= section
->size
;
7468 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7470 header
= section
->start
;
7471 for (i
= 0; i
< count
; i
++)
7474 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7476 printf (_(" For compilation unit at offset 0x%s:\n"),
7477 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7479 printf (_("\tIndex\tAddress\n"));
7480 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7481 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7483 size_t header_size
= entry
- header
;
7484 unsigned char * curr_header
= header
;
7487 int segment_selector_size
;
7489 if (header_size
!= 8 && header_size
!= 16)
7491 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %ld instead\n"),
7492 section
->name
, (long) header_size
);
7496 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7497 if (length
== 0xffffffff)
7498 SAFE_BYTE_GET (length
, curr_header
, 8, entry
);
7499 end
= curr_header
+ length
;
7501 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7503 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7504 section
->name
, version
);
7506 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7507 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7508 address_size
+= segment_selector_size
;
7511 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7516 dwarf_vma base
= byte_get (entry
, address_size
);
7517 printf (_("\t%d:\t"), idx
);
7518 print_dwarf_vma (base
, address_size
);
7520 entry
+= address_size
;
7526 free (debug_addr_info
);
7530 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7533 display_debug_str_offsets (struct dwarf_section
*section
,
7534 void *file ATTRIBUTE_UNUSED
)
7538 if (section
->size
== 0)
7540 printf (_("\nThe %s section is empty.\n"), section
->name
);
7544 unsigned char *start
= section
->start
;
7545 unsigned char *end
= start
+ section
->size
;
7546 unsigned char *curr
= start
;
7548 const char *suffix
= strrchr (section
->name
, '.');
7549 bfd_boolean dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7552 load_debug_section_with_follow (str_dwo
, file
);
7554 load_debug_section_with_follow (str
, file
);
7556 introduce (section
, FALSE
);
7561 dwarf_vma entry_length
;
7563 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7564 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7565 if (length
== 0xffffffff)
7567 SAFE_BYTE_GET (length
, curr
, 8, end
);
7573 unsigned char *entries_end
;
7576 /* This is probably an old style .debug_str_offset section which
7577 just contains offsets and no header (and the first offset is 0). */
7578 length
= section
->size
;
7579 curr
= section
->start
;
7582 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7583 printf (_(" Index Offset [String]\n"));
7587 entries_end
= curr
+ length
;
7590 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
7592 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7595 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
7597 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7599 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7600 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7601 printf (_(" Index Offset [String]\n"));
7604 for (idx
= 0; curr
< entries_end
; idx
++)
7607 const unsigned char * string
;
7609 if (curr
+ entry_length
> entries_end
)
7610 /* Not enough space to read one entry_length, give up. */
7613 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, end
);
7615 string
= (const unsigned char *)
7616 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7618 string
= fetch_indirect_string (offset
);
7620 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7628 /* Each debug_information[x].range_lists[y] gets this representation for
7629 sorting purposes. */
7633 /* The debug_information[x].range_lists[y] value. */
7634 dwarf_vma ranges_offset
;
7636 /* Original debug_information to find parameters of the data. */
7637 debug_info
*debug_info_p
;
7640 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7643 range_entry_compar (const void *ap
, const void *bp
)
7645 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7646 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7647 const dwarf_vma a
= a_re
->ranges_offset
;
7648 const dwarf_vma b
= b_re
->ranges_offset
;
7650 return (a
> b
) - (b
> a
);
7654 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7655 unsigned int pointer_size
, unsigned long offset
,
7656 unsigned long base_address
)
7658 while (start
< finish
)
7663 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7664 if (start
>= finish
)
7666 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7668 printf (" %8.8lx ", offset
);
7670 if (begin
== 0 && end
== 0)
7672 printf (_("<End of list>\n"));
7676 /* Check base address specifiers. */
7677 if (is_max_address (begin
, pointer_size
)
7678 && !is_max_address (end
, pointer_size
))
7681 print_dwarf_vma (begin
, pointer_size
);
7682 print_dwarf_vma (end
, pointer_size
);
7683 printf ("(base address)\n");
7687 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7688 print_dwarf_vma (end
+ base_address
, pointer_size
);
7691 fputs (_("(start == end)"), stdout
);
7692 else if (begin
> end
)
7693 fputs (_("(start > end)"), stdout
);
7700 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7701 unsigned int pointer_size
, unsigned long offset
,
7702 unsigned long base_address
)
7704 unsigned char *next
= start
;
7708 unsigned long off
= offset
+ (start
- next
);
7709 enum dwarf_range_list_entry rlet
;
7710 /* Initialize it due to a false compiler warning. */
7711 dwarf_vma begin
= -1, length
, end
= -1;
7713 if (start
+ 1 > finish
)
7715 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7720 printf (" %8.8lx ", off
);
7722 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7726 case DW_RLE_end_of_list
:
7727 printf (_("<End of list>\n"));
7729 case DW_RLE_base_address
:
7730 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7731 print_dwarf_vma (base_address
, pointer_size
);
7732 printf (_("(base address)\n"));
7734 case DW_RLE_start_length
:
7735 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7736 READ_ULEB (length
, start
, finish
);
7737 end
= begin
+ length
;
7739 case DW_RLE_offset_pair
:
7740 READ_ULEB (begin
, start
, finish
);
7741 READ_ULEB (end
, start
, finish
);
7743 case DW_RLE_start_end
:
7744 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7745 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7748 error (_("Invalid range list entry type %d\n"), rlet
);
7749 rlet
= DW_RLE_end_of_list
;
7752 if (rlet
== DW_RLE_end_of_list
)
7754 if (rlet
== DW_RLE_base_address
)
7757 /* Only a DW_RLE_offset_pair needs the base address added. */
7758 if (rlet
== DW_RLE_offset_pair
)
7760 begin
+= base_address
;
7761 end
+= base_address
;
7764 print_dwarf_vma (begin
, pointer_size
);
7765 print_dwarf_vma (end
, pointer_size
);
7768 fputs (_("(start == end)"), stdout
);
7769 else if (begin
> end
)
7770 fputs (_("(start > end)"), stdout
);
7777 display_debug_ranges (struct dwarf_section
*section
,
7778 void *file ATTRIBUTE_UNUSED
)
7780 unsigned char *start
= section
->start
;
7781 unsigned char *last_start
= start
;
7782 unsigned long bytes
= section
->size
;
7783 unsigned char *section_begin
= start
;
7784 unsigned char *finish
= start
+ bytes
;
7785 unsigned int num_range_list
, i
;
7786 struct range_entry
*range_entries
, *range_entry_fill
;
7787 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7788 /* Initialize it due to a false compiler warning. */
7789 unsigned char address_size
= 0;
7790 dwarf_vma last_offset
= 0;
7794 printf (_("\nThe %s section is empty.\n"), section
->name
);
7800 dwarf_vma initial_length
;
7801 unsigned int initial_length_size
;
7802 unsigned char segment_selector_size
;
7803 unsigned int offset_size
, offset_entry_count
;
7804 unsigned short version
;
7806 /* Get and check the length of the block. */
7807 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7809 if (initial_length
== 0xffffffff)
7811 /* This section is 64-bit DWARF 3. */
7812 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7814 initial_length_size
= 12;
7819 initial_length_size
= 4;
7822 if (initial_length
+ initial_length_size
> section
->size
)
7824 /* If the length field has a relocation against it, then we should
7825 not complain if it is inaccurate (and probably negative).
7826 It is copied from .debug_line handling code. */
7827 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7829 initial_length
= (finish
- start
) - initial_length_size
;
7833 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7834 (long) initial_length
);
7839 /* Get and check the version number. */
7840 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7844 warn (_("Only DWARF version 5 debug_rnglists info "
7845 "is currently supported.\n"));
7849 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7851 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7852 if (segment_selector_size
!= 0)
7854 warn (_("The %s section contains "
7855 "unsupported segment selector size: %d.\n"),
7856 section
->name
, segment_selector_size
);
7860 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7861 if (offset_entry_count
!= 0)
7863 warn (_("The %s section contains "
7864 "unsupported offset entry count: %u.\n"),
7865 section
->name
, offset_entry_count
);
7870 if (load_debug_info (file
) == 0)
7872 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7878 for (i
= 0; i
< num_debug_info_entries
; i
++)
7880 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7881 /* Skip .debug_rnglists reference. */
7883 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7884 /* Skip .debug_range reference. */
7886 num_range_list
+= debug_information
[i
].num_range_lists
;
7889 if (num_range_list
== 0)
7891 /* This can happen when the file was compiled with -gsplit-debug
7892 which removes references to range lists from the primary .o file. */
7893 printf (_("No range lists in .debug_info section.\n"));
7897 range_entries
= (struct range_entry
*)
7898 xmalloc (sizeof (*range_entries
) * num_range_list
);
7899 range_entry_fill
= range_entries
;
7901 for (i
= 0; i
< num_debug_info_entries
; i
++)
7903 debug_info
*debug_info_p
= &debug_information
[i
];
7906 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7907 /* Skip .debug_rnglists reference. */
7909 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7910 /* Skip .debug_range reference. */
7913 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7915 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7916 range_entry_fill
->debug_info_p
= debug_info_p
;
7921 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7922 range_entry_compar
);
7924 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7925 warn (_("Range lists in %s section start at 0x%lx\n"),
7926 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7928 introduce (section
, FALSE
);
7930 printf (_(" Offset Begin End\n"));
7932 for (i
= 0; i
< num_range_list
; i
++)
7934 struct range_entry
*range_entry
= &range_entries
[i
];
7935 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7936 unsigned int pointer_size
;
7938 unsigned char *next
;
7939 dwarf_vma base_address
;
7941 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7942 offset
= range_entry
->ranges_offset
;
7943 next
= section_begin
+ offset
;
7944 base_address
= debug_info_p
->base_address
;
7946 /* PR 17512: file: 001-101485-0.001:0.1. */
7947 if (pointer_size
< 2 || pointer_size
> 8)
7949 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7950 pointer_size
, (unsigned long) offset
);
7954 if (next
< section_begin
|| next
>= finish
)
7956 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7957 (unsigned long) offset
, i
);
7961 /* If multiple DWARF entities reference the same range then we will
7962 have multiple entries in the `range_entries' list for the same
7963 offset. Thanks to the sort above these will all be consecutive in
7964 the `range_entries' list, so we can easily ignore duplicates
7966 if (i
> 0 && last_offset
== offset
)
7968 last_offset
= offset
;
7970 if (dwarf_check
!= 0 && i
> 0)
7973 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7974 (unsigned long) (start
- section_begin
),
7975 (unsigned long) (next
- section_begin
), section
->name
);
7976 else if (start
> next
)
7978 if (next
== last_start
)
7980 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7981 (unsigned long) (start
- section_begin
),
7982 (unsigned long) (next
- section_begin
), section
->name
);
7989 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7990 (start
, finish
, pointer_size
, offset
, base_address
);
7994 free (range_entries
);
7999 typedef struct Frame_Chunk
8001 struct Frame_Chunk
*next
;
8002 unsigned char *chunk_start
;
8004 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8005 short int *col_type
;
8008 unsigned int code_factor
;
8012 unsigned int cfa_reg
;
8013 dwarf_vma cfa_offset
;
8015 unsigned char fde_encoding
;
8016 unsigned char cfa_exp
;
8017 unsigned char ptr_size
;
8018 unsigned char segment_size
;
8022 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
8023 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
8024 static const char *const *dwarf_regnames
;
8025 static unsigned int dwarf_regnames_count
;
8028 /* A marker for a col_type that means this column was never referenced
8029 in the frame info. */
8030 #define DW_CFA_unreferenced (-1)
8032 /* Return 0 if no more space is needed, 1 if more space is needed,
8033 -1 for invalid reg. */
8036 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
8038 unsigned int prev
= fc
->ncols
;
8040 if (reg
< (unsigned int) fc
->ncols
)
8043 if (dwarf_regnames_count
> 0
8044 && reg
> dwarf_regnames_count
)
8047 fc
->ncols
= reg
+ 1;
8048 /* PR 17512: file: 10450-2643-0.004.
8049 If reg == -1 then this can happen... */
8053 /* PR 17512: file: 2844a11d. */
8054 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
8056 error (_("Unfeasibly large register number: %u\n"), reg
);
8058 /* FIXME: 1024 is an arbitrary limit. Increase it if
8059 we ever encounter a valid binary that exceeds it. */
8063 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
8064 sizeof (short int));
8065 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
8066 /* PR 17512: file:002-10025-0.005. */
8067 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
8069 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
8075 while (prev
< fc
->ncols
)
8077 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8078 fc
->col_offset
[prev
] = 0;
8084 static const char *const dwarf_regnames_i386
[] =
8086 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8087 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8088 "eip", "eflags", NULL
, /* 8 - 10 */
8089 "st0", "st1", "st2", "st3", /* 11 - 14 */
8090 "st4", "st5", "st6", "st7", /* 15 - 18 */
8091 NULL
, NULL
, /* 19 - 20 */
8092 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
8093 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
8094 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
8095 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
8096 "fcw", "fsw", "mxcsr", /* 37 - 39 */
8097 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8098 "tr", "ldtr", /* 48 - 49 */
8099 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8100 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8101 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8102 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8103 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8104 NULL
, NULL
, NULL
, /* 90 - 92 */
8105 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8108 static const char *const dwarf_regnames_iamcu
[] =
8110 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8111 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8112 "eip", "eflags", NULL
, /* 8 - 10 */
8113 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8114 NULL
, NULL
, /* 19 - 20 */
8115 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8116 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8117 NULL
, NULL
, NULL
, /* 37 - 39 */
8118 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8119 "tr", "ldtr", /* 48 - 49 */
8120 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8121 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8122 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8123 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8124 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8125 NULL
, NULL
, NULL
, /* 90 - 92 */
8126 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8130 init_dwarf_regnames_i386 (void)
8132 dwarf_regnames
= dwarf_regnames_i386
;
8133 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8134 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8138 init_dwarf_regnames_iamcu (void)
8140 dwarf_regnames
= dwarf_regnames_iamcu
;
8141 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8142 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8145 static const char *const dwarf_regnames_x86_64
[] =
8147 "rax", "rdx", "rcx", "rbx",
8148 "rsi", "rdi", "rbp", "rsp",
8149 "r8", "r9", "r10", "r11",
8150 "r12", "r13", "r14", "r15",
8152 "xmm0", "xmm1", "xmm2", "xmm3",
8153 "xmm4", "xmm5", "xmm6", "xmm7",
8154 "xmm8", "xmm9", "xmm10", "xmm11",
8155 "xmm12", "xmm13", "xmm14", "xmm15",
8156 "st0", "st1", "st2", "st3",
8157 "st4", "st5", "st6", "st7",
8158 "mm0", "mm1", "mm2", "mm3",
8159 "mm4", "mm5", "mm6", "mm7",
8161 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8162 "fs.base", "gs.base", NULL
, NULL
,
8164 "mxcsr", "fcw", "fsw",
8165 "xmm16", "xmm17", "xmm18", "xmm19",
8166 "xmm20", "xmm21", "xmm22", "xmm23",
8167 "xmm24", "xmm25", "xmm26", "xmm27",
8168 "xmm28", "xmm29", "xmm30", "xmm31",
8169 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8170 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8171 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8172 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8173 NULL
, NULL
, NULL
, /* 115 - 117 */
8174 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8178 init_dwarf_regnames_x86_64 (void)
8180 dwarf_regnames
= dwarf_regnames_x86_64
;
8181 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8182 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8185 static const char *const dwarf_regnames_aarch64
[] =
8187 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8188 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8189 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8190 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8191 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8192 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8193 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8194 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8195 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8196 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8197 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8198 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8199 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8200 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8201 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8202 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8206 init_dwarf_regnames_aarch64 (void)
8208 dwarf_regnames
= dwarf_regnames_aarch64
;
8209 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8210 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8213 static const char *const dwarf_regnames_s390
[] =
8215 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8216 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8217 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8218 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8219 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8220 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8221 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8222 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8223 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8226 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8227 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8231 init_dwarf_regnames_s390 (void)
8233 dwarf_regnames
= dwarf_regnames_s390
;
8234 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8235 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8238 static const char *const dwarf_regnames_riscv
[] =
8240 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8241 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8242 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8243 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8244 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8245 "fs0", "fs1", /* 40 - 41 */
8246 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8247 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8248 "fs10", "fs11", /* 58 - 59 */
8249 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8252 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8253 the large number of CSRs. */
8256 regname_internal_riscv (unsigned int regno
)
8258 const char *name
= NULL
;
8260 /* Lookup in the table first, this covers GPR and FPR. */
8261 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8262 name
= dwarf_regnames_riscv
[regno
];
8263 else if (regno
>= 4096 && regno
<= 8191)
8265 /* This might be a CSR, these live in a sparse number space from 4096
8266 to 8191 These numbers are defined in the RISC-V ELF ABI
8270 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8271 case VALUE + 4096: name = #NAME; break;
8272 #include "opcode/riscv-opc.h"
8277 static char csr_name
[10];
8278 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8289 init_dwarf_regnames_riscv (void)
8291 dwarf_regnames
= NULL
;
8292 dwarf_regnames_count
= 8192;
8293 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8297 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8299 dwarf_regnames_lookup_func
= NULL
;
8304 init_dwarf_regnames_i386 ();
8308 init_dwarf_regnames_iamcu ();
8314 init_dwarf_regnames_x86_64 ();
8318 init_dwarf_regnames_aarch64 ();
8322 init_dwarf_regnames_s390 ();
8326 init_dwarf_regnames_riscv ();
8334 /* Initialize the DWARF register name lookup state based on the
8335 architecture and specific machine type of a BFD. */
8338 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8341 dwarf_regnames_lookup_func
= NULL
;
8348 case bfd_mach_x86_64
:
8349 case bfd_mach_x86_64_intel_syntax
:
8350 case bfd_mach_x64_32
:
8351 case bfd_mach_x64_32_intel_syntax
:
8352 init_dwarf_regnames_x86_64 ();
8356 init_dwarf_regnames_i386 ();
8361 case bfd_arch_iamcu
:
8362 init_dwarf_regnames_iamcu ();
8365 case bfd_arch_aarch64
:
8366 init_dwarf_regnames_aarch64();
8370 init_dwarf_regnames_s390 ();
8373 case bfd_arch_riscv
:
8374 init_dwarf_regnames_riscv ();
8383 regname_internal_by_table_only (unsigned int regno
)
8385 if (dwarf_regnames
!= NULL
8386 && regno
< dwarf_regnames_count
8387 && dwarf_regnames
[regno
] != NULL
)
8388 return dwarf_regnames
[regno
];
8394 regname (unsigned int regno
, int name_only_p
)
8396 static char reg
[64];
8398 const char *name
= NULL
;
8400 if (dwarf_regnames_lookup_func
!= NULL
)
8401 name
= dwarf_regnames_lookup_func (regno
);
8407 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8410 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8415 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8420 if (*max_regs
!= fc
->ncols
)
8421 *max_regs
= fc
->ncols
;
8423 if (*need_col_headers
)
8425 *need_col_headers
= 0;
8427 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8429 for (r
= 0; r
< *max_regs
; r
++)
8430 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8435 printf ("%-5s ", regname (r
, 1));
8441 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8443 strcpy (tmp
, "exp");
8445 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8446 printf ("%-8s ", tmp
);
8448 for (r
= 0; r
< fc
->ncols
; r
++)
8450 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8452 switch (fc
->col_type
[r
])
8454 case DW_CFA_undefined
:
8457 case DW_CFA_same_value
:
8461 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8463 case DW_CFA_val_offset
:
8464 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8466 case DW_CFA_register
:
8467 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8469 case DW_CFA_expression
:
8470 strcpy (tmp
, "exp");
8472 case DW_CFA_val_expression
:
8473 strcpy (tmp
, "vexp");
8476 strcpy (tmp
, "n/a");
8479 printf ("%-5s ", tmp
);
8485 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8487 static unsigned char *
8488 read_cie (unsigned char *start
, unsigned char *end
,
8489 Frame_Chunk
**p_cie
, int *p_version
,
8490 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8494 unsigned char *augmentation_data
= NULL
;
8495 bfd_size_type augmentation_data_len
= 0;
8498 /* PR 17512: file: 001-228113-0.004. */
8502 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8503 memset (fc
, 0, sizeof (Frame_Chunk
));
8505 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8506 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8510 fc
->augmentation
= (char *) start
;
8511 /* PR 17512: file: 001-228113-0.004.
8512 Skip past augmentation name, but avoid running off the end of the data. */
8514 if (* start
++ == '\0')
8518 warn (_("No terminator for augmentation name\n"));
8522 if (strcmp (fc
->augmentation
, "eh") == 0)
8523 start
+= eh_addr_size
;
8527 GET (fc
->ptr_size
, 1);
8528 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8530 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8534 GET (fc
->segment_size
, 1);
8535 /* PR 17512: file: e99d2804. */
8536 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8538 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8542 eh_addr_size
= fc
->ptr_size
;
8546 fc
->ptr_size
= eh_addr_size
;
8547 fc
->segment_size
= 0;
8550 READ_ULEB (fc
->code_factor
, start
, end
);
8551 READ_SLEB (fc
->data_factor
, start
, end
);
8559 READ_ULEB (fc
->ra
, start
, end
);
8562 if (fc
->augmentation
[0] == 'z')
8564 READ_ULEB (augmentation_data_len
, start
, end
);
8565 augmentation_data
= start
;
8566 /* PR 17512: file: 11042-2589-0.004. */
8567 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8569 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8570 dwarf_vmatoa ("x", augmentation_data_len
),
8571 (unsigned long) (end
- start
));
8574 start
+= augmentation_data_len
;
8577 if (augmentation_data_len
)
8581 unsigned char *qend
;
8583 p
= (unsigned char *) fc
->augmentation
+ 1;
8584 q
= augmentation_data
;
8585 qend
= q
+ augmentation_data_len
;
8587 while (p
< end
&& q
< qend
)
8592 q
+= 1 + size_of_encoded_value (*q
);
8594 fc
->fde_encoding
= *q
++;
8603 /* Note - it is OK if this loop terminates with q < qend.
8604 Padding may have been inserted to align the end of the CIE. */
8609 *p_version
= version
;
8612 *p_aug_len
= augmentation_data_len
;
8613 *p_aug
= augmentation_data
;
8618 free (fc
->col_offset
);
8619 free (fc
->col_type
);
8624 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8625 If do_wide is not enabled, then formats the output to fit into 80 columns.
8626 PRINTED contains the number of characters already written to the current
8630 display_data (bfd_size_type printed
,
8631 const unsigned char * data
,
8632 const bfd_size_type len
)
8634 if (do_wide
|| len
< ((80 - printed
) / 3))
8635 for (printed
= 0; printed
< len
; ++printed
)
8636 printf (" %02x", data
[printed
]);
8639 for (printed
= 0; printed
< len
; ++printed
)
8641 if (printed
% (80 / 3) == 0)
8643 printf (" %02x", data
[printed
]);
8648 /* Prints out the contents on the augmentation data array.
8649 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8652 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8656 i
= printf (_(" Augmentation data: "));
8657 display_data (i
, data
, len
);
8661 display_debug_frames (struct dwarf_section
*section
,
8662 void *file ATTRIBUTE_UNUSED
)
8664 unsigned char *start
= section
->start
;
8665 unsigned char *end
= start
+ section
->size
;
8666 unsigned char *section_start
= start
;
8667 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8668 Frame_Chunk
*remembered_state
= NULL
;
8670 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8671 unsigned int max_regs
= 0;
8672 const char *bad_reg
= _("bad register: ");
8673 unsigned int saved_eh_addr_size
= eh_addr_size
;
8675 introduce (section
, FALSE
);
8679 unsigned char *saved_start
;
8680 unsigned char *block_end
;
8685 int need_col_headers
= 1;
8686 unsigned char *augmentation_data
= NULL
;
8687 bfd_size_type augmentation_data_len
= 0;
8688 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8689 unsigned int offset_size
;
8690 unsigned int initial_length_size
;
8691 bfd_boolean all_nops
;
8692 static Frame_Chunk fde_fc
;
8694 saved_start
= start
;
8696 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8700 printf ("\n%08lx ZERO terminator\n\n",
8701 (unsigned long)(saved_start
- section_start
));
8702 /* Skip any zero terminators that directly follow.
8703 A corrupt section size could have loaded a whole
8704 slew of zero filled memory bytes. eg
8705 PR 17512: file: 070-19381-0.004. */
8706 while (start
< end
&& * start
== 0)
8711 if (length
== 0xffffffff)
8713 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8715 initial_length_size
= 12;
8720 initial_length_size
= 4;
8723 block_end
= saved_start
+ length
+ initial_length_size
;
8724 if (block_end
> end
|| block_end
< start
)
8726 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8727 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8728 (unsigned long) (saved_start
- section_start
));
8732 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8734 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8735 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8740 start
= read_cie (start
, end
, &cie
, &version
,
8741 &augmentation_data_len
, &augmentation_data
);
8742 /* PR 17512: file: 027-135133-0.005. */
8749 fc
->chunk_start
= saved_start
;
8750 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8753 if (frame_need_space (fc
, mreg
) < 0)
8755 if (fc
->fde_encoding
)
8756 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8758 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8759 print_dwarf_vma (length
, fc
->ptr_size
);
8760 print_dwarf_vma (cie_id
, offset_size
);
8762 if (do_debug_frames_interp
)
8764 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8765 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8770 printf (" Version: %d\n", version
);
8771 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8774 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8775 printf (" Segment Size: %u\n", fc
->segment_size
);
8777 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8778 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8779 printf (" Return address column: %d\n", fc
->ra
);
8781 if (augmentation_data_len
)
8782 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8789 unsigned char *look_for
;
8790 unsigned long segment_selector
;
8794 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8795 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8798 look_for
= section_start
+ cie_id
;
8800 if (look_for
<= saved_start
)
8802 for (cie
= chunks
; cie
; cie
= cie
->next
)
8803 if (cie
->chunk_start
== look_for
)
8808 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8809 if (cie
->chunk_start
== look_for
)
8813 unsigned int off_size
;
8814 unsigned char *cie_scan
;
8816 cie_scan
= look_for
;
8818 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8819 if (length
== 0xffffffff)
8821 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8828 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8831 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8832 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8837 read_cie (cie_scan
, end
, &cie
, &version
,
8838 &augmentation_data_len
, &augmentation_data
);
8839 /* PR 17512: file: 3450-2098-0.004. */
8842 warn (_("Failed to read CIE information\n"));
8845 cie
->next
= forward_refs
;
8847 cie
->chunk_start
= look_for
;
8848 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8851 if (frame_need_space (cie
, mreg
) < 0)
8853 warn (_("Invalid max register\n"));
8856 if (cie
->fde_encoding
)
8858 = size_of_encoded_value (cie
->fde_encoding
);
8865 memset (fc
, 0, sizeof (Frame_Chunk
));
8869 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8870 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8871 (unsigned long) (saved_start
- section_start
));
8873 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8874 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8875 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8877 warn (_("Invalid max register\n"));
8881 fc
->augmentation
= "";
8882 fc
->fde_encoding
= 0;
8883 fc
->ptr_size
= eh_addr_size
;
8884 fc
->segment_size
= 0;
8888 fc
->ncols
= cie
->ncols
;
8889 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8890 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8891 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8892 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8893 fc
->augmentation
= cie
->augmentation
;
8894 fc
->ptr_size
= cie
->ptr_size
;
8895 eh_addr_size
= cie
->ptr_size
;
8896 fc
->segment_size
= cie
->segment_size
;
8897 fc
->code_factor
= cie
->code_factor
;
8898 fc
->data_factor
= cie
->data_factor
;
8899 fc
->cfa_reg
= cie
->cfa_reg
;
8900 fc
->cfa_offset
= cie
->cfa_offset
;
8902 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8904 warn (_("Invalid max register\n"));
8907 fc
->fde_encoding
= cie
->fde_encoding
;
8910 if (fc
->fde_encoding
)
8911 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8913 segment_selector
= 0;
8914 if (fc
->segment_size
)
8916 if (fc
->segment_size
> sizeof (segment_selector
))
8918 /* PR 17512: file: 9e196b3e. */
8919 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8920 fc
->segment_size
= 4;
8922 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8925 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8927 /* FIXME: It appears that sometimes the final pc_range value is
8928 encoded in less than encoded_ptr_size bytes. See the x86_64
8929 run of the "objcopy on compressed debug sections" test for an
8931 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8933 if (cie
->augmentation
[0] == 'z')
8935 READ_ULEB (augmentation_data_len
, start
, end
);
8936 augmentation_data
= start
;
8937 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8938 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8940 warn (_("Augmentation data too long: 0x%s, "
8941 "expected at most %#lx\n"),
8942 dwarf_vmatoa ("x", augmentation_data_len
),
8943 (unsigned long) (end
- start
));
8945 augmentation_data
= NULL
;
8946 augmentation_data_len
= 0;
8948 start
+= augmentation_data_len
;
8951 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8952 (unsigned long)(saved_start
- section_start
),
8953 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8954 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8955 (unsigned long)(cie
->chunk_start
- section_start
));
8957 if (fc
->segment_size
)
8958 printf ("%04lx:", segment_selector
);
8961 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8962 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8964 if (! do_debug_frames_interp
&& augmentation_data_len
)
8966 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8971 /* At this point, fc is the current chunk, cie (if any) is set, and
8972 we're about to interpret instructions for the chunk. */
8973 /* ??? At present we need to do this always, since this sizes the
8974 fc->col_type and fc->col_offset arrays, which we write into always.
8975 We should probably split the interpreted and non-interpreted bits
8976 into two different routines, since there's so much that doesn't
8977 really overlap between them. */
8978 if (1 || do_debug_frames_interp
)
8980 /* Start by making a pass over the chunk, allocating storage
8981 and taking note of what registers are used. */
8982 unsigned char *tmp
= start
;
8984 while (start
< block_end
)
8986 unsigned int reg
, op
, opa
;
8988 unsigned char * new_start
;
8995 /* Warning: if you add any more cases to this switch, be
8996 sure to add them to the corresponding switch below. */
8999 case DW_CFA_advance_loc
:
9002 SKIP_ULEB (start
, end
);
9003 if (frame_need_space (fc
, opa
) >= 0)
9004 fc
->col_type
[opa
] = DW_CFA_undefined
;
9006 case DW_CFA_restore
:
9007 if (frame_need_space (fc
, opa
) >= 0)
9008 fc
->col_type
[opa
] = DW_CFA_undefined
;
9010 case DW_CFA_set_loc
:
9011 start
+= encoded_ptr_size
;
9013 case DW_CFA_advance_loc1
:
9016 case DW_CFA_advance_loc2
:
9019 case DW_CFA_advance_loc4
:
9022 case DW_CFA_offset_extended
:
9023 case DW_CFA_val_offset
:
9024 READ_ULEB (reg
, start
, end
);
9025 SKIP_ULEB (start
, end
);
9026 if (frame_need_space (fc
, reg
) >= 0)
9027 fc
->col_type
[reg
] = DW_CFA_undefined
;
9029 case DW_CFA_restore_extended
:
9030 READ_ULEB (reg
, start
, end
);
9031 if (frame_need_space (fc
, reg
) >= 0)
9032 fc
->col_type
[reg
] = DW_CFA_undefined
;
9034 case DW_CFA_undefined
:
9035 READ_ULEB (reg
, start
, end
);
9036 if (frame_need_space (fc
, reg
) >= 0)
9037 fc
->col_type
[reg
] = DW_CFA_undefined
;
9039 case DW_CFA_same_value
:
9040 READ_ULEB (reg
, start
, end
);
9041 if (frame_need_space (fc
, reg
) >= 0)
9042 fc
->col_type
[reg
] = DW_CFA_undefined
;
9044 case DW_CFA_register
:
9045 READ_ULEB (reg
, start
, end
);
9046 SKIP_ULEB (start
, end
);
9047 if (frame_need_space (fc
, reg
) >= 0)
9048 fc
->col_type
[reg
] = DW_CFA_undefined
;
9050 case DW_CFA_def_cfa
:
9051 SKIP_ULEB (start
, end
);
9052 SKIP_ULEB (start
, end
);
9054 case DW_CFA_def_cfa_register
:
9055 SKIP_ULEB (start
, end
);
9057 case DW_CFA_def_cfa_offset
:
9058 SKIP_ULEB (start
, end
);
9060 case DW_CFA_def_cfa_expression
:
9061 READ_ULEB (temp
, start
, end
);
9062 new_start
= start
+ temp
;
9063 if (new_start
< start
)
9065 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
9071 case DW_CFA_expression
:
9072 case DW_CFA_val_expression
:
9073 READ_ULEB (reg
, start
, end
);
9074 READ_ULEB (temp
, start
, end
);
9075 new_start
= start
+ temp
;
9076 if (new_start
< start
)
9078 /* PR 17512: file:306-192417-0.005. */
9079 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
9084 if (frame_need_space (fc
, reg
) >= 0)
9085 fc
->col_type
[reg
] = DW_CFA_undefined
;
9087 case DW_CFA_offset_extended_sf
:
9088 case DW_CFA_val_offset_sf
:
9089 READ_ULEB (reg
, start
, end
);
9090 SKIP_SLEB (start
, end
);
9091 if (frame_need_space (fc
, reg
) >= 0)
9092 fc
->col_type
[reg
] = DW_CFA_undefined
;
9094 case DW_CFA_def_cfa_sf
:
9095 SKIP_ULEB (start
, end
);
9096 SKIP_SLEB (start
, end
);
9098 case DW_CFA_def_cfa_offset_sf
:
9099 SKIP_SLEB (start
, end
);
9101 case DW_CFA_MIPS_advance_loc8
:
9104 case DW_CFA_GNU_args_size
:
9105 SKIP_ULEB (start
, end
);
9107 case DW_CFA_GNU_negative_offset_extended
:
9108 READ_ULEB (reg
, start
, end
);
9109 SKIP_ULEB (start
, end
);
9110 if (frame_need_space (fc
, reg
) >= 0)
9111 fc
->col_type
[reg
] = DW_CFA_undefined
;
9122 /* Now we know what registers are used, make a second pass over
9123 the chunk, this time actually printing out the info. */
9125 while (start
< block_end
)
9127 unsigned char * tmp
;
9129 unsigned long ul
, roffs
;
9130 /* Note: It is tempting to use an unsigned long for 'reg' but there
9131 are various functions, notably frame_space_needed() that assume that
9132 reg is an unsigned int. */
9137 const char *reg_prefix
= "";
9144 /* Make a note if something other than DW_CFA_nop happens. */
9145 if (op
!= DW_CFA_nop
)
9148 /* Warning: if you add any more cases to this switch, be
9149 sure to add them to the corresponding switch above. */
9152 case DW_CFA_advance_loc
:
9153 if (do_debug_frames_interp
)
9154 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9156 printf (" DW_CFA_advance_loc: %d to %s\n",
9157 opa
* fc
->code_factor
,
9158 dwarf_vmatoa_1 (NULL
,
9159 fc
->pc_begin
+ opa
* fc
->code_factor
,
9161 fc
->pc_begin
+= opa
* fc
->code_factor
;
9165 READ_ULEB (roffs
, start
, end
);
9166 if (opa
>= (unsigned int) fc
->ncols
)
9167 reg_prefix
= bad_reg
;
9168 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9169 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9170 reg_prefix
, regname (opa
, 0),
9171 roffs
* fc
->data_factor
);
9172 if (*reg_prefix
== '\0')
9174 fc
->col_type
[opa
] = DW_CFA_offset
;
9175 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9179 case DW_CFA_restore
:
9180 if (opa
>= (unsigned int) fc
->ncols
)
9181 reg_prefix
= bad_reg
;
9182 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9183 printf (" DW_CFA_restore: %s%s\n",
9184 reg_prefix
, regname (opa
, 0));
9185 if (*reg_prefix
!= '\0')
9188 if (opa
>= (unsigned int) cie
->ncols
9189 || (do_debug_frames_interp
9190 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
9192 fc
->col_type
[opa
] = DW_CFA_undefined
;
9193 fc
->col_offset
[opa
] = 0;
9197 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9198 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9202 case DW_CFA_set_loc
:
9203 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
9204 if (do_debug_frames_interp
)
9205 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9207 printf (" DW_CFA_set_loc: %s\n",
9208 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
9212 case DW_CFA_advance_loc1
:
9213 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
9214 if (do_debug_frames_interp
)
9215 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9217 printf (" DW_CFA_advance_loc1: %ld to %s\n",
9218 (unsigned long) (ofs
* fc
->code_factor
),
9219 dwarf_vmatoa_1 (NULL
,
9220 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9222 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9225 case DW_CFA_advance_loc2
:
9226 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9227 if (do_debug_frames_interp
)
9228 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9230 printf (" DW_CFA_advance_loc2: %ld to %s\n",
9231 (unsigned long) (ofs
* fc
->code_factor
),
9232 dwarf_vmatoa_1 (NULL
,
9233 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9235 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9238 case DW_CFA_advance_loc4
:
9239 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9240 if (do_debug_frames_interp
)
9241 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9243 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9244 (unsigned long) (ofs
* fc
->code_factor
),
9245 dwarf_vmatoa_1 (NULL
,
9246 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9248 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9251 case DW_CFA_offset_extended
:
9252 READ_ULEB (reg
, start
, end
);
9253 READ_ULEB (roffs
, start
, end
);
9254 if (reg
>= (unsigned int) fc
->ncols
)
9255 reg_prefix
= bad_reg
;
9256 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9257 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9258 reg_prefix
, regname (reg
, 0),
9259 roffs
* fc
->data_factor
);
9260 if (*reg_prefix
== '\0')
9262 fc
->col_type
[reg
] = DW_CFA_offset
;
9263 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9267 case DW_CFA_val_offset
:
9268 READ_ULEB (reg
, start
, end
);
9269 READ_ULEB (roffs
, start
, end
);
9270 if (reg
>= (unsigned int) fc
->ncols
)
9271 reg_prefix
= bad_reg
;
9272 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9273 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9274 reg_prefix
, regname (reg
, 0),
9275 roffs
* fc
->data_factor
);
9276 if (*reg_prefix
== '\0')
9278 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9279 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9283 case DW_CFA_restore_extended
:
9284 READ_ULEB (reg
, start
, end
);
9285 if (reg
>= (unsigned int) fc
->ncols
)
9286 reg_prefix
= bad_reg
;
9287 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9288 printf (" DW_CFA_restore_extended: %s%s\n",
9289 reg_prefix
, regname (reg
, 0));
9290 if (*reg_prefix
!= '\0')
9293 if (reg
>= (unsigned int) cie
->ncols
)
9295 fc
->col_type
[reg
] = DW_CFA_undefined
;
9296 fc
->col_offset
[reg
] = 0;
9300 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9301 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9305 case DW_CFA_undefined
:
9306 READ_ULEB (reg
, start
, end
);
9307 if (reg
>= (unsigned int) fc
->ncols
)
9308 reg_prefix
= bad_reg
;
9309 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9310 printf (" DW_CFA_undefined: %s%s\n",
9311 reg_prefix
, regname (reg
, 0));
9312 if (*reg_prefix
== '\0')
9314 fc
->col_type
[reg
] = DW_CFA_undefined
;
9315 fc
->col_offset
[reg
] = 0;
9319 case DW_CFA_same_value
:
9320 READ_ULEB (reg
, start
, end
);
9321 if (reg
>= (unsigned int) fc
->ncols
)
9322 reg_prefix
= bad_reg
;
9323 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9324 printf (" DW_CFA_same_value: %s%s\n",
9325 reg_prefix
, regname (reg
, 0));
9326 if (*reg_prefix
== '\0')
9328 fc
->col_type
[reg
] = DW_CFA_same_value
;
9329 fc
->col_offset
[reg
] = 0;
9333 case DW_CFA_register
:
9334 READ_ULEB (reg
, start
, end
);
9335 READ_ULEB (roffs
, start
, end
);
9336 if (reg
>= (unsigned int) fc
->ncols
)
9337 reg_prefix
= bad_reg
;
9338 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9340 printf (" DW_CFA_register: %s%s in ",
9341 reg_prefix
, regname (reg
, 0));
9342 puts (regname (roffs
, 0));
9344 if (*reg_prefix
== '\0')
9346 fc
->col_type
[reg
] = DW_CFA_register
;
9347 fc
->col_offset
[reg
] = roffs
;
9351 case DW_CFA_remember_state
:
9352 if (! do_debug_frames_interp
)
9353 printf (" DW_CFA_remember_state\n");
9354 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9355 rs
->cfa_offset
= fc
->cfa_offset
;
9356 rs
->cfa_reg
= fc
->cfa_reg
;
9358 rs
->cfa_exp
= fc
->cfa_exp
;
9359 rs
->ncols
= fc
->ncols
;
9360 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9361 sizeof (* rs
->col_type
));
9362 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9363 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9364 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9365 rs
->next
= remembered_state
;
9366 remembered_state
= rs
;
9369 case DW_CFA_restore_state
:
9370 if (! do_debug_frames_interp
)
9371 printf (" DW_CFA_restore_state\n");
9372 rs
= remembered_state
;
9375 remembered_state
= rs
->next
;
9376 fc
->cfa_offset
= rs
->cfa_offset
;
9377 fc
->cfa_reg
= rs
->cfa_reg
;
9379 fc
->cfa_exp
= rs
->cfa_exp
;
9380 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9382 warn (_("Invalid column number in saved frame state\n"));
9386 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9387 memcpy (fc
->col_offset
, rs
->col_offset
,
9388 rs
->ncols
* sizeof (* rs
->col_offset
));
9389 free (rs
->col_type
);
9390 free (rs
->col_offset
);
9393 else if (do_debug_frames_interp
)
9394 printf ("Mismatched DW_CFA_restore_state\n");
9397 case DW_CFA_def_cfa
:
9398 READ_ULEB (fc
->cfa_reg
, start
, end
);
9399 READ_ULEB (fc
->cfa_offset
, start
, end
);
9401 if (! do_debug_frames_interp
)
9402 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9403 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9406 case DW_CFA_def_cfa_register
:
9407 READ_ULEB (fc
->cfa_reg
, start
, end
);
9409 if (! do_debug_frames_interp
)
9410 printf (" DW_CFA_def_cfa_register: %s\n",
9411 regname (fc
->cfa_reg
, 0));
9414 case DW_CFA_def_cfa_offset
:
9415 READ_ULEB (fc
->cfa_offset
, start
, end
);
9416 if (! do_debug_frames_interp
)
9417 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9421 if (! do_debug_frames_interp
)
9422 printf (" DW_CFA_nop\n");
9425 case DW_CFA_def_cfa_expression
:
9426 READ_ULEB (ul
, start
, end
);
9427 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
9429 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9432 if (! do_debug_frames_interp
)
9434 printf (" DW_CFA_def_cfa_expression (");
9435 decode_location_expression (start
, eh_addr_size
, 0, -1,
9443 case DW_CFA_expression
:
9444 READ_ULEB (reg
, start
, end
);
9445 READ_ULEB (ul
, start
, end
);
9446 if (reg
>= (unsigned int) fc
->ncols
)
9447 reg_prefix
= bad_reg
;
9448 /* PR 17512: file: 069-133014-0.006. */
9449 /* PR 17512: file: 98c02eb4. */
9451 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9453 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9456 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9458 printf (" DW_CFA_expression: %s%s (",
9459 reg_prefix
, regname (reg
, 0));
9460 decode_location_expression (start
, eh_addr_size
, 0, -1,
9464 if (*reg_prefix
== '\0')
9465 fc
->col_type
[reg
] = DW_CFA_expression
;
9469 case DW_CFA_val_expression
:
9470 READ_ULEB (reg
, start
, end
);
9471 READ_ULEB (ul
, start
, end
);
9472 if (reg
>= (unsigned int) fc
->ncols
)
9473 reg_prefix
= bad_reg
;
9475 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9477 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9480 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9482 printf (" DW_CFA_val_expression: %s%s (",
9483 reg_prefix
, regname (reg
, 0));
9484 decode_location_expression (start
, eh_addr_size
, 0, -1,
9488 if (*reg_prefix
== '\0')
9489 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9493 case DW_CFA_offset_extended_sf
:
9494 READ_ULEB (reg
, start
, end
);
9495 READ_SLEB (l
, start
, end
);
9496 if (frame_need_space (fc
, reg
) < 0)
9497 reg_prefix
= bad_reg
;
9498 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9499 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9500 reg_prefix
, regname (reg
, 0),
9501 (long)(l
* fc
->data_factor
));
9502 if (*reg_prefix
== '\0')
9504 fc
->col_type
[reg
] = DW_CFA_offset
;
9505 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9509 case DW_CFA_val_offset_sf
:
9510 READ_ULEB (reg
, start
, end
);
9511 READ_SLEB (l
, start
, end
);
9512 if (frame_need_space (fc
, reg
) < 0)
9513 reg_prefix
= bad_reg
;
9514 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9515 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9516 reg_prefix
, regname (reg
, 0),
9517 (long)(l
* fc
->data_factor
));
9518 if (*reg_prefix
== '\0')
9520 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9521 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9525 case DW_CFA_def_cfa_sf
:
9526 READ_ULEB (fc
->cfa_reg
, start
, end
);
9527 READ_ULEB (fc
->cfa_offset
, start
, end
);
9528 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
9530 if (! do_debug_frames_interp
)
9531 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
9532 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9535 case DW_CFA_def_cfa_offset_sf
:
9536 READ_ULEB (fc
->cfa_offset
, start
, end
);
9537 fc
->cfa_offset
*= fc
->data_factor
;
9538 if (! do_debug_frames_interp
)
9539 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
9542 case DW_CFA_MIPS_advance_loc8
:
9543 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9544 if (do_debug_frames_interp
)
9545 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9547 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9548 (unsigned long) (ofs
* fc
->code_factor
),
9549 dwarf_vmatoa_1 (NULL
,
9550 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9552 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9555 case DW_CFA_GNU_window_save
:
9556 if (! do_debug_frames_interp
)
9557 printf (" DW_CFA_GNU_window_save\n");
9560 case DW_CFA_GNU_args_size
:
9561 READ_ULEB (ul
, start
, end
);
9562 if (! do_debug_frames_interp
)
9563 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9566 case DW_CFA_GNU_negative_offset_extended
:
9567 READ_ULEB (reg
, start
, end
);
9568 READ_SLEB (l
, start
, end
);
9570 if (frame_need_space (fc
, reg
) < 0)
9571 reg_prefix
= bad_reg
;
9572 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9573 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9574 reg_prefix
, regname (reg
, 0),
9575 (long)(l
* fc
->data_factor
));
9576 if (*reg_prefix
== '\0')
9578 fc
->col_type
[reg
] = DW_CFA_offset
;
9579 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9584 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9585 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9587 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9592 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9593 if (do_debug_frames_interp
&& ! all_nops
)
9594 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9596 if (fde_fc
.col_type
!= NULL
)
9598 free (fde_fc
.col_type
);
9599 fde_fc
.col_type
= NULL
;
9601 if (fde_fc
.col_offset
!= NULL
)
9603 free (fde_fc
.col_offset
);
9604 fde_fc
.col_offset
= NULL
;
9608 eh_addr_size
= saved_eh_addr_size
;
9613 while (remembered_state
!= NULL
)
9615 rs
= remembered_state
;
9616 remembered_state
= rs
->next
;
9617 free (rs
->col_type
);
9618 free (rs
->col_offset
);
9619 rs
->next
= NULL
; /* Paranoia. */
9623 while (chunks
!= NULL
)
9627 free (rs
->col_type
);
9628 free (rs
->col_offset
);
9629 rs
->next
= NULL
; /* Paranoia. */
9633 while (forward_refs
!= NULL
)
9636 forward_refs
= rs
->next
;
9637 free (rs
->col_type
);
9638 free (rs
->col_offset
);
9639 rs
->next
= NULL
; /* Paranoia. */
9649 display_debug_names (struct dwarf_section
*section
, void *file
)
9651 unsigned char *hdrptr
= section
->start
;
9652 dwarf_vma unit_length
;
9653 unsigned char *unit_start
;
9654 const unsigned char *const section_end
= section
->start
+ section
->size
;
9655 unsigned char *unit_end
;
9657 introduce (section
, FALSE
);
9659 load_debug_section_with_follow (str
, file
);
9661 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9663 unsigned int offset_size
;
9664 uint16_t dwarf_version
, padding
;
9665 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9666 uint32_t bucket_count
, name_count
, abbrev_table_size
;
9667 uint32_t augmentation_string_size
;
9669 unsigned long sec_off
;
9670 bfd_boolean augmentation_printable
;
9671 const char *augmentation_string
;
9673 unit_start
= hdrptr
;
9675 /* Get and check the length of the block. */
9676 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9678 if (unit_length
== 0xffffffff)
9680 /* This section is 64-bit DWARF. */
9681 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9686 unit_end
= hdrptr
+ unit_length
;
9688 sec_off
= hdrptr
- section
->start
;
9689 if (sec_off
+ unit_length
< sec_off
9690 || sec_off
+ unit_length
> section
->size
)
9692 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9694 (unsigned long) (unit_start
- section
->start
),
9695 dwarf_vmatoa ("x", unit_length
));
9699 /* Get and check the version number. */
9700 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9701 printf (_("Version %ld\n"), (long) dwarf_version
);
9703 /* Prior versions did not exist, and future versions may not be
9704 backwards compatible. */
9705 if (dwarf_version
!= 5)
9707 warn (_("Only DWARF version 5 .debug_names "
9708 "is currently supported.\n"));
9712 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9714 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9717 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9718 if (comp_unit_count
== 0)
9719 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9721 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9722 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9723 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9724 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9725 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9727 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9728 if (augmentation_string_size
% 4 != 0)
9730 warn (_("Augmentation string length %u must be rounded up "
9731 "to a multiple of 4 in .debug_names.\n"),
9732 augmentation_string_size
);
9733 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9736 printf (_("Augmentation string:"));
9738 augmentation_printable
= TRUE
;
9739 augmentation_string
= (const char *) hdrptr
;
9741 for (i
= 0; i
< augmentation_string_size
; i
++)
9745 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9746 printf (" %02x", uc
);
9748 if (uc
!= 0 && !ISPRINT (uc
))
9749 augmentation_printable
= FALSE
;
9752 if (augmentation_printable
)
9756 i
< augmentation_string_size
&& augmentation_string
[i
];
9758 putchar (augmentation_string
[i
]);
9763 printf (_("CU table:\n"));
9764 for (i
= 0; i
< comp_unit_count
; i
++)
9768 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9769 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9773 printf (_("TU table:\n"));
9774 for (i
= 0; i
< local_type_unit_count
; i
++)
9778 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9779 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9783 printf (_("Foreign TU table:\n"));
9784 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9788 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9789 printf (_("[%3u] "), i
);
9790 print_dwarf_vma (signature
, 8);
9795 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9796 hdrptr
+= bucket_count
* sizeof (uint32_t);
9797 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9798 hdrptr
+= name_count
* sizeof (uint32_t);
9799 unsigned char *const name_table_string_offsets
= hdrptr
;
9800 hdrptr
+= name_count
* offset_size
;
9801 unsigned char *const name_table_entry_offsets
= hdrptr
;
9802 hdrptr
+= name_count
* offset_size
;
9803 unsigned char *const abbrev_table
= hdrptr
;
9804 hdrptr
+= abbrev_table_size
;
9805 const unsigned char *const abbrev_table_end
= hdrptr
;
9806 unsigned char *const entry_pool
= hdrptr
;
9807 if (hdrptr
> unit_end
)
9809 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9810 "for unit 0x%lx in the debug_names\n"),
9811 (long) (hdrptr
- section
->start
),
9812 (long) (unit_end
- section
->start
),
9813 (long) (unit_start
- section
->start
));
9817 size_t buckets_filled
= 0;
9819 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9821 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9826 printf (ngettext ("Used %zu of %lu bucket.\n",
9827 "Used %zu of %lu buckets.\n",
9829 buckets_filled
, (unsigned long) bucket_count
);
9831 uint32_t hash_prev
= 0;
9832 size_t hash_clash_count
= 0;
9833 size_t longest_clash
= 0;
9834 size_t this_length
= 0;
9836 for (hashi
= 0; hashi
< name_count
; hashi
++)
9838 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9842 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9846 longest_clash
= MAX (longest_clash
, this_length
);
9851 hash_prev
= hash_this
;
9853 printf (_("Out of %lu items there are %zu bucket clashes"
9854 " (longest of %zu entries).\n"),
9855 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9856 assert (name_count
== buckets_filled
+ hash_clash_count
);
9858 struct abbrev_lookup_entry
9860 dwarf_vma abbrev_tag
;
9861 unsigned char *abbrev_lookup_ptr
;
9863 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9864 size_t abbrev_lookup_used
= 0;
9865 size_t abbrev_lookup_allocated
= 0;
9867 unsigned char *abbrevptr
= abbrev_table
;
9870 dwarf_vma abbrev_tag
;
9872 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9873 if (abbrev_tag
== 0)
9875 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9877 abbrev_lookup_allocated
= MAX (0x100,
9878 abbrev_lookup_allocated
* 2);
9879 abbrev_lookup
= xrealloc (abbrev_lookup
,
9880 (abbrev_lookup_allocated
9881 * sizeof (*abbrev_lookup
)));
9883 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9884 struct abbrev_lookup_entry
*entry
;
9885 for (entry
= abbrev_lookup
;
9886 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9888 if (entry
->abbrev_tag
== abbrev_tag
)
9890 warn (_("Duplicate abbreviation tag %lu "
9891 "in unit 0x%lx in the debug_names\n"),
9892 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9895 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9896 entry
->abbrev_tag
= abbrev_tag
;
9897 entry
->abbrev_lookup_ptr
= abbrevptr
;
9899 /* Skip DWARF tag. */
9900 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9903 dwarf_vma xindex
, form
;
9905 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9906 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9907 if (xindex
== 0 && form
== 0)
9912 printf (_("\nSymbol table:\n"));
9914 for (namei
= 0; namei
< name_count
; ++namei
)
9916 uint64_t string_offset
, entry_offset
;
9918 SAFE_BYTE_GET (string_offset
,
9919 name_table_string_offsets
+ namei
* offset_size
,
9920 offset_size
, unit_end
);
9921 SAFE_BYTE_GET (entry_offset
,
9922 name_table_entry_offsets
+ namei
* offset_size
,
9923 offset_size
, unit_end
);
9925 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9926 fetch_indirect_string (string_offset
));
9928 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9930 /* We need to scan first whether there is a single or multiple
9931 entries. TAGNO is -2 for the first entry, it is -1 for the
9932 initial tag read of the second entry, then it becomes 0 for the
9933 first entry for real printing etc. */
9935 /* Initialize it due to a false compiler warning. */
9936 dwarf_vma second_abbrev_tag
= -1;
9939 dwarf_vma abbrev_tag
;
9940 dwarf_vma dwarf_tag
;
9941 const struct abbrev_lookup_entry
*entry
;
9943 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9946 second_abbrev_tag
= abbrev_tag
;
9948 entryptr
= entry_pool
+ entry_offset
;
9951 if (abbrev_tag
== 0)
9955 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9956 (unsigned long) abbrev_tag
);
9958 for (entry
= abbrev_lookup
;
9959 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9961 if (entry
->abbrev_tag
== abbrev_tag
)
9963 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9965 warn (_("Undefined abbreviation tag %lu "
9966 "in unit 0x%lx in the debug_names\n"),
9968 (long) (unit_start
- section
->start
));
9971 abbrevptr
= entry
->abbrev_lookup_ptr
;
9972 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9974 printf (" %s", get_TAG_name (dwarf_tag
));
9977 dwarf_vma xindex
, form
;
9979 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9980 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9981 if (xindex
== 0 && form
== 0)
9985 printf (" %s", get_IDX_name (xindex
));
9986 entryptr
= read_and_display_attr_value (0, form
, 0,
9987 unit_start
, entryptr
, unit_end
,
9989 dwarf_version
, NULL
,
9996 printf (_(" <no entries>"));
10000 free (abbrev_lookup
);
10007 display_debug_links (struct dwarf_section
* section
,
10008 void * file ATTRIBUTE_UNUSED
)
10010 const unsigned char * filename
;
10011 unsigned int filelen
;
10013 introduce (section
, FALSE
);
10015 /* The .gnu_debuglink section is formatted as:
10016 (c-string) Filename.
10017 (padding) If needed to reach a 4 byte boundary.
10018 (uint32_t) CRC32 value.
10020 The .gun_debugaltlink section is formatted as:
10021 (c-string) Filename.
10022 (binary) Build-ID. */
10024 filename
= section
->start
;
10025 filelen
= strnlen ((const char *) filename
, section
->size
);
10026 if (filelen
== section
->size
)
10028 warn (_("The debuglink filename is corrupt/missing\n"));
10032 printf (_(" Separate debug info file: %s\n"), filename
);
10034 if (const_strneq (section
->name
, ".gnu_debuglink"))
10036 unsigned int crc32
;
10037 unsigned int crc_offset
;
10039 crc_offset
= filelen
+ 1;
10040 crc_offset
= (crc_offset
+ 3) & ~3;
10041 if (crc_offset
+ 4 > section
->size
)
10043 warn (_("CRC offset missing/truncated\n"));
10047 crc32
= byte_get (filename
+ crc_offset
, 4);
10049 printf (_(" CRC value: %#x\n"), crc32
);
10051 if (crc_offset
+ 4 < section
->size
)
10053 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
10054 (long)(section
->size
- (crc_offset
+ 4)));
10058 else /* const_strneq (section->name, ".gnu_debugaltlink") */
10060 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
10061 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
10062 bfd_size_type printed
;
10064 /* FIXME: Should we support smaller build-id notes ? */
10065 if (build_id_len
< 0x14)
10067 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
10071 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
10072 display_data (printed
, build_id
, build_id_len
);
10081 display_gdb_index (struct dwarf_section
*section
,
10082 void *file ATTRIBUTE_UNUSED
)
10084 unsigned char *start
= section
->start
;
10086 uint32_t cu_list_offset
, tu_list_offset
;
10087 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10088 unsigned int cu_list_elements
, tu_list_elements
;
10089 unsigned int address_table_size
, symbol_table_slots
;
10090 unsigned char *cu_list
, *tu_list
;
10091 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10094 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10096 introduce (section
, FALSE
);
10098 if (section
->size
< 6 * sizeof (uint32_t))
10100 warn (_("Truncated header in the %s section.\n"), section
->name
);
10104 version
= byte_get_little_endian (start
, 4);
10105 printf (_("Version %ld\n"), (long) version
);
10107 /* Prior versions are obsolete, and future versions may not be
10108 backwards compatible. */
10109 if (version
< 3 || version
> 8)
10111 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10115 warn (_("The address table data in version 3 may be wrong.\n"));
10117 warn (_("Version 4 does not support case insensitive lookups.\n"));
10119 warn (_("Version 5 does not include inlined functions.\n"));
10121 warn (_("Version 6 does not include symbol attributes.\n"));
10122 /* Version 7 indices generated by Gold have bad type unit references,
10123 PR binutils/15021. But we don't know if the index was generated by
10124 Gold or not, so to avoid worrying users with gdb-generated indices
10125 we say nothing for version 7 here. */
10127 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10128 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10129 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10130 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10131 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10133 if (cu_list_offset
> section
->size
10134 || tu_list_offset
> section
->size
10135 || address_table_offset
> section
->size
10136 || symbol_table_offset
> section
->size
10137 || constant_pool_offset
> section
->size
)
10139 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10143 /* PR 17531: file: 418d0a8a. */
10144 if (tu_list_offset
< cu_list_offset
)
10146 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
10147 tu_list_offset
, cu_list_offset
);
10151 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
10153 if (address_table_offset
< tu_list_offset
)
10155 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
10156 address_table_offset
, tu_list_offset
);
10160 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
10162 /* PR 17531: file: 18a47d3d. */
10163 if (symbol_table_offset
< address_table_offset
)
10165 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
10166 symbol_table_offset
, address_table_offset
);
10170 address_table_size
= symbol_table_offset
- address_table_offset
;
10172 if (constant_pool_offset
< symbol_table_offset
)
10174 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
10175 constant_pool_offset
, symbol_table_offset
);
10179 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10181 cu_list
= start
+ cu_list_offset
;
10182 tu_list
= start
+ tu_list_offset
;
10183 address_table
= start
+ address_table_offset
;
10184 symbol_table
= start
+ symbol_table_offset
;
10185 constant_pool
= start
+ constant_pool_offset
;
10187 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
10189 warn (_("Address table extends beyond end of section.\n"));
10193 printf (_("\nCU table:\n"));
10194 for (i
= 0; i
< cu_list_elements
; i
+= 2)
10196 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
10197 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
10199 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
10200 (unsigned long) cu_offset
,
10201 (unsigned long) (cu_offset
+ cu_length
- 1));
10204 printf (_("\nTU table:\n"));
10205 for (i
= 0; i
< tu_list_elements
; i
+= 3)
10207 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
10208 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
10209 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
10211 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
10212 (unsigned long) tu_offset
,
10213 (unsigned long) type_offset
);
10214 print_dwarf_vma (signature
, 8);
10218 printf (_("\nAddress table:\n"));
10219 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
10222 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
10223 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
10224 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
10226 print_dwarf_vma (low
, 8);
10227 print_dwarf_vma (high
, 8);
10228 printf (_("%lu\n"), (unsigned long) cu_index
);
10231 printf (_("\nSymbol table:\n"));
10232 for (i
= 0; i
< symbol_table_slots
; ++i
)
10234 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10235 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10236 uint32_t num_cus
, cu
;
10238 if (name_offset
!= 0
10239 || cu_vector_offset
!= 0)
10242 unsigned char * adr
;
10244 adr
= constant_pool
+ name_offset
;
10245 /* PR 17531: file: 5b7b07ad. */
10246 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
10248 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10249 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10253 printf ("[%3u] %.*s:", i
,
10254 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10255 constant_pool
+ name_offset
);
10257 adr
= constant_pool
+ cu_vector_offset
;
10258 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
10260 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10261 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10262 cu_vector_offset
, i
);
10266 num_cus
= byte_get_little_endian (adr
, 4);
10268 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
10269 if (num_cus
* 4 < num_cus
10270 || adr
>= section
->start
+ section
->size
10271 || adr
< constant_pool
)
10273 printf ("<invalid number of CUs: %d>\n", num_cus
);
10274 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10282 for (j
= 0; j
< num_cus
; ++j
)
10285 gdb_index_symbol_kind kind
;
10287 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10288 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10289 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10290 cu
= GDB_INDEX_CU_VALUE (cu
);
10291 /* Convert to TU number if it's for a type unit. */
10292 if (cu
>= cu_list_elements
/ 2)
10293 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10294 (unsigned long) (cu
- cu_list_elements
/ 2));
10296 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10298 printf (" [%s, %s]",
10299 is_static
? _("static") : _("global"),
10300 get_gdb_index_symbol_kind_name (kind
));
10312 /* Pre-allocate enough space for the CU/TU sets needed. */
10315 prealloc_cu_tu_list (unsigned int nshndx
)
10317 if (shndx_pool
== NULL
)
10319 shndx_pool_size
= nshndx
;
10320 shndx_pool_used
= 0;
10321 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10322 sizeof (unsigned int));
10326 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10327 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10328 sizeof (unsigned int));
10333 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10335 if (shndx_pool_used
>= shndx_pool_size
)
10337 error (_("Internal error: out of space in the shndx pool.\n"));
10340 shndx_pool
[shndx_pool_used
++] = shndx
;
10344 end_cu_tu_entry (void)
10346 if (shndx_pool_used
>= shndx_pool_size
)
10348 error (_("Internal error: out of space in the shndx pool.\n"));
10351 shndx_pool
[shndx_pool_used
++] = 0;
10354 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10356 static const char *
10357 get_DW_SECT_short_name (unsigned int dw_sect
)
10359 static char buf
[16];
10365 case DW_SECT_TYPES
:
10367 case DW_SECT_ABBREV
:
10373 case DW_SECT_STR_OFFSETS
:
10375 case DW_SECT_MACINFO
:
10377 case DW_SECT_MACRO
:
10383 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10387 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10388 These sections are extensions for Fission.
10389 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10392 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10394 unsigned char *phdr
= section
->start
;
10395 unsigned char *limit
= phdr
+ section
->size
;
10396 unsigned char *phash
;
10397 unsigned char *pindex
;
10398 unsigned char *ppool
;
10399 unsigned int version
;
10400 unsigned int ncols
= 0;
10401 unsigned int nused
;
10402 unsigned int nslots
;
10405 dwarf_vma signature_high
;
10406 dwarf_vma signature_low
;
10409 /* PR 17512: file: 002-168123-0.004. */
10412 warn (_("Section %s is empty\n"), section
->name
);
10415 /* PR 17512: file: 002-376-0.004. */
10416 if (section
->size
< 24)
10418 warn (_("Section %s is too small to contain a CU/TU header\n"),
10423 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
10425 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
10426 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
10427 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
10430 pindex
= phash
+ (size_t) nslots
* 8;
10431 ppool
= pindex
+ (size_t) nslots
* 4;
10435 introduce (section
, FALSE
);
10437 printf (_(" Version: %u\n"), version
);
10439 printf (_(" Number of columns: %u\n"), ncols
);
10440 printf (_(" Number of used entries: %u\n"), nused
);
10441 printf (_(" Number of slots: %u\n\n"), nslots
);
10444 /* PR 17531: file: 45d69832. */
10445 if ((size_t) nslots
* 8 / 8 != nslots
10446 || phash
< phdr
|| phash
> limit
10447 || pindex
< phash
|| pindex
> limit
10448 || ppool
< pindex
|| ppool
> limit
)
10450 warn (ngettext ("Section %s is too small for %u slot\n",
10451 "Section %s is too small for %u slots\n",
10453 section
->name
, nslots
);
10460 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10461 for (i
= 0; i
< nslots
; i
++)
10463 unsigned char *shndx_list
;
10464 unsigned int shndx
;
10466 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
10467 if (signature_high
!= 0 || signature_low
!= 0)
10469 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10470 shndx_list
= ppool
+ j
* 4;
10471 /* PR 17531: file: 705e010d. */
10472 if (shndx_list
< ppool
)
10474 warn (_("Section index pool located before start of section\n"));
10479 printf (_(" [%3d] Signature: 0x%s Sections: "),
10480 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10481 buf
, sizeof (buf
)));
10484 if (shndx_list
>= limit
)
10486 warn (_("Section %s too small for shndx pool\n"),
10490 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10494 printf (" %d", shndx
);
10496 add_shndx_to_cu_tu_entry (shndx
);
10502 end_cu_tu_entry ();
10508 else if (version
== 2)
10511 unsigned int dw_sect
;
10512 unsigned char *ph
= phash
;
10513 unsigned char *pi
= pindex
;
10514 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10515 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10516 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
10517 bfd_boolean is_tu_index
;
10518 struct cu_tu_set
*this_set
= NULL
;
10520 unsigned char *prow
;
10522 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10524 /* PR 17531: file: 0dd159bf.
10525 Check for integer overflow (can occur when size_t is 32-bit)
10526 with overlarge ncols or nused values. */
10528 && ((size_t) ncols
* 4 / 4 != ncols
10529 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
10530 || poffsets
< ppool
|| poffsets
> limit
10531 || psizes
< poffsets
|| psizes
> limit
10532 || pend
< psizes
|| pend
> limit
))
10534 warn (_("Section %s too small for offset and size tables\n"),
10541 printf (_(" Offset table\n"));
10542 printf (" slot %-16s ",
10543 is_tu_index
? _("signature") : _("dwo_id"));
10550 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10551 this_set
= tu_sets
;
10556 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10557 this_set
= cu_sets
;
10563 for (j
= 0; j
< ncols
; j
++)
10565 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10566 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10571 for (i
= 0; i
< nslots
; i
++)
10573 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10575 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10578 /* PR 17531: file: a05f6ab3. */
10581 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10588 size_t num_copy
= sizeof (uint64_t);
10590 /* PR 23064: Beware of buffer overflow. */
10591 if (ph
+ num_copy
< limit
)
10592 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10595 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
10600 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10601 /* PR 17531: file: b8ce60a8. */
10602 if (prow
< poffsets
|| prow
> limit
)
10604 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
10610 printf (_(" [%3d] 0x%s"),
10611 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10612 buf
, sizeof (buf
)));
10613 for (j
= 0; j
< ncols
; j
++)
10615 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10617 printf (" %8d", val
);
10620 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10622 /* PR 17531: file: 10796eb3. */
10623 if (dw_sect
>= DW_SECT_MAX
)
10624 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10626 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10642 printf (_(" Size table\n"));
10643 printf (" slot %-16s ",
10644 is_tu_index
? _("signature") : _("dwo_id"));
10647 for (j
= 0; j
< ncols
; j
++)
10649 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
10651 printf (" %8s", get_DW_SECT_short_name (val
));
10657 for (i
= 0; i
< nslots
; i
++)
10659 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10661 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10664 prow
= psizes
+ (row
- 1) * ncols
* 4;
10667 printf (_(" [%3d] 0x%s"),
10668 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10669 buf
, sizeof (buf
)));
10671 for (j
= 0; j
< ncols
; j
++)
10673 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10675 printf (" %8d", val
);
10678 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10679 if (dw_sect
>= DW_SECT_MAX
)
10680 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10682 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10694 else if (do_display
)
10695 printf (_(" Unsupported version (%d)\n"), version
);
10703 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10705 /* Load the CU and TU indexes if present. This will build a list of
10706 section sets that we can use to associate a .debug_info.dwo section
10707 with its associated .debug_abbrev.dwo section in a .dwp file. */
10710 load_cu_tu_indexes (void *file
)
10712 /* If we have already loaded (or tried to load) the CU and TU indexes
10713 then do not bother to repeat the task. */
10714 if (cu_tu_indexes_read
== -1)
10716 cu_tu_indexes_read
= TRUE
;
10718 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10719 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10720 cu_tu_indexes_read
= FALSE
;
10722 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10723 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10724 cu_tu_indexes_read
= FALSE
;
10727 return (bfd_boolean
) cu_tu_indexes_read
;
10730 /* Find the set of sections that includes section SHNDX. */
10733 find_cu_tu_set (void *file
, unsigned int shndx
)
10737 if (! load_cu_tu_indexes (file
))
10740 /* Find SHNDX in the shndx pool. */
10741 for (i
= 0; i
< shndx_pool_used
; i
++)
10742 if (shndx_pool
[i
] == shndx
)
10745 if (i
>= shndx_pool_used
)
10748 /* Now backup to find the first entry in the set. */
10749 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10752 return shndx_pool
+ i
;
10755 /* Display a .debug_cu_index or .debug_tu_index section. */
10758 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10760 return process_cu_tu_index (section
, 1);
10764 display_debug_not_supported (struct dwarf_section
*section
,
10765 void *file ATTRIBUTE_UNUSED
)
10767 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10773 /* Like malloc, but takes two parameters like calloc.
10774 Verifies that the first parameter is not too large.
10775 Note: does *not* initialise the allocated memory to zero. */
10778 cmalloc (size_t nmemb
, size_t size
)
10780 /* Check for overflow. */
10781 if (nmemb
>= ~(size_t) 0 / size
)
10784 return xmalloc (nmemb
* size
);
10787 /* Like xmalloc, but takes two parameters like calloc.
10788 Verifies that the first parameter is not too large.
10789 Note: does *not* initialise the allocated memory to zero. */
10792 xcmalloc (size_t nmemb
, size_t size
)
10794 /* Check for overflow. */
10795 if (nmemb
>= ~(size_t) 0 / size
)
10798 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10803 return xmalloc (nmemb
* size
);
10806 /* Like xrealloc, but takes three parameters.
10807 Verifies that the second parameter is not too large.
10808 Note: does *not* initialise any new memory to zero. */
10811 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10813 /* Check for overflow. */
10814 if (nmemb
>= ~(size_t) 0 / size
)
10816 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10821 return xrealloc (ptr
, nmemb
* size
);
10824 /* Like xcalloc, but verifies that the first parameter is not too large. */
10827 xcalloc2 (size_t nmemb
, size_t size
)
10829 /* Check for overflow. */
10830 if (nmemb
>= ~(size_t) 0 / size
)
10832 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10837 return xcalloc (nmemb
, size
);
10840 static unsigned long
10841 calc_gnu_debuglink_crc32 (unsigned long crc
,
10842 const unsigned char * buf
,
10845 static const unsigned long crc32_table
[256] =
10847 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10848 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10849 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10850 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10851 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10852 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10853 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10854 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10855 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10856 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10857 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10858 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10859 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10860 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10861 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10862 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10863 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10864 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10865 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10866 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10867 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10868 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10869 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10870 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10871 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10872 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10873 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10874 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10875 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10876 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10877 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10878 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10879 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10880 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10881 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10882 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10883 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10884 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10885 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10886 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10887 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10888 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10889 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10890 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10891 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10892 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10893 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10894 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10895 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10896 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10897 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10900 const unsigned char *end
;
10902 crc
= ~crc
& 0xffffffff;
10903 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10904 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10905 return ~crc
& 0xffffffff;
10908 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10909 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10912 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10914 static unsigned char buffer
[8 * 1024];
10916 bfd_size_type count
;
10917 unsigned long crc
= 0;
10920 sep_data
= open_debug_file (pathname
);
10921 if (sep_data
== NULL
)
10924 /* Yes - we are opening the file twice... */
10925 f
= fopen (pathname
, "rb");
10928 /* Paranoia: This should never happen. */
10929 close_debug_file (sep_data
);
10930 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10934 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10935 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10939 if (crc
!= * (unsigned long *) crc_pointer
)
10941 close_debug_file (sep_data
);
10942 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10950 static const char *
10951 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10954 unsigned int crc_offset
;
10955 unsigned long * crc32
= (unsigned long *) data
;
10957 /* The name is first.
10958 The CRC value is stored after the filename, aligned up to 4 bytes. */
10959 name
= (const char *) section
->start
;
10961 crc_offset
= strnlen (name
, section
->size
) + 1;
10962 crc_offset
= (crc_offset
+ 3) & ~3;
10963 if (crc_offset
+ 4 > section
->size
)
10966 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10971 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10973 void * sep_data
= open_debug_file (filename
);
10975 if (sep_data
== NULL
)
10978 /* FIXME: We should now extract the build-id in the separate file
10984 typedef struct build_id_data
10987 const unsigned char * data
;
10990 static const char *
10991 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10994 bfd_size_type namelen
;
10995 bfd_size_type id_len
;
10996 Build_id_data
* build_id_data
;
10998 /* The name is first.
10999 The build-id follows immediately, with no padding, up to the section's end. */
11001 name
= (const char *) section
->start
;
11002 namelen
= strnlen (name
, section
->size
) + 1;
11003 if (namelen
>= section
->size
)
11006 id_len
= section
->size
- namelen
;
11010 build_id_data
= (Build_id_data
*) data
;
11011 build_id_data
->len
= id_len
;
11012 build_id_data
->data
= section
->start
+ namelen
;
11018 add_separate_debug_file (const char * filename
, void * handle
)
11020 separate_info
* i
= xmalloc (sizeof * i
);
11022 i
->filename
= filename
;
11023 i
->handle
= handle
;
11024 i
->next
= first_separate_info
;
11025 first_separate_info
= i
;
11028 #if HAVE_LIBDEBUGINFOD
11029 /* Query debuginfod servers for the target debuglink or debugaltlink
11030 file. If successful, store the path of the file in filename and
11031 return TRUE, otherwise return FALSE. */
11034 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
11038 size_t build_id_len
;
11039 unsigned char * build_id
;
11041 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
11043 /* Get the build-id of file. */
11044 build_id
= get_build_id (file
);
11047 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
11049 /* Get the build-id of the debugaltlink file. */
11050 unsigned int filelen
;
11052 filelen
= strnlen ((const char *)section
->start
, section
->size
);
11053 if (filelen
== section
->size
)
11054 /* Corrupt debugaltlink. */
11057 build_id
= section
->start
+ filelen
+ 1;
11058 build_id_len
= section
->size
- (filelen
+ 1);
11060 if (build_id_len
== 0)
11069 debuginfod_client
* client
;
11071 client
= debuginfod_begin ();
11072 if (client
== NULL
)
11075 /* Query debuginfod servers for the target file. If found its path
11076 will be stored in filename. */
11077 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
11078 debuginfod_end (client
);
11080 /* Only free build_id if we allocated space for a hex string
11081 in get_build_id (). */
11082 if (build_id_len
== 0)
11087 /* File successfully retrieved. Close fd since we want to
11088 use open_debug_file () on filename instead. */
11099 load_separate_debug_info (const char * main_filename
,
11100 struct dwarf_section
* xlink
,
11101 parse_func_type parse_func
,
11102 check_func_type check_func
,
11104 void * file ATTRIBUTE_UNUSED
)
11106 const char * separate_filename
;
11107 char * debug_filename
;
11109 size_t canon_dirlen
;
11112 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11114 warn (_("Corrupt debuglink section: %s\n"),
11115 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11119 /* Attempt to locate the separate file.
11120 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11122 canon_dir
= lrealpath (main_filename
);
11124 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11125 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11127 canon_dir
[canon_dirlen
] = '\0';
11130 #define DEBUGDIR "/lib/debug"
11132 #ifndef EXTRA_DEBUG_ROOT1
11133 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11135 #ifndef EXTRA_DEBUG_ROOT2
11136 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11139 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11141 + strlen (".debug/")
11142 #ifdef EXTRA_DEBUG_ROOT1
11143 + strlen (EXTRA_DEBUG_ROOT1
)
11145 #ifdef EXTRA_DEBUG_ROOT2
11146 + strlen (EXTRA_DEBUG_ROOT2
)
11148 + strlen (separate_filename
)
11150 if (debug_filename
== NULL
)
11152 warn (_("Out of memory"));
11157 /* First try in the current directory. */
11158 sprintf (debug_filename
, "%s", separate_filename
);
11159 if (check_func (debug_filename
, func_data
))
11162 /* Then try in a subdirectory called .debug. */
11163 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11164 if (check_func (debug_filename
, func_data
))
11167 /* Then try in the same directory as the original file. */
11168 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11169 if (check_func (debug_filename
, func_data
))
11172 /* And the .debug subdirectory of that directory. */
11173 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11174 if (check_func (debug_filename
, func_data
))
11177 #ifdef EXTRA_DEBUG_ROOT1
11178 /* Try the first extra debug file root. */
11179 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11180 if (check_func (debug_filename
, func_data
))
11183 /* Try the first extra debug file root. */
11184 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11185 if (check_func (debug_filename
, func_data
))
11189 #ifdef EXTRA_DEBUG_ROOT2
11190 /* Try the second extra debug file root. */
11191 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11192 if (check_func (debug_filename
, func_data
))
11196 /* Then try in the global debug_filename directory. */
11197 strcpy (debug_filename
, DEBUGDIR
);
11198 dirlen
= strlen (DEBUGDIR
) - 1;
11199 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11200 strcat (debug_filename
, "/");
11201 strcat (debug_filename
, (const char *) separate_filename
);
11203 if (check_func (debug_filename
, func_data
))
11206 #if HAVE_LIBDEBUGINFOD
11208 char * tmp_filename
;
11210 if (debuginfod_fetch_separate_debug_info (xlink
,
11214 /* File successfully downloaded from server, replace
11215 debug_filename with the file's path. */
11216 free (debug_filename
);
11217 debug_filename
= tmp_filename
;
11223 if (do_debug_links
)
11225 /* Failed to find the file. */
11226 warn (_("could not find separate debug file '%s'\n"),
11227 separate_filename
);
11228 warn (_("tried: %s\n"), debug_filename
);
11230 #ifdef EXTRA_DEBUG_ROOT2
11231 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11232 separate_filename
);
11233 warn (_("tried: %s\n"), debug_filename
);
11236 #ifdef EXTRA_DEBUG_ROOT1
11237 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11238 canon_dir
, separate_filename
);
11239 warn (_("tried: %s\n"), debug_filename
);
11241 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11242 separate_filename
);
11243 warn (_("tried: %s\n"), debug_filename
);
11246 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11247 separate_filename
);
11248 warn (_("tried: %s\n"), debug_filename
);
11250 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11251 warn (_("tried: %s\n"), debug_filename
);
11253 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11254 warn (_("tried: %s\n"), debug_filename
);
11256 sprintf (debug_filename
, "%s", separate_filename
);
11257 warn (_("tried: %s\n"), debug_filename
);
11259 #if HAVE_LIBDEBUGINFOD
11261 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11265 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11271 free (debug_filename
);
11277 void * debug_handle
;
11279 /* Now open the file.... */
11280 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11282 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11283 free (debug_filename
);
11287 /* FIXME: We do not check to see if there are any other separate debug info
11288 files that would also match. */
11290 if (do_debug_links
)
11291 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11292 add_separate_debug_file (debug_filename
, debug_handle
);
11294 /* Do not free debug_filename - it might be referenced inside
11295 the structure returned by open_debug_file(). */
11296 return debug_handle
;
11299 /* Attempt to load a separate dwarf object file. */
11302 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11304 char * separate_filename
;
11305 void * separate_handle
;
11307 if (IS_ABSOLUTE_PATH (name
))
11308 separate_filename
= strdup (name
);
11310 /* FIXME: Skip adding / if dwo_dir ends in /. */
11311 separate_filename
= concat (dir
, "/", name
, NULL
);
11312 if (separate_filename
== NULL
)
11314 warn (_("Out of memory allocating dwo filename\n"));
11318 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11320 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11321 free (separate_filename
);
11325 /* FIXME: We should check the dwo_id. */
11327 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11328 add_separate_debug_file (separate_filename
, separate_handle
);
11329 /* Note - separate_filename will be freed in free_debug_memory(). */
11330 return separate_handle
;
11334 load_debug_sup_file (const char * main_filename
, void * file
)
11336 if (! load_debug_section (debug_sup
, file
))
11337 return; /* No .debug_sup section. */
11339 struct dwarf_section
* section
;
11340 section
= & debug_displays
[debug_sup
].section
;
11341 assert (section
!= NULL
);
11343 if (section
->start
== NULL
|| section
->size
< 5)
11345 warn (_(".debug_sup section is corrupt/empty\n"));
11349 if (section
->start
[2] != 0)
11350 return; /* This is a supplementary file. */
11352 const char * filename
= (const char *) section
->start
+ 3;
11353 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11355 warn (_("filename in .debug_sup section is corrupt\n"));
11359 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11362 if (asprintf (& new_name
, "%.*s/%s",
11363 (int) (strrchr (main_filename
, '/') - main_filename
),
11366 warn (_("unable to construct path for supplementary debug file"));
11368 filename
= new_name
;
11372 handle
= open_debug_file (filename
);
11373 if (handle
== NULL
)
11375 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11379 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11381 /* FIXME: Compare the checksums, if present. */
11382 add_separate_debug_file (filename
, handle
);
11385 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11386 Recursively check the loaded files for more of these sections.
11387 Also follow any links in .debug_sup sections.
11388 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11391 check_for_and_load_links (void * file
, const char * filename
)
11393 void * handle
= NULL
;
11395 if (load_debug_section (gnu_debugaltlink
, file
))
11397 Build_id_data build_id_data
;
11399 handle
= load_separate_debug_info (filename
,
11400 & debug_displays
[gnu_debugaltlink
].section
,
11401 parse_gnu_debugaltlink
,
11402 check_gnu_debugaltlink
,
11407 assert (handle
== first_separate_info
->handle
);
11408 check_for_and_load_links (first_separate_info
->handle
,
11409 first_separate_info
->filename
);
11413 if (load_debug_section (gnu_debuglink
, file
))
11415 unsigned long crc32
;
11417 handle
= load_separate_debug_info (filename
,
11418 & debug_displays
[gnu_debuglink
].section
,
11419 parse_gnu_debuglink
,
11420 check_gnu_debuglink
,
11425 assert (handle
== first_separate_info
->handle
);
11426 check_for_and_load_links (first_separate_info
->handle
,
11427 first_separate_info
->filename
);
11431 load_debug_sup_file (filename
, file
);
11434 /* Load the separate debug info file(s) attached to FILE, if any exist.
11435 Returns TRUE if any were found, FALSE otherwise.
11436 If TRUE is returned then the linked list starting at first_separate_info
11437 will be populated with open file handles. */
11440 load_separate_debug_files (void * file
, const char * filename
)
11442 /* Skip this operation if we are not interested in debug links. */
11443 if (! do_follow_links
&& ! do_debug_links
)
11446 /* See if there are any dwo links. */
11447 if (load_debug_section (str
, file
)
11448 && load_debug_section (abbrev
, file
)
11449 && load_debug_section (info
, file
))
11453 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11456 bfd_boolean introduced
= FALSE
;
11458 const char * dir
= NULL
;
11459 const char * id
= NULL
;
11460 const char * name
= NULL
;
11462 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11464 /* Accumulate NAME, DIR and ID fields. */
11465 switch (dwinfo
->type
)
11469 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11470 name
= dwinfo
->value
;
11474 /* There can be multiple DW_AT_comp_dir entries in a CU,
11475 so do not complain. */
11476 dir
= dwinfo
->value
;
11481 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11482 id
= dwinfo
->value
;
11486 error (_("Unexpected DWO INFO type"));
11490 /* If we have reached the end of our list, or we are changing
11491 CUs, then display the information that we have accumulated
11494 && (dwinfo
->next
== NULL
11495 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11497 if (do_debug_links
)
11501 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11502 debug_displays
[info
].section
.uncompressed_name
);
11506 printf (_(" Name: %s\n"), name
);
11507 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11509 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11511 printf (_(" ID: <not specified>\n"));
11515 if (do_follow_links
)
11516 load_dwo_file (filename
, name
, dir
, id
);
11518 name
= dir
= id
= NULL
;
11524 if (! do_follow_links
)
11525 /* The other debug links will be displayed by display_debug_links()
11526 so we do not need to do any further processing here. */
11529 /* FIXME: We do not check for the presence of both link sections in the same file. */
11530 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11531 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11533 check_for_and_load_links (file
, filename
);
11534 if (first_separate_info
!= NULL
)
11537 do_follow_links
= 0;
11542 free_debug_memory (void)
11546 free_all_abbrevs ();
11548 free (cu_abbrev_map
);
11549 cu_abbrev_map
= NULL
;
11550 next_free_abbrev_map_entry
= 0;
11554 shndx_pool_size
= 0;
11555 shndx_pool_used
= 0;
11563 memset (level_type_signed
, 0, sizeof level_type_signed
);
11564 cu_tu_indexes_read
= -1;
11566 for (i
= 0; i
< max
; i
++)
11567 free_debug_section ((enum dwarf_section_display_enum
) i
);
11569 if (debug_information
!= NULL
)
11571 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11573 if (debug_information
[i
].max_loc_offsets
)
11575 free (debug_information
[i
].loc_offsets
);
11576 free (debug_information
[i
].have_frame_base
);
11578 if (debug_information
[i
].max_range_lists
)
11579 free (debug_information
[i
].range_lists
);
11581 free (debug_information
);
11582 debug_information
= NULL
;
11583 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11587 separate_info
* next
;
11589 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11591 close_debug_file (d
->handle
);
11592 free ((void *) d
->filename
);
11596 first_separate_info
= NULL
;
11602 dwarf_select_sections_by_names (const char *names
)
11606 const char * option
;
11610 debug_dump_long_opts
;
11612 static const debug_dump_long_opts opts_table
[] =
11614 /* Please keep this table alpha- sorted. */
11615 { "Ranges", & do_debug_ranges
, 1 },
11616 { "abbrev", & do_debug_abbrevs
, 1 },
11617 { "addr", & do_debug_addr
, 1 },
11618 { "aranges", & do_debug_aranges
, 1 },
11619 { "cu_index", & do_debug_cu_index
, 1 },
11620 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11621 { "follow-links", & do_follow_links
, 1 },
11622 { "frames", & do_debug_frames
, 1 },
11623 { "frames-interp", & do_debug_frames_interp
, 1 },
11624 /* The special .gdb_index section. */
11625 { "gdb_index", & do_gdb_index
, 1 },
11626 { "info", & do_debug_info
, 1 },
11627 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11628 { "links", & do_debug_links
, 1 },
11629 { "loc", & do_debug_loc
, 1 },
11630 { "macro", & do_debug_macinfo
, 1 },
11631 { "no-follow-links", & do_follow_links
, 0 },
11632 { "pubnames", & do_debug_pubnames
, 1 },
11633 { "pubtypes", & do_debug_pubtypes
, 1 },
11634 /* This entry is for compatibility
11635 with earlier versions of readelf. */
11636 { "ranges", & do_debug_aranges
, 1 },
11637 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11638 { "str", & do_debug_str
, 1 },
11639 { "str-offsets", & do_debug_str_offsets
, 1 },
11640 /* These trace_* sections are used by Itanium VMS. */
11641 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11642 { "trace_aranges", & do_trace_aranges
, 1 },
11643 { "trace_info", & do_trace_info
, 1 },
11652 const debug_dump_long_opts
* entry
;
11654 for (entry
= opts_table
; entry
->option
; entry
++)
11656 size_t len
= strlen (entry
->option
);
11658 if (strncmp (p
, entry
->option
, len
) == 0
11659 && (p
[len
] == ',' || p
[len
] == '\0'))
11661 * entry
->variable
= entry
->val
;
11663 /* The --debug-dump=frames-interp option also
11664 enables the --debug-dump=frames option. */
11665 if (do_debug_frames_interp
)
11666 do_debug_frames
= 1;
11673 if (entry
->option
== NULL
)
11675 warn (_("Unrecognized debug option '%s'\n"), p
);
11676 p
= strchr (p
, ',');
11687 dwarf_select_sections_by_letters (const char *letters
)
11689 unsigned int lindex
= 0;
11691 while (letters
[lindex
])
11692 switch (letters
[lindex
++])
11694 case 'A': do_debug_addr
= 1; break;
11695 case 'a': do_debug_abbrevs
= 1; break;
11696 case 'c': do_debug_cu_index
= 1; break;
11697 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11698 case 'f': do_debug_frames
= 1; break;
11699 case 'g': do_gdb_index
= 1; break;
11700 case 'i': do_debug_info
= 1; break;
11701 case 'K': do_follow_links
= 1; break;
11702 case 'N': do_follow_links
= 0; break;
11703 case 'k': do_debug_links
= 1; break;
11704 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11705 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11706 case 'm': do_debug_macinfo
= 1; break;
11707 case 'O': do_debug_str_offsets
= 1; break;
11708 case 'o': do_debug_loc
= 1; break;
11709 case 'p': do_debug_pubnames
= 1; break;
11710 case 'R': do_debug_ranges
= 1; break;
11711 case 'r': do_debug_aranges
= 1; break;
11712 case 's': do_debug_str
= 1; break;
11713 case 'T': do_trace_aranges
= 1; break;
11714 case 't': do_debug_pubtypes
= 1; break;
11715 case 'U': do_trace_info
= 1; break;
11716 case 'u': do_trace_abbrevs
= 1; break;
11719 warn (_("Unrecognized debug option '%s'\n"), letters
);
11725 dwarf_select_sections_all (void)
11728 do_debug_abbrevs
= 1;
11729 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11730 do_debug_pubnames
= 1;
11731 do_debug_pubtypes
= 1;
11732 do_debug_aranges
= 1;
11733 do_debug_ranges
= 1;
11734 do_debug_frames
= 1;
11735 do_debug_macinfo
= 1;
11740 do_trace_abbrevs
= 1;
11741 do_trace_aranges
= 1;
11743 do_debug_cu_index
= 1;
11744 do_follow_links
= 1;
11745 do_debug_links
= 1;
11746 do_debug_str_offsets
= 1;
11749 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
11750 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
11752 /* N.B. The order here must match the order in section_display_enum. */
11754 struct dwarf_section_display debug_displays
[] =
11756 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
11757 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
11758 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
11759 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
11760 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
11761 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
11762 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
11763 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
11764 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
11765 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
11766 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11767 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11768 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11769 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11770 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
11771 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
11772 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
11773 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
11774 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11775 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11776 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
11777 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11778 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
11779 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
11780 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
11781 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
11782 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
11783 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
11784 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
11785 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
11786 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
11787 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11788 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
11789 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
11790 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
11791 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11792 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11793 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
11794 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11795 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11796 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11797 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11798 { { ".debug_sup", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, FALSE
},
11799 /* Separate debug info files can containt their own .debug_str section,
11800 and this might be in *addition* to a .debug_str section already present
11801 in the main file. Hence we need to have two entries for .debug_str. */
11802 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11805 /* A static assertion. */
11806 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];