1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2020 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"
24 #include "bfd_stdint.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>
41 #define MAX(a, b) ((a) > (b) ? (a) : (b))
42 #define MIN(a, b) ((a) < (b) ? (a) : (b))
44 static const char *regname (unsigned int regno
, int row
);
45 static const char *regname_internal_by_table_only (unsigned int regno
);
47 static int have_frame_base
;
48 static int need_base_address
;
50 static unsigned int num_debug_info_entries
= 0;
51 static unsigned int alloc_num_debug_info_entries
= 0;
52 static debug_info
*debug_information
= NULL
;
53 /* Special value for num_debug_info_entries to indicate
54 that the .debug_info section could not be loaded/parsed. */
55 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
57 /* A .debug_info section can contain multiple links to separate
58 DWO object files. We use these structures to record these links. */
66 typedef struct dwo_info
70 struct dwo_info
* next
;
73 static dwo_info
* first_dwo_info
= NULL
;
74 static bfd_boolean need_dwo_info
;
76 separate_info
* first_separate_info
= NULL
;
78 unsigned int eh_addr_size
;
83 int do_debug_pubnames
;
84 int do_debug_pubtypes
;
88 int do_debug_frames_interp
;
91 int do_debug_str_offsets
;
98 int do_debug_cu_index
;
102 bfd_boolean do_checks
;
104 int dwarf_cutoff_level
= -1;
105 unsigned long dwarf_start_die
;
109 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
110 testing whether e.g. a locview list is present. */
111 static const dwarf_vma vm1
= -1;
113 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
114 sections. For version 1 package files, each set is stored in SHNDX_POOL
115 as a zero-terminated list of section indexes comprising one set of debug
116 sections from a .dwo file. */
118 static unsigned int *shndx_pool
= NULL
;
119 static unsigned int shndx_pool_size
= 0;
120 static unsigned int shndx_pool_used
= 0;
122 /* For version 2 package files, each set contains an array of section offsets
123 and an array of section sizes, giving the offset and size of the
124 contribution from a CU or TU within one of the debug sections.
125 When displaying debug info from a package file, we need to use these
126 tables to locate the corresponding contributions to each section. */
131 dwarf_vma section_offsets
[DW_SECT_MAX
];
132 size_t section_sizes
[DW_SECT_MAX
];
135 static int cu_count
= 0;
136 static int tu_count
= 0;
137 static struct cu_tu_set
*cu_sets
= NULL
;
138 static struct cu_tu_set
*tu_sets
= NULL
;
140 static bfd_boolean
load_cu_tu_indexes (void *);
142 /* An array that indicates for a given level of CU nesting whether
143 the latest DW_AT_type seen for that level was a signed type or
145 #define MAX_CU_NESTING (1 << 8)
146 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
148 /* Values for do_debug_lines. */
149 #define FLAG_DEBUG_LINES_RAW 1
150 #define FLAG_DEBUG_LINES_DECODED 2
153 size_of_encoded_value (int encoding
)
155 switch (encoding
& 0x7)
158 case 0: return eh_addr_size
;
166 get_encoded_value (unsigned char **pdata
,
168 struct dwarf_section
*section
,
171 unsigned char * data
= * pdata
;
172 unsigned int size
= size_of_encoded_value (encoding
);
175 if (data
+ size
>= end
)
177 warn (_("Encoded value extends past end of section\n"));
182 /* PR 17512: file: 002-829853-0.004. */
185 warn (_("Encoded size of %d is too large to read\n"), size
);
190 /* PR 17512: file: 1085-5603-0.004. */
193 warn (_("Encoded size of 0 is too small to read\n"));
198 if (encoding
& DW_EH_PE_signed
)
199 val
= byte_get_signed (data
, size
);
201 val
= byte_get (data
, size
);
203 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
204 val
+= section
->address
+ (data
- section
->start
);
206 * pdata
= data
+ size
;
210 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
212 # define DWARF_VMA_FMT "ll"
213 # define DWARF_VMA_FMT_LONG "%16.16llx"
215 # define DWARF_VMA_FMT "I64"
216 # define DWARF_VMA_FMT_LONG "%016I64x"
219 # define DWARF_VMA_FMT "l"
220 # define DWARF_VMA_FMT_LONG "%16.16lx"
223 /* Convert a dwarf vma value into a string. Returns a pointer to a static
224 buffer containing the converted VALUE. The value is converted according
225 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
226 it specifies the maximum number of bytes to be displayed in the converted
227 value and FMTCH is ignored - hex is always used. */
230 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
232 /* As dwarf_vmatoa is used more then once in a printf call
233 for output, we are cycling through an fixed array of pointers
234 for return address. */
235 static int buf_pos
= 0;
236 static struct dwarf_vmatoa_buf
242 ret
= buf
[buf_pos
++].place
;
243 buf_pos
%= ARRAY_SIZE (buf
);
247 /* Printf does not have a way of specifying a maximum field width for an
248 integer value, so we print the full value into a buffer and then select
249 the precision we need. */
250 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
253 return ret
+ (16 - 2 * num_bytes
);
260 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
262 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
263 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
268 static inline const char *
269 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
271 return dwarf_vmatoa_1 (fmtch
, value
, 0);
274 /* Print a dwarf_vma value (typically an address, offset or length) in
275 hexadecimal format, followed by a space. The length of the VALUE (and
276 hence the precision displayed) is determined by the NUM_BYTES parameter. */
279 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
281 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
284 /* Print a view number in hexadecimal value, with the same width
285 print_dwarf_vma would have printed it with the same num_bytes.
286 Print blanks for zero view, unless force is nonzero. */
289 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
297 assert (value
== (unsigned long) value
);
299 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
301 printf ("%*s", len
+ 1, "");
304 /* Format a 64-bit value, given as two 32-bit values, in hex.
305 For reentrancy, this uses a buffer provided by the caller. */
308 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
309 unsigned int buf_len
)
314 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
317 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
318 snprintf (buf
+ len
, buf_len
- len
,
319 "%08" DWARF_VMA_FMT
"x", lvalue
);
325 /* Read in a LEB128 encoded value starting at address DATA.
326 If SIGN is true, return a signed LEB128 value.
327 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
328 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
329 terminating byte was not found and with bit 1 set if the value
330 overflows a dwarf_vma.
331 No bytes will be read at address END or beyond. */
334 read_leb128 (unsigned char *data
,
335 const unsigned char *const end
,
337 unsigned int *length_return
,
340 dwarf_vma result
= 0;
341 unsigned int num_read
= 0;
342 unsigned int shift
= 0;
347 unsigned char byte
= *data
++;
350 if (shift
< sizeof (result
) * 8)
352 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
353 if ((result
>> shift
) != (byte
& 0x7f))
358 else if ((byte
& 0x7f) != 0)
361 if ((byte
& 0x80) == 0)
364 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
365 result
|= -((dwarf_vma
) 1 << shift
);
370 if (length_return
!= NULL
)
371 *length_return
= num_read
;
372 if (status_return
!= NULL
)
373 *status_return
= status
;
378 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
379 Checks to make sure that the read will not reach or pass END
380 and that VAL is big enough to hold AMOUNT bytes. */
381 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
384 unsigned int amount = (AMOUNT); \
385 if (sizeof (VAL) < amount) \
387 error (ngettext ("internal error: attempt to read %d byte " \
388 "of data in to %d sized variable", \
389 "internal error: attempt to read %d bytes " \
390 "of data in to %d sized variable", \
392 amount, (int) sizeof (VAL)); \
393 amount = sizeof (VAL); \
395 if (((PTR) + amount) >= (END)) \
398 amount = (END) - (PTR); \
402 if (amount == 0 || amount > 8) \
405 VAL = byte_get ((PTR), amount); \
409 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
410 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
413 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
418 /* Like SAFE_BYTE_GET, but reads a signed value. */
419 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
422 unsigned int amount = (AMOUNT); \
423 if (((PTR) + amount) >= (END)) \
426 amount = (END) - (PTR); \
431 VAL = byte_get_signed ((PTR), amount); \
437 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
438 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
441 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
446 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
449 if (((PTR) + 8) <= (END)) \
451 byte_get_64 ((PTR), (HIGH), (LOW)); \
455 * (LOW) = * (HIGH) = 0; \
460 typedef struct State_Machine_Registers
469 unsigned char op_index
;
470 unsigned char end_sequence
;
471 /* This variable hold the number of the last entry seen
472 in the File Table. */
473 unsigned int last_file_entry
;
476 static SMR state_machine_regs
;
479 reset_state_machine (int is_stmt
)
481 state_machine_regs
.address
= 0;
482 state_machine_regs
.view
= 0;
483 state_machine_regs
.op_index
= 0;
484 state_machine_regs
.file
= 1;
485 state_machine_regs
.line
= 1;
486 state_machine_regs
.column
= 0;
487 state_machine_regs
.is_stmt
= is_stmt
;
488 state_machine_regs
.basic_block
= 0;
489 state_machine_regs
.end_sequence
= 0;
490 state_machine_regs
.last_file_entry
= 0;
493 /* Handled an extend line op.
494 Returns the number of bytes read. */
497 process_extended_line_op (unsigned char * data
,
501 unsigned char op_code
;
502 size_t len
, header_len
;
504 unsigned char *orig_data
= data
;
507 READ_ULEB (len
, data
, end
);
508 header_len
= data
- orig_data
;
510 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
512 warn (_("Badly formed extended line op encountered!\n"));
518 printf (_(" Extended opcode %d: "), op_code
);
522 case DW_LNE_end_sequence
:
523 printf (_("End of Sequence\n\n"));
524 reset_state_machine (is_stmt
);
527 case DW_LNE_set_address
:
528 /* PR 17512: file: 002-100480-0.004. */
531 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
532 (unsigned long) len
- 1);
536 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
537 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
538 state_machine_regs
.address
= adr
;
539 state_machine_regs
.view
= 0;
540 state_machine_regs
.op_index
= 0;
543 case DW_LNE_define_file
:
544 printf (_("define new File Table entry\n"));
545 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
546 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
552 l
= strnlen ((char *) data
, end
- data
);
554 READ_ULEB (val
, data
, end
);
555 printf ("%s\t", dwarf_vmatoa ("u", val
));
556 READ_ULEB (val
, data
, end
);
557 printf ("%s\t", dwarf_vmatoa ("u", val
));
558 READ_ULEB (val
, data
, end
);
559 printf ("%s\t", dwarf_vmatoa ("u", val
));
560 printf ("%.*s\n\n", (int) l
, name
);
563 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
564 warn (_("DW_LNE_define_file: Bad opcode length\n"));
567 case DW_LNE_set_discriminator
:
568 READ_ULEB (val
, data
, end
);
569 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
573 case DW_LNE_HP_negate_is_UV_update
:
574 printf ("DW_LNE_HP_negate_is_UV_update\n");
576 case DW_LNE_HP_push_context
:
577 printf ("DW_LNE_HP_push_context\n");
579 case DW_LNE_HP_pop_context
:
580 printf ("DW_LNE_HP_pop_context\n");
582 case DW_LNE_HP_set_file_line_column
:
583 printf ("DW_LNE_HP_set_file_line_column\n");
585 case DW_LNE_HP_set_routine_name
:
586 printf ("DW_LNE_HP_set_routine_name\n");
588 case DW_LNE_HP_set_sequence
:
589 printf ("DW_LNE_HP_set_sequence\n");
591 case DW_LNE_HP_negate_post_semantics
:
592 printf ("DW_LNE_HP_negate_post_semantics\n");
594 case DW_LNE_HP_negate_function_exit
:
595 printf ("DW_LNE_HP_negate_function_exit\n");
597 case DW_LNE_HP_negate_front_end_logical
:
598 printf ("DW_LNE_HP_negate_front_end_logical\n");
600 case DW_LNE_HP_define_proc
:
601 printf ("DW_LNE_HP_define_proc\n");
603 case DW_LNE_HP_source_file_correlation
:
605 unsigned char *edata
= data
+ len
- 1;
607 printf ("DW_LNE_HP_source_file_correlation\n");
613 READ_ULEB (opc
, data
, edata
);
617 case DW_LNE_HP_SFC_formfeed
:
618 printf (" DW_LNE_HP_SFC_formfeed\n");
620 case DW_LNE_HP_SFC_set_listing_line
:
621 READ_ULEB (val
, data
, edata
);
622 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
623 dwarf_vmatoa ("u", val
));
625 case DW_LNE_HP_SFC_associate
:
626 printf (" DW_LNE_HP_SFC_associate ");
627 READ_ULEB (val
, data
, edata
);
628 printf ("(%s", dwarf_vmatoa ("u", val
));
629 READ_ULEB (val
, data
, edata
);
630 printf (",%s", dwarf_vmatoa ("u", val
));
631 READ_ULEB (val
, data
, edata
);
632 printf (",%s)\n", dwarf_vmatoa ("u", val
));
635 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
645 unsigned int rlen
= len
- 1;
647 if (op_code
>= DW_LNE_lo_user
648 /* The test against DW_LNW_hi_user is redundant due to
649 the limited range of the unsigned char data type used
651 /*&& op_code <= DW_LNE_hi_user*/)
652 printf (_("user defined: "));
654 printf (_("UNKNOWN: "));
655 printf (_("length %d ["), rlen
);
657 printf (" %02x", *data
++);
663 return len
+ header_len
;
666 static const unsigned char *
667 fetch_indirect_string (dwarf_vma offset
)
669 struct dwarf_section
*section
= &debug_displays
[str
].section
;
670 const unsigned char * ret
;
672 if (section
->start
== NULL
)
673 return (const unsigned char *) _("<no .debug_str section>");
675 if (offset
>= section
->size
)
677 warn (_("DW_FORM_strp offset too big: %s\n"),
678 dwarf_vmatoa ("x", offset
));
679 return (const unsigned char *) _("<offset is too big>");
682 ret
= section
->start
+ offset
;
683 /* Unfortunately we cannot rely upon the .debug_str section ending with a
684 NUL byte. Since our caller is expecting to receive a well formed C
685 string we test for the lack of a terminating byte here. */
686 if (strnlen ((const char *) ret
, section
->size
- offset
)
687 == section
->size
- offset
)
688 ret
= (const unsigned char *)
689 _("<no NUL byte at end of .debug_str section>");
694 static const unsigned char *
695 fetch_indirect_line_string (dwarf_vma offset
)
697 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
698 const unsigned char * ret
;
700 if (section
->start
== NULL
)
701 return (const unsigned char *) _("<no .debug_line_str section>");
703 if (offset
>= section
->size
)
705 warn (_("DW_FORM_line_strp offset too big: %s\n"),
706 dwarf_vmatoa ("x", offset
));
707 return (const unsigned char *) _("<offset is too big>");
710 ret
= section
->start
+ offset
;
711 /* Unfortunately we cannot rely upon the .debug_line_str section ending
712 with a NUL byte. Since our caller is expecting to receive a well formed
713 C string we test for the lack of a terminating byte here. */
714 if (strnlen ((const char *) ret
, section
->size
- offset
)
715 == section
->size
- offset
)
716 ret
= (const unsigned char *)
717 _("<no NUL byte at end of .debug_line_str section>");
723 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
724 dwarf_vma offset_size
, bfd_boolean dwo
)
726 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
727 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
728 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
729 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
730 dwarf_vma index_offset
;
731 dwarf_vma str_offset
;
733 unsigned char *curr
= index_section
->start
;
734 const unsigned char *end
= curr
+ index_section
->size
;
737 if (index_section
->start
== NULL
)
738 return (dwo
? _("<no .debug_str_offsets.dwo section>")
739 : _("<no .debug_str_offsets section>"));
741 if (str_section
->start
== NULL
)
742 return (dwo
? _("<no .debug_str.dwo section>")
743 : _("<no .debug_str section>"));
745 /* FIXME: We should cache the length... */
746 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
747 if (length
== 0xffffffff)
749 if (offset_size
!= 8)
750 warn (_("Expected offset size of 8 but given %s"), dwarf_vmatoa ("x", offset_size
));
751 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
753 else if (offset_size
!= 4)
755 warn (_("Expected offset size of 4 but given %s"), dwarf_vmatoa ("x", offset_size
));
760 /* This is probably an old style .debug_str_offset section which
761 just contains offsets and no header (and the first offset is 0). */
762 curr
= index_section
->start
;
763 length
= index_section
->size
;
767 /* Skip the version and padding bytes.
768 We assume that they are correct. */
771 /* FIXME: The code below assumes that there is only one table
772 in the .debug_str_offsets section, so check that now. */
773 if ((offset_size
== 4 && curr
+ length
< (end
- 8))
774 || (offset_size
== 8 && curr
+ length
< (end
- 16)))
776 warn (_("index table size is too small %s vs %s\n"),
777 dwarf_vmatoa ("x", length
),
778 dwarf_vmatoa ("x", index_section
->size
));
779 return _("<table too small>");
783 index_offset
= idx
* offset_size
;
785 if (this_set
!= NULL
)
786 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
788 if (index_offset
>= length
)
790 warn (_("DW_FORM_GNU_str_index offset too big: %s vs %s\n"),
791 dwarf_vmatoa ("x", index_offset
),
792 dwarf_vmatoa ("x", length
));
793 return _("<index offset is too big>");
796 str_offset
= byte_get (curr
+ index_offset
, offset_size
);
797 str_offset
-= str_section
->address
;
798 if (str_offset
>= str_section
->size
)
800 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
801 dwarf_vmatoa ("x", str_offset
));
802 return _("<indirect index offset is too big>");
805 ret
= (const char *) str_section
->start
+ str_offset
;
806 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
807 Since our caller is expecting to receive a well formed C string we test
808 for the lack of a terminating byte here. */
809 if (strnlen (ret
, str_section
->size
- str_offset
)
810 == str_section
->size
- str_offset
)
811 ret
= (const char *) _("<no NUL byte at end of section>");
817 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
819 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
821 if (section
->start
== NULL
)
822 return (_("<no .debug_addr section>"));
824 if (offset
+ bytes
> section
->size
)
826 warn (_("Offset into section %s too big: %s\n"),
827 section
->name
, dwarf_vmatoa ("x", offset
));
828 return "<offset too big>";
831 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
835 /* FIXME: There are better and more efficient ways to handle
836 these structures. For now though, I just want something that
837 is simple to implement. */
838 typedef struct abbrev_attr
840 unsigned long attribute
;
842 bfd_signed_vma implicit_const
;
843 struct abbrev_attr
*next
;
847 typedef struct abbrev_entry
852 struct abbrev_attr
*first_attr
;
853 struct abbrev_attr
*last_attr
;
854 struct abbrev_entry
*next
;
858 static abbrev_entry
*first_abbrev
= NULL
;
859 static abbrev_entry
*last_abbrev
= NULL
;
866 for (abbrv
= first_abbrev
; abbrv
;)
868 abbrev_entry
*next_abbrev
= abbrv
->next
;
871 for (attr
= abbrv
->first_attr
; attr
;)
873 abbrev_attr
*next_attr
= attr
->next
;
883 last_abbrev
= first_abbrev
= NULL
;
887 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
891 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
896 entry
->entry
= number
;
898 entry
->children
= children
;
899 entry
->first_attr
= NULL
;
900 entry
->last_attr
= NULL
;
903 if (first_abbrev
== NULL
)
904 first_abbrev
= entry
;
906 last_abbrev
->next
= entry
;
912 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
913 bfd_signed_vma implicit_const
)
917 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
922 attr
->attribute
= attribute
;
924 attr
->implicit_const
= implicit_const
;
927 if (last_abbrev
->first_attr
== NULL
)
928 last_abbrev
->first_attr
= attr
;
930 last_abbrev
->last_attr
->next
= attr
;
932 last_abbrev
->last_attr
= attr
;
935 /* Processes the (partial) contents of a .debug_abbrev section.
936 Returns NULL if the end of the section was encountered.
937 Returns the address after the last byte read if the end of
938 an abbreviation set was found. */
940 static unsigned char *
941 process_abbrev_section (unsigned char *start
, unsigned char *end
)
943 if (first_abbrev
!= NULL
)
950 unsigned long attribute
;
953 READ_ULEB (entry
, start
, end
);
955 /* A single zero is supposed to end the section according
956 to the standard. If there's more, then signal that to
963 READ_ULEB (tag
, start
, end
);
969 add_abbrev (entry
, tag
, children
);
974 /* Initialize it due to a false compiler warning. */
975 bfd_signed_vma implicit_const
= -1;
977 READ_ULEB (attribute
, start
, end
);
981 READ_ULEB (form
, start
, end
);
985 if (form
== DW_FORM_implicit_const
)
987 READ_SLEB (implicit_const
, start
, end
);
992 add_abbrev_attr (attribute
, form
, implicit_const
);
994 while (attribute
!= 0);
997 /* Report the missing single zero which ends the section. */
998 error (_(".debug_abbrev section not zero terminated\n"));
1004 get_TAG_name (unsigned long tag
)
1006 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
1010 static char buffer
[100];
1012 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1013 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
1015 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1023 get_FORM_name (unsigned long form
)
1028 return "DW_FORM value: 0";
1030 name
= get_DW_FORM_name (form
);
1033 static char buffer
[100];
1035 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1043 get_IDX_name (unsigned long idx
)
1045 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1049 static char buffer
[100];
1051 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1058 static unsigned char *
1059 display_block (unsigned char *data
,
1061 const unsigned char * const end
, char delimiter
)
1065 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1067 return (unsigned char *) end
;
1069 maxlen
= (dwarf_vma
) (end
- data
);
1070 length
= length
> maxlen
? maxlen
: length
;
1073 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1079 decode_location_expression (unsigned char * data
,
1080 unsigned int pointer_size
,
1081 unsigned int offset_size
,
1084 dwarf_vma cu_offset
,
1085 struct dwarf_section
* section
)
1089 dwarf_signed_vma svalue
;
1090 unsigned char *end
= data
+ length
;
1091 int need_frame_base
= 0;
1100 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1101 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1104 printf ("DW_OP_deref");
1107 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1108 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1111 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1112 printf ("DW_OP_const1s: %ld", (long) svalue
);
1115 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1116 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1119 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1120 printf ("DW_OP_const2s: %ld", (long) svalue
);
1123 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1124 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1127 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1128 printf ("DW_OP_const4s: %ld", (long) svalue
);
1131 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1132 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1133 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1134 printf ("%lu", (unsigned long) uvalue
);
1137 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1138 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1139 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1140 printf ("%ld", (long) svalue
);
1143 READ_ULEB (uvalue
, data
, end
);
1144 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1147 READ_SLEB (svalue
, data
, end
);
1148 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1151 printf ("DW_OP_dup");
1154 printf ("DW_OP_drop");
1157 printf ("DW_OP_over");
1160 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1161 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1164 printf ("DW_OP_swap");
1167 printf ("DW_OP_rot");
1170 printf ("DW_OP_xderef");
1173 printf ("DW_OP_abs");
1176 printf ("DW_OP_and");
1179 printf ("DW_OP_div");
1182 printf ("DW_OP_minus");
1185 printf ("DW_OP_mod");
1188 printf ("DW_OP_mul");
1191 printf ("DW_OP_neg");
1194 printf ("DW_OP_not");
1197 printf ("DW_OP_or");
1200 printf ("DW_OP_plus");
1202 case DW_OP_plus_uconst
:
1203 READ_ULEB (uvalue
, data
, end
);
1204 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1207 printf ("DW_OP_shl");
1210 printf ("DW_OP_shr");
1213 printf ("DW_OP_shra");
1216 printf ("DW_OP_xor");
1219 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1220 printf ("DW_OP_bra: %ld", (long) svalue
);
1223 printf ("DW_OP_eq");
1226 printf ("DW_OP_ge");
1229 printf ("DW_OP_gt");
1232 printf ("DW_OP_le");
1235 printf ("DW_OP_lt");
1238 printf ("DW_OP_ne");
1241 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1242 printf ("DW_OP_skip: %ld", (long) svalue
);
1277 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1312 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1313 regname (op
- DW_OP_reg0
, 1));
1348 READ_SLEB (svalue
, data
, end
);
1349 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1350 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1354 READ_ULEB (uvalue
, data
, end
);
1355 printf ("DW_OP_regx: %s (%s)",
1356 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1359 need_frame_base
= 1;
1360 READ_SLEB (svalue
, data
, end
);
1361 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1364 READ_ULEB (uvalue
, data
, end
);
1365 READ_SLEB (svalue
, data
, end
);
1366 printf ("DW_OP_bregx: %s (%s) %s",
1367 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1368 dwarf_vmatoa ("d", svalue
));
1371 READ_ULEB (uvalue
, data
, end
);
1372 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1374 case DW_OP_deref_size
:
1375 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1376 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1378 case DW_OP_xderef_size
:
1379 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1380 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1383 printf ("DW_OP_nop");
1386 /* DWARF 3 extensions. */
1387 case DW_OP_push_object_address
:
1388 printf ("DW_OP_push_object_address");
1391 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1392 this ought to be an 8-byte wide computation. */
1393 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1394 printf ("DW_OP_call2: <0x%s>",
1395 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1398 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1399 this ought to be an 8-byte wide computation. */
1400 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1401 printf ("DW_OP_call4: <0x%s>",
1402 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1404 case DW_OP_call_ref
:
1405 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1406 this ought to be an 8-byte wide computation. */
1407 if (dwarf_version
== -1)
1409 printf (_("(DW_OP_call_ref in frame info)"));
1410 /* No way to tell where the next op is, so just bail. */
1411 return need_frame_base
;
1413 if (dwarf_version
== 2)
1415 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1419 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1421 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1423 case DW_OP_form_tls_address
:
1424 printf ("DW_OP_form_tls_address");
1426 case DW_OP_call_frame_cfa
:
1427 printf ("DW_OP_call_frame_cfa");
1429 case DW_OP_bit_piece
:
1430 printf ("DW_OP_bit_piece: ");
1431 READ_ULEB (uvalue
, data
, end
);
1432 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1433 READ_ULEB (uvalue
, data
, end
);
1434 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1437 /* DWARF 4 extensions. */
1438 case DW_OP_stack_value
:
1439 printf ("DW_OP_stack_value");
1442 case DW_OP_implicit_value
:
1443 printf ("DW_OP_implicit_value");
1444 READ_ULEB (uvalue
, data
, end
);
1445 data
= display_block (data
, uvalue
, end
, ' ');
1448 /* GNU extensions. */
1449 case DW_OP_GNU_push_tls_address
:
1450 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1452 case DW_OP_GNU_uninit
:
1453 printf ("DW_OP_GNU_uninit");
1454 /* FIXME: Is there data associated with this OP ? */
1456 case DW_OP_GNU_encoded_addr
:
1463 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1465 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1466 print_dwarf_vma (addr
, pointer_size
);
1469 case DW_OP_implicit_pointer
:
1470 case DW_OP_GNU_implicit_pointer
:
1471 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1472 this ought to be an 8-byte wide computation. */
1473 if (dwarf_version
== -1)
1475 printf (_("(%s in frame info)"),
1476 (op
== DW_OP_implicit_pointer
1477 ? "DW_OP_implicit_pointer"
1478 : "DW_OP_GNU_implicit_pointer"));
1479 /* No way to tell where the next op is, so just bail. */
1480 return need_frame_base
;
1482 if (dwarf_version
== 2)
1484 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1488 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1490 READ_SLEB (svalue
, data
, end
);
1491 printf ("%s: <0x%s> %s",
1492 (op
== DW_OP_implicit_pointer
1493 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1494 dwarf_vmatoa ("x", uvalue
),
1495 dwarf_vmatoa ("d", svalue
));
1497 case DW_OP_entry_value
:
1498 case DW_OP_GNU_entry_value
:
1499 READ_ULEB (uvalue
, data
, end
);
1500 /* PR 17531: file: 0cc9cd00. */
1501 if (uvalue
> (dwarf_vma
) (end
- data
))
1502 uvalue
= end
- data
;
1503 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1504 : "DW_OP_GNU_entry_value"));
1505 if (decode_location_expression (data
, pointer_size
, offset_size
,
1506 dwarf_version
, uvalue
,
1507 cu_offset
, section
))
1508 need_frame_base
= 1;
1514 case DW_OP_const_type
:
1515 case DW_OP_GNU_const_type
:
1516 READ_ULEB (uvalue
, data
, end
);
1517 printf ("%s: <0x%s> ",
1518 (op
== DW_OP_const_type
? "DW_OP_const_type"
1519 : "DW_OP_GNU_const_type"),
1520 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1521 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1522 data
= display_block (data
, uvalue
, end
, ' ');
1524 case DW_OP_regval_type
:
1525 case DW_OP_GNU_regval_type
:
1526 READ_ULEB (uvalue
, data
, end
);
1527 printf ("%s: %s (%s)",
1528 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1529 : "DW_OP_GNU_regval_type"),
1530 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1531 READ_ULEB (uvalue
, data
, end
);
1532 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1534 case DW_OP_deref_type
:
1535 case DW_OP_GNU_deref_type
:
1536 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1538 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1539 : "DW_OP_GNU_deref_type"),
1541 READ_ULEB (uvalue
, data
, end
);
1542 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1545 case DW_OP_GNU_convert
:
1546 READ_ULEB (uvalue
, data
, end
);
1547 printf ("%s <0x%s>",
1548 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1549 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1551 case DW_OP_reinterpret
:
1552 case DW_OP_GNU_reinterpret
:
1553 READ_ULEB (uvalue
, data
, end
);
1554 printf ("%s <0x%s>",
1555 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1556 : "DW_OP_GNU_reinterpret"),
1557 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1559 case DW_OP_GNU_parameter_ref
:
1560 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1561 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1562 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1564 case DW_OP_GNU_addr_index
:
1565 READ_ULEB (uvalue
, data
, end
);
1566 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1568 case DW_OP_GNU_const_index
:
1569 READ_ULEB (uvalue
, data
, end
);
1570 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1572 case DW_OP_GNU_variable_value
:
1573 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1574 this ought to be an 8-byte wide computation. */
1575 if (dwarf_version
== -1)
1577 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1578 /* No way to tell where the next op is, so just bail. */
1579 return need_frame_base
;
1581 if (dwarf_version
== 2)
1583 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1587 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1589 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1592 /* HP extensions. */
1593 case DW_OP_HP_is_value
:
1594 printf ("DW_OP_HP_is_value");
1595 /* FIXME: Is there data associated with this OP ? */
1597 case DW_OP_HP_fltconst4
:
1598 printf ("DW_OP_HP_fltconst4");
1599 /* FIXME: Is there data associated with this OP ? */
1601 case DW_OP_HP_fltconst8
:
1602 printf ("DW_OP_HP_fltconst8");
1603 /* FIXME: Is there data associated with this OP ? */
1605 case DW_OP_HP_mod_range
:
1606 printf ("DW_OP_HP_mod_range");
1607 /* FIXME: Is there data associated with this OP ? */
1609 case DW_OP_HP_unmod_range
:
1610 printf ("DW_OP_HP_unmod_range");
1611 /* FIXME: Is there data associated with this OP ? */
1614 printf ("DW_OP_HP_tls");
1615 /* FIXME: Is there data associated with this OP ? */
1618 /* PGI (STMicroelectronics) extensions. */
1619 case DW_OP_PGI_omp_thread_num
:
1620 /* Pushes the thread number for the current thread as it would be
1621 returned by the standard OpenMP library function:
1622 omp_get_thread_num(). The "current thread" is the thread for
1623 which the expression is being evaluated. */
1624 printf ("DW_OP_PGI_omp_thread_num");
1628 if (op
>= DW_OP_lo_user
1629 && op
<= DW_OP_hi_user
)
1630 printf (_("(User defined location op 0x%x)"), op
);
1632 printf (_("(Unknown location op 0x%x)"), op
);
1633 /* No way to tell where the next op is, so just bail. */
1634 return need_frame_base
;
1637 /* Separate the ops. */
1642 return need_frame_base
;
1645 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1646 This is used for DWARF package files. */
1648 static struct cu_tu_set
*
1649 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1651 struct cu_tu_set
*p
;
1653 unsigned int dw_sect
;
1659 dw_sect
= DW_SECT_TYPES
;
1665 dw_sect
= DW_SECT_INFO
;
1669 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1677 /* Add INC to HIGH_BITS:LOW_BITS. */
1679 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1681 dwarf_vma tmp
= * low_bits
;
1685 /* FIXME: There is probably a better way of handling this:
1687 We need to cope with dwarf_vma being a 32-bit or 64-bit
1688 type. Plus regardless of its size LOW_BITS is meant to
1689 only hold 32-bits, so if there is overflow or wrap around
1690 we must propagate into HIGH_BITS. */
1691 if (tmp
< * low_bits
)
1695 else if (sizeof (tmp
) > 8
1706 fetch_alt_indirect_string (dwarf_vma offset
)
1710 if (! do_follow_links
)
1713 if (first_separate_info
== NULL
)
1714 return _("<no links available>");
1716 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1718 struct dwarf_section
* section
;
1721 if (! load_debug_section (separate_debug_str
, i
->handle
))
1724 section
= &debug_displays
[separate_debug_str
].section
;
1726 if (section
->start
== NULL
)
1729 if (offset
>= section
->size
)
1732 ret
= (const char *) (section
->start
+ offset
);
1733 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1734 NUL byte. Since our caller is expecting to receive a well formed C
1735 string we test for the lack of a terminating byte here. */
1736 if (strnlen ((const char *) ret
, section
->size
- offset
)
1737 == section
->size
- offset
)
1738 return _("<no NUL byte at end of alt .debug_str section>");
1743 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1744 dwarf_vmatoa ("x", offset
));
1745 return _("<offset is too big>");
1749 get_AT_name (unsigned long attribute
)
1754 return "DW_AT value: 0";
1756 /* One value is shared by the MIPS and HP extensions: */
1757 if (attribute
== DW_AT_MIPS_fde
)
1758 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1760 name
= get_DW_AT_name (attribute
);
1764 static char buffer
[100];
1766 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1775 add_dwo_info (const char * field
, dwo_type type
)
1777 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1779 dwinfo
->type
= type
;
1780 dwinfo
->value
= field
;
1781 dwinfo
->next
= first_dwo_info
;
1782 first_dwo_info
= dwinfo
;
1786 add_dwo_name (const char * name
)
1788 add_dwo_info (name
, DWO_NAME
);
1792 add_dwo_dir (const char * dir
)
1794 add_dwo_info (dir
, DWO_DIR
);
1798 add_dwo_id (const char * id
)
1800 add_dwo_info (id
, DWO_ID
);
1804 free_dwo_info (void)
1809 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1811 next
= dwinfo
->next
;
1814 first_dwo_info
= NULL
;
1817 /* Ensure that START + UVALUE is less than END.
1818 Return an adjusted UVALUE if necessary to ensure this relationship. */
1820 static inline dwarf_vma
1821 check_uvalue (const unsigned char * start
,
1823 const unsigned char * end
)
1825 dwarf_vma max_uvalue
= end
- start
;
1827 /* See PR 17512: file: 008-103549-0.001:0.1.
1828 and PR 24829 for examples of where these tests are triggered. */
1829 if (uvalue
> max_uvalue
)
1831 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1832 uvalue
= max_uvalue
;
1838 static unsigned char *
1839 skip_attr_bytes (unsigned long form
,
1840 unsigned char * data
,
1841 unsigned const char * end
,
1842 dwarf_vma pointer_size
,
1843 dwarf_vma offset_size
,
1845 dwarf_vma
* value_return
)
1847 dwarf_signed_vma svalue
;
1848 dwarf_vma uvalue
= 0;
1854 case DW_FORM_ref_addr
:
1855 if (dwarf_version
== 2)
1856 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1857 else if (dwarf_version
== 3 || dwarf_version
== 4)
1858 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1864 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1868 case DW_FORM_line_strp
:
1869 case DW_FORM_sec_offset
:
1870 case DW_FORM_GNU_ref_alt
:
1871 case DW_FORM_GNU_strp_alt
:
1872 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1875 case DW_FORM_flag_present
:
1882 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1887 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1892 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1896 READ_SLEB (svalue
, data
, end
);
1900 case DW_FORM_ref_udata
:
1902 case DW_FORM_GNU_str_index
:
1903 case DW_FORM_GNU_addr_index
:
1904 READ_ULEB (uvalue
, data
, end
);
1912 case DW_FORM_data16
:
1916 case DW_FORM_string
:
1917 data
+= strnlen ((char *) data
, end
- data
) + 1;
1921 case DW_FORM_exprloc
:
1922 READ_ULEB (uvalue
, data
, end
);
1925 case DW_FORM_block1
:
1926 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1930 case DW_FORM_block2
:
1931 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1935 case DW_FORM_block4
:
1936 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1940 case DW_FORM_ref_sig8
:
1944 case DW_FORM_indirect
:
1945 /* FIXME: Handle this form. */
1950 * value_return
= uvalue
;
1952 data
= (unsigned char *) end
;
1956 /* Return IS_SIGNED set to TRUE if the type at
1957 DATA can be determined to be a signed type. */
1960 get_type_signedness (unsigned char * start
,
1961 unsigned char * data
,
1962 unsigned const char * end
,
1963 dwarf_vma pointer_size
,
1964 dwarf_vma offset_size
,
1966 bfd_boolean
* is_signed
,
1967 bfd_boolean is_nested
)
1969 unsigned long abbrev_number
;
1970 abbrev_entry
* entry
;
1973 * is_signed
= FALSE
;
1975 READ_ULEB (abbrev_number
, data
, end
);
1977 for (entry
= first_abbrev
;
1978 entry
!= NULL
&& entry
->entry
!= abbrev_number
;
1979 entry
= entry
->next
)
1983 /* FIXME: Issue a warning ? */
1986 for (attr
= entry
->first_attr
;
1987 attr
!= NULL
&& attr
->attribute
;
1990 dwarf_vma uvalue
= 0;
1992 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
1993 offset_size
, dwarf_version
, & uvalue
);
1997 switch (attr
->attribute
)
1999 #if 0 /* FIXME: It would be nice to print the name of the type,
2000 but this would mean updating a lot of binutils tests. */
2002 if (attr
->form
== DW_FORM_strp
)
2003 printf ("%s", fetch_indirect_string (uvalue
));
2010 /* FIXME: Warn - or is this expected ?
2011 NB/ We need to avoid infinite recursion. */
2014 if (uvalue
>= (size_t) (end
- start
))
2016 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2017 offset_size
, dwarf_version
, is_signed
, TRUE
);
2020 case DW_AT_encoding
:
2021 /* Determine signness. */
2024 case DW_ATE_address
:
2025 /* FIXME - some architectures have signed addresses. */
2026 case DW_ATE_boolean
:
2027 case DW_ATE_unsigned
:
2028 case DW_ATE_unsigned_char
:
2029 case DW_ATE_unsigned_fixed
:
2030 * is_signed
= FALSE
;
2034 case DW_ATE_complex_float
:
2037 case DW_ATE_signed_char
:
2038 case DW_ATE_imaginary_float
:
2039 case DW_ATE_decimal_float
:
2040 case DW_ATE_signed_fixed
:
2050 read_and_print_leb128 (unsigned char * data
,
2051 unsigned int * bytes_read
,
2052 unsigned const char * end
,
2053 bfd_boolean is_signed
)
2056 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2058 report_leb_status (status
, __FILE__
, __LINE__
);
2060 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2064 display_discr_list (unsigned long form
,
2066 unsigned char * data
,
2067 unsigned const char * end
,
2072 printf ("[default]");
2079 case DW_FORM_block1
:
2080 case DW_FORM_block2
:
2081 case DW_FORM_block4
:
2082 /* Move data pointer back to the start of the byte array. */
2086 printf ("<corrupt>\n");
2087 warn (_("corrupt discr_list - not using a block form\n"));
2093 printf ("<corrupt>\n");
2094 warn (_("corrupt discr_list - block not long enough\n"));
2098 bfd_boolean is_signed
=
2099 (level
> 0 && level
<= MAX_CU_NESTING
)
2100 ? level_type_signed
[level
- 1] : FALSE
;
2105 unsigned char discriminant
;
2106 unsigned int bytes_read
;
2108 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2112 assert (uvalue
> 0);
2113 switch (discriminant
)
2117 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2118 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2119 uvalue
-= bytes_read
;
2125 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2126 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2127 uvalue
-= bytes_read
;
2131 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2132 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2133 uvalue
-= bytes_read
;
2138 printf ("<corrupt>\n");
2139 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2149 printf (")(signed)");
2151 printf (")(unsigned)");
2154 static unsigned char *
2155 read_and_display_attr_value (unsigned long attribute
,
2157 dwarf_signed_vma implicit_const
,
2158 unsigned char * start
,
2159 unsigned char * data
,
2160 unsigned char * end
,
2161 dwarf_vma cu_offset
,
2162 dwarf_vma pointer_size
,
2163 dwarf_vma offset_size
,
2165 debug_info
* debug_info_p
,
2167 struct dwarf_section
* section
,
2168 struct cu_tu_set
* this_set
,
2172 dwarf_signed_vma svalue
;
2173 dwarf_vma uvalue
= 0;
2174 unsigned char * block_start
= NULL
;
2175 unsigned char * orig_data
= data
;
2177 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2179 warn (_("Corrupt attribute\n"));
2188 case DW_FORM_ref_addr
:
2189 if (dwarf_version
== 2)
2190 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2191 else if (dwarf_version
== 3 || dwarf_version
== 4)
2192 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2194 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
2199 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2203 case DW_FORM_line_strp
:
2204 case DW_FORM_sec_offset
:
2205 case DW_FORM_GNU_ref_alt
:
2206 case DW_FORM_GNU_strp_alt
:
2207 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2210 case DW_FORM_flag_present
:
2217 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2222 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2227 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2231 READ_SLEB (svalue
, data
, end
);
2235 case DW_FORM_GNU_str_index
:
2236 case DW_FORM_ref_udata
:
2238 case DW_FORM_GNU_addr_index
:
2239 READ_ULEB (uvalue
, data
, end
);
2242 case DW_FORM_indirect
:
2243 READ_ULEB (form
, data
, end
);
2245 printf ("%c%s", delimiter
, get_FORM_name (form
));
2246 if (form
== DW_FORM_implicit_const
)
2247 READ_SLEB (implicit_const
, data
, end
);
2248 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2250 cu_offset
, pointer_size
,
2251 offset_size
, dwarf_version
,
2252 debug_info_p
, do_loc
,
2253 section
, this_set
, delimiter
, level
);
2258 case DW_FORM_ref_addr
:
2260 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2263 case DW_FORM_GNU_ref_alt
:
2265 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2266 /* FIXME: Follow the reference... */
2272 case DW_FORM_ref_udata
:
2274 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2279 case DW_FORM_sec_offset
:
2281 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2284 case DW_FORM_flag_present
:
2291 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2294 case DW_FORM_implicit_const
:
2296 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2303 dwarf_vma high_bits
;
2307 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2309 if (form
== DW_FORM_ref8
)
2310 add64 (& high_bits
, & utmp
, cu_offset
);
2311 printf ("%c0x%s", delimiter
,
2312 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2315 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2316 && num_debug_info_entries
== 0)
2318 if (sizeof (uvalue
) == 8)
2319 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2321 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2327 case DW_FORM_data16
:
2330 dwarf_vma left_high_bits
, left_low_bits
;
2331 dwarf_vma right_high_bits
, right_low_bits
;
2333 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2334 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2335 if (byte_get
== byte_get_little_endian
)
2338 left_high_bits
^= right_high_bits
;
2339 right_high_bits
^= left_high_bits
;
2340 left_high_bits
^= right_high_bits
;
2341 left_low_bits
^= right_low_bits
;
2342 right_low_bits
^= left_low_bits
;
2343 left_low_bits
^= right_low_bits
;
2345 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2346 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2347 left_high_bits
, left_low_bits
, right_high_bits
,
2353 case DW_FORM_string
:
2355 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2356 data
+= strnlen ((char *) data
, end
- data
) + 1;
2360 case DW_FORM_exprloc
:
2361 READ_ULEB (uvalue
, data
, end
);
2364 if (block_start
>= end
)
2366 warn (_("Block ends prematurely\n"));
2371 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2374 data
= block_start
+ uvalue
;
2376 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2379 case DW_FORM_block1
:
2380 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2383 case DW_FORM_block2
:
2384 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2387 case DW_FORM_block4
:
2388 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2393 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2394 dwarf_vmatoa ("x", uvalue
),
2395 fetch_indirect_string (uvalue
));
2398 case DW_FORM_line_strp
:
2400 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2401 dwarf_vmatoa ("x", uvalue
),
2402 fetch_indirect_line_string (uvalue
));
2405 case DW_FORM_GNU_str_index
:
2408 const char * suffix
= strrchr (section
->name
, '.');
2409 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2411 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2412 dwarf_vmatoa ("x", uvalue
),
2413 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2417 case DW_FORM_GNU_strp_alt
:
2420 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2421 dwarf_vmatoa ("x", uvalue
),
2422 fetch_alt_indirect_string (uvalue
));
2426 case DW_FORM_indirect
:
2427 /* Handled above. */
2430 case DW_FORM_ref_sig8
:
2433 dwarf_vma high_bits
;
2436 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2437 printf ("%csignature: 0x%s", delimiter
,
2438 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2443 case DW_FORM_GNU_addr_index
:
2445 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2446 dwarf_vmatoa ("x", uvalue
),
2447 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2451 warn (_("Unrecognized form: %lu\n"), form
);
2455 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2456 && num_debug_info_entries
== 0
2457 && debug_info_p
!= NULL
)
2461 case DW_AT_frame_base
:
2462 have_frame_base
= 1;
2464 case DW_AT_location
:
2465 case DW_AT_GNU_locviews
:
2466 case DW_AT_string_length
:
2467 case DW_AT_return_addr
:
2468 case DW_AT_data_member_location
:
2469 case DW_AT_vtable_elem_location
:
2471 case DW_AT_static_link
:
2472 case DW_AT_use_location
:
2473 case DW_AT_call_value
:
2474 case DW_AT_GNU_call_site_value
:
2475 case DW_AT_call_data_value
:
2476 case DW_AT_GNU_call_site_data_value
:
2477 case DW_AT_call_target
:
2478 case DW_AT_GNU_call_site_target
:
2479 case DW_AT_call_target_clobbered
:
2480 case DW_AT_GNU_call_site_target_clobbered
:
2481 if ((dwarf_version
< 4
2482 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2483 || form
== DW_FORM_sec_offset
)
2485 /* Process location list. */
2486 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2487 unsigned int num
= debug_info_p
->num_loc_offsets
;
2489 if (lmax
== 0 || num
>= lmax
)
2492 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2493 xcrealloc (debug_info_p
->loc_offsets
,
2494 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2495 debug_info_p
->loc_views
= (dwarf_vma
*)
2496 xcrealloc (debug_info_p
->loc_views
,
2497 lmax
, sizeof (*debug_info_p
->loc_views
));
2498 debug_info_p
->have_frame_base
= (int *)
2499 xcrealloc (debug_info_p
->have_frame_base
,
2500 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2501 debug_info_p
->max_loc_offsets
= lmax
;
2503 if (this_set
!= NULL
)
2504 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2505 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2506 if (attribute
!= DW_AT_GNU_locviews
)
2508 /* Corrupt DWARF info can produce more offsets than views.
2509 See PR 23062 for an example. */
2510 if (debug_info_p
->num_loc_offsets
2511 > debug_info_p
->num_loc_views
)
2512 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2515 debug_info_p
->loc_offsets
[num
] = uvalue
;
2516 debug_info_p
->num_loc_offsets
++;
2521 assert (debug_info_p
->num_loc_views
<= num
);
2522 num
= debug_info_p
->num_loc_views
;
2523 if (num
> debug_info_p
->num_loc_offsets
)
2524 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2527 debug_info_p
->loc_views
[num
] = uvalue
;
2528 debug_info_p
->num_loc_views
++;
2535 if (need_base_address
)
2536 debug_info_p
->base_address
= uvalue
;
2539 case DW_AT_GNU_addr_base
:
2540 debug_info_p
->addr_base
= uvalue
;
2543 case DW_AT_GNU_ranges_base
:
2544 debug_info_p
->ranges_base
= uvalue
;
2548 if ((dwarf_version
< 4
2549 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2550 || form
== DW_FORM_sec_offset
)
2552 /* Process range list. */
2553 unsigned int lmax
= debug_info_p
->max_range_lists
;
2554 unsigned int num
= debug_info_p
->num_range_lists
;
2556 if (lmax
== 0 || num
>= lmax
)
2559 debug_info_p
->range_lists
= (dwarf_vma
*)
2560 xcrealloc (debug_info_p
->range_lists
,
2561 lmax
, sizeof (*debug_info_p
->range_lists
));
2562 debug_info_p
->max_range_lists
= lmax
;
2564 debug_info_p
->range_lists
[num
] = uvalue
;
2565 debug_info_p
->num_range_lists
++;
2569 case DW_AT_GNU_dwo_name
:
2570 case DW_AT_dwo_name
:
2575 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2577 case DW_FORM_GNU_str_index
:
2578 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2580 case DW_FORM_string
:
2581 add_dwo_name ((const char *) orig_data
);
2584 warn (_("Unsupported form (%s) for attribute %s\n"),
2585 get_FORM_name (form
), get_AT_name (attribute
));
2590 case DW_AT_comp_dir
:
2591 /* FIXME: Also extract a build-id in a CU/TU. */
2596 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2598 case DW_FORM_line_strp
:
2599 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2601 case DW_FORM_GNU_str_index
:
2602 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2604 case DW_FORM_string
:
2605 add_dwo_dir ((const char *) orig_data
);
2608 warn (_("Unsupported form (%s) for attribute %s\n"),
2609 get_FORM_name (form
), get_AT_name (attribute
));
2614 case DW_AT_GNU_dwo_id
:
2619 /* FIXME: Record the length of the ID as well ? */
2620 add_dwo_id ((const char *) (data
- 8));
2623 warn (_("Unsupported form (%s) for attribute %s\n"),
2624 get_FORM_name (form
), get_AT_name (attribute
));
2634 if (do_loc
|| attribute
== 0)
2637 /* For some attributes we can display further information. */
2641 if (level
>= 0 && level
< MAX_CU_NESTING
2642 && uvalue
< (size_t) (end
- start
))
2644 bfd_boolean is_signed
= FALSE
;
2646 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2647 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2648 level_type_signed
[level
] = is_signed
;
2656 case DW_INL_not_inlined
:
2657 printf (_("(not inlined)"));
2659 case DW_INL_inlined
:
2660 printf (_("(inlined)"));
2662 case DW_INL_declared_not_inlined
:
2663 printf (_("(declared as inline but ignored)"));
2665 case DW_INL_declared_inlined
:
2666 printf (_("(declared as inline and inlined)"));
2669 printf (_(" (Unknown inline attribute value: %s)"),
2670 dwarf_vmatoa ("x", uvalue
));
2675 case DW_AT_language
:
2679 /* Ordered by the numeric value of these constants. */
2680 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2681 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2682 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2683 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2684 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2685 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2686 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2687 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2688 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2689 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2690 /* DWARF 2.1 values. */
2691 case DW_LANG_Java
: printf ("(Java)"); break;
2692 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2693 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2694 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2695 /* DWARF 3 values. */
2696 case DW_LANG_PLI
: printf ("(PLI)"); break;
2697 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2698 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2699 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2700 case DW_LANG_D
: printf ("(D)"); break;
2701 /* DWARF 4 values. */
2702 case DW_LANG_Python
: printf ("(Python)"); break;
2703 /* DWARF 5 values. */
2704 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2705 case DW_LANG_Go
: printf ("(Go)"); break;
2706 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2707 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2708 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2709 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2710 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2711 case DW_LANG_Rust
: printf ("(Rust)"); break;
2712 case DW_LANG_C11
: printf ("(C11)"); break;
2713 case DW_LANG_Swift
: printf ("(Swift)"); break;
2714 case DW_LANG_Julia
: printf ("(Julia)"); break;
2715 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2716 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2717 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2718 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2719 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2720 /* MIPS extension. */
2721 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2722 /* UPC extension. */
2723 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2725 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2726 printf (_("(implementation defined: %s)"),
2727 dwarf_vmatoa ("x", uvalue
));
2729 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2734 case DW_AT_encoding
:
2738 case DW_ATE_void
: printf ("(void)"); break;
2739 case DW_ATE_address
: printf ("(machine address)"); break;
2740 case DW_ATE_boolean
: printf ("(boolean)"); break;
2741 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2742 case DW_ATE_float
: printf ("(float)"); break;
2743 case DW_ATE_signed
: printf ("(signed)"); break;
2744 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2745 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2746 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2747 /* DWARF 2.1 values: */
2748 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2749 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2750 /* DWARF 3 values: */
2751 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2752 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2753 case DW_ATE_edited
: printf ("(edited)"); break;
2754 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2755 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2756 /* DWARF 4 values: */
2757 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2758 /* DWARF 5 values: */
2759 case DW_ATE_UCS
: printf ("(UCS)"); break;
2760 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2762 /* HP extensions: */
2763 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2764 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2765 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2766 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2767 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2768 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2769 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2772 if (uvalue
>= DW_ATE_lo_user
2773 && uvalue
<= DW_ATE_hi_user
)
2774 printf (_("(user defined type)"));
2776 printf (_("(unknown type)"));
2781 case DW_AT_accessibility
:
2785 case DW_ACCESS_public
: printf ("(public)"); break;
2786 case DW_ACCESS_protected
: printf ("(protected)"); break;
2787 case DW_ACCESS_private
: printf ("(private)"); break;
2789 printf (_("(unknown accessibility)"));
2794 case DW_AT_visibility
:
2798 case DW_VIS_local
: printf ("(local)"); break;
2799 case DW_VIS_exported
: printf ("(exported)"); break;
2800 case DW_VIS_qualified
: printf ("(qualified)"); break;
2801 default: printf (_("(unknown visibility)")); break;
2805 case DW_AT_endianity
:
2809 case DW_END_default
: printf ("(default)"); break;
2810 case DW_END_big
: printf ("(big)"); break;
2811 case DW_END_little
: printf ("(little)"); break;
2813 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2814 printf (_("(user specified)"));
2816 printf (_("(unknown endianity)"));
2821 case DW_AT_virtuality
:
2825 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2826 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2827 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2828 default: printf (_("(unknown virtuality)")); break;
2832 case DW_AT_identifier_case
:
2836 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2837 case DW_ID_up_case
: printf ("(up_case)"); break;
2838 case DW_ID_down_case
: printf ("(down_case)"); break;
2839 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2840 default: printf (_("(unknown case)")); break;
2844 case DW_AT_calling_convention
:
2848 case DW_CC_normal
: printf ("(normal)"); break;
2849 case DW_CC_program
: printf ("(program)"); break;
2850 case DW_CC_nocall
: printf ("(nocall)"); break;
2851 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2852 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2853 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2854 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2856 if (uvalue
>= DW_CC_lo_user
2857 && uvalue
<= DW_CC_hi_user
)
2858 printf (_("(user defined)"));
2860 printf (_("(unknown convention)"));
2864 case DW_AT_ordering
:
2869 case -1: printf (_("(undefined)")); break;
2870 case 0: printf ("(row major)"); break;
2871 case 1: printf ("(column major)"); break;
2875 case DW_AT_decimal_sign
:
2879 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2880 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2881 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2882 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2883 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2884 default: printf (_("(unrecognised)")); break;
2888 case DW_AT_defaulted
:
2892 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2893 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2894 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2895 default: printf (_("(unrecognised)")); break;
2899 case DW_AT_discr_list
:
2901 display_discr_list (form
, uvalue
, data
, end
, level
);
2904 case DW_AT_frame_base
:
2905 have_frame_base
= 1;
2907 case DW_AT_location
:
2908 case DW_AT_string_length
:
2909 case DW_AT_return_addr
:
2910 case DW_AT_data_member_location
:
2911 case DW_AT_vtable_elem_location
:
2913 case DW_AT_static_link
:
2914 case DW_AT_use_location
:
2915 case DW_AT_call_value
:
2916 case DW_AT_GNU_call_site_value
:
2917 case DW_AT_call_data_value
:
2918 case DW_AT_GNU_call_site_data_value
:
2919 case DW_AT_call_target
:
2920 case DW_AT_GNU_call_site_target
:
2921 case DW_AT_call_target_clobbered
:
2922 case DW_AT_GNU_call_site_target_clobbered
:
2923 if ((dwarf_version
< 4
2924 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2925 || form
== DW_FORM_sec_offset
)
2926 printf (_(" (location list)"));
2928 case DW_AT_allocated
:
2929 case DW_AT_associated
:
2930 case DW_AT_data_location
:
2932 case DW_AT_upper_bound
:
2933 case DW_AT_lower_bound
:
2936 int need_frame_base
;
2939 need_frame_base
= decode_location_expression (block_start
,
2944 cu_offset
, section
);
2946 if (need_frame_base
&& !have_frame_base
)
2947 printf (_(" [without DW_AT_frame_base]"));
2951 case DW_AT_data_bit_offset
:
2952 case DW_AT_byte_size
:
2953 case DW_AT_bit_size
:
2954 case DW_AT_string_length_byte_size
:
2955 case DW_AT_string_length_bit_size
:
2956 case DW_AT_bit_stride
:
2957 if (form
== DW_FORM_exprloc
)
2960 (void) decode_location_expression (block_start
, pointer_size
,
2961 offset_size
, dwarf_version
,
2962 uvalue
, cu_offset
, section
);
2969 if (form
== DW_FORM_ref_sig8
2970 || form
== DW_FORM_GNU_ref_alt
)
2973 if (form
== DW_FORM_ref1
2974 || form
== DW_FORM_ref2
2975 || form
== DW_FORM_ref4
2976 || form
== DW_FORM_ref_udata
)
2977 uvalue
+= cu_offset
;
2979 if (uvalue
>= section
->size
)
2980 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2981 dwarf_vmatoa ("x", uvalue
),
2982 (unsigned long) (orig_data
- section
->start
));
2985 unsigned long abbrev_number
;
2986 abbrev_entry
*entry
;
2987 unsigned char *p
= section
->start
+ uvalue
;
2989 READ_ULEB (abbrev_number
, p
, end
);
2991 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2992 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2993 use different abbrev table, and we don't track .debug_info chunks
2995 if (form
!= DW_FORM_ref_addr
)
2997 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2998 if (entry
->entry
== abbrev_number
)
3001 printf (" (%s)", get_TAG_name (entry
->tag
));
3015 static unsigned char *
3016 read_and_display_attr (unsigned long attribute
,
3018 dwarf_signed_vma implicit_const
,
3019 unsigned char * start
,
3020 unsigned char * data
,
3021 unsigned char * end
,
3022 dwarf_vma cu_offset
,
3023 dwarf_vma pointer_size
,
3024 dwarf_vma offset_size
,
3026 debug_info
* debug_info_p
,
3028 struct dwarf_section
* section
,
3029 struct cu_tu_set
* this_set
,
3033 printf (" %-18s:", get_AT_name (attribute
));
3034 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3036 cu_offset
, pointer_size
, offset_size
,
3037 dwarf_version
, debug_info_p
,
3038 do_loc
, section
, this_set
, ' ', level
);
3044 /* Like load_debug_section, but if the ordinary call fails, and we are
3045 following debug links, then attempt to load the requested section
3046 from one of the separate debug info files. */
3049 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3052 if (load_debug_section (sec_enum
, handle
))
3054 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3056 /* See if we can associate a filename with this section. */
3059 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3060 if (i
->handle
== handle
)
3062 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3070 if (do_follow_links
)
3074 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3076 if (load_debug_section (sec_enum
, i
->handle
))
3078 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3080 /* FIXME: We should check to see if any of the remaining debug info
3081 files also contain this section, and, umm, do something about it. */
3091 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3095 if (do_follow_links
&& section
->filename
)
3096 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3097 section
->name
, section
->filename
);
3099 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3103 if (do_follow_links
&& section
->filename
)
3104 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3105 section
->name
, section
->filename
);
3107 printf (_("Contents of the %s section:\n\n"), section
->name
);
3111 /* Process the contents of a .debug_info section.
3112 If do_loc is TRUE then we are scanning for location lists and dwo tags
3113 and we do not want to display anything to the user.
3114 If do_types is TRUE, we are processing a .debug_types section instead of
3115 a .debug_info section.
3116 The information displayed is restricted by the values in DWARF_START_DIE
3117 and DWARF_CUTOFF_LEVEL.
3118 Returns TRUE upon success. Otherwise an error or warning message is
3119 printed and FALSE is returned. */
3122 process_debug_info (struct dwarf_section
* section
,
3124 enum dwarf_section_display_enum abbrev_sec
,
3126 bfd_boolean do_types
)
3128 unsigned char *start
= section
->start
;
3129 unsigned char *end
= start
+ section
->size
;
3130 unsigned char *section_begin
;
3132 unsigned int num_units
= 0;
3134 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3135 && num_debug_info_entries
== 0
3140 /* First scan the section to get the number of comp units. */
3141 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3144 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3145 will be the length. For a 64-bit DWARF section, it'll be
3146 the escape code 0xffffffff followed by an 8 byte length. */
3147 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3149 if (length
== 0xffffffff)
3151 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3152 section_begin
+= length
+ 12;
3154 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3156 warn (_("Reserved length value (0x%s) found in section %s\n"),
3157 dwarf_vmatoa ("x", length
), section
->name
);
3161 section_begin
+= length
+ 4;
3163 /* Negative values are illegal, they may even cause infinite
3164 looping. This can happen if we can't accurately apply
3165 relocations to an object file, or if the file is corrupt. */
3166 if ((signed long) length
<= 0 || section_begin
< start
)
3168 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3169 dwarf_vmatoa ("x", length
), section
->name
);
3176 error (_("No comp units in %s section ?\n"), section
->name
);
3180 /* Then allocate an array to hold the information. */
3181 debug_information
= (debug_info
*) cmalloc (num_units
,
3182 sizeof (* debug_information
));
3183 if (debug_information
== NULL
)
3185 error (_("Not enough memory for a debug info array of %u entries\n"),
3187 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3191 /* PR 17531: file: 92ca3797.
3192 We cannot rely upon the debug_information array being initialised
3193 before it is used. A corrupt file could easily contain references
3194 to a unit for which information has not been made available. So
3195 we ensure that the array is zeroed here. */
3196 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3198 alloc_num_debug_info_entries
= num_units
;
3203 load_debug_section_with_follow (str
, file
);
3204 load_debug_section_with_follow (line_str
, file
);
3205 load_debug_section_with_follow (str_dwo
, file
);
3206 load_debug_section_with_follow (str_index
, file
);
3207 load_debug_section_with_follow (str_index_dwo
, file
);
3208 load_debug_section_with_follow (debug_addr
, file
);
3211 load_debug_section_with_follow (abbrev_sec
, file
);
3212 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3214 warn (_("Unable to locate %s section!\n"),
3215 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3219 if (!do_loc
&& dwarf_start_die
== 0)
3220 introduce (section
, FALSE
);
3222 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3224 DWARF2_Internal_CompUnit compunit
;
3225 unsigned char *hdrptr
;
3226 unsigned char *tags
;
3227 int level
, last_level
, saved_level
;
3228 dwarf_vma cu_offset
;
3229 unsigned long sec_off
;
3230 unsigned int offset_size
;
3231 unsigned int initial_length_size
;
3232 dwarf_vma signature_high
= 0;
3233 dwarf_vma signature_low
= 0;
3234 dwarf_vma type_offset
= 0;
3235 struct cu_tu_set
*this_set
;
3236 dwarf_vma abbrev_base
;
3241 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3243 if (compunit
.cu_length
== 0xffffffff)
3245 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3247 initial_length_size
= 12;
3252 initial_length_size
= 4;
3255 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3257 cu_offset
= start
- section_begin
;
3259 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3261 if (compunit
.cu_version
< 5)
3263 compunit
.cu_unit_type
= DW_UT_compile
;
3264 /* Initialize it due to a false compiler warning. */
3265 compunit
.cu_pointer_size
= -1;
3269 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3270 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3272 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3275 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3277 if (this_set
== NULL
)
3280 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3284 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3285 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3288 if (compunit
.cu_version
< 5)
3289 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3291 /* PR 17512: file: 001-108546-0.001:0.1. */
3292 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3294 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3295 compunit
.cu_pointer_size
, offset_size
);
3296 compunit
.cu_pointer_size
= offset_size
;
3301 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3303 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3306 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3307 + initial_length_size
))
3309 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3310 + initial_length_size
;
3314 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3315 && num_debug_info_entries
== 0
3316 && alloc_num_debug_info_entries
> unit
3319 debug_information
[unit
].cu_offset
= cu_offset
;
3320 debug_information
[unit
].pointer_size
3321 = compunit
.cu_pointer_size
;
3322 debug_information
[unit
].offset_size
= offset_size
;
3323 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3324 debug_information
[unit
].base_address
= 0;
3325 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3326 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3327 debug_information
[unit
].loc_offsets
= NULL
;
3328 debug_information
[unit
].have_frame_base
= NULL
;
3329 debug_information
[unit
].max_loc_offsets
= 0;
3330 debug_information
[unit
].num_loc_offsets
= 0;
3331 debug_information
[unit
].range_lists
= NULL
;
3332 debug_information
[unit
].max_range_lists
= 0;
3333 debug_information
[unit
].num_range_lists
= 0;
3336 if (!do_loc
&& dwarf_start_die
== 0)
3338 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3339 dwarf_vmatoa ("x", cu_offset
));
3340 printf (_(" Length: 0x%s (%s)\n"),
3341 dwarf_vmatoa ("x", compunit
.cu_length
),
3342 offset_size
== 8 ? "64-bit" : "32-bit");
3343 printf (_(" Version: %d\n"), compunit
.cu_version
);
3344 printf (_(" Abbrev Offset: 0x%s\n"),
3345 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3346 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3351 printf (_(" Signature: 0x%s\n"),
3352 dwarf_vmatoa64 (signature_high
, signature_low
,
3353 buf
, sizeof (buf
)));
3354 printf (_(" Type Offset: 0x%s\n"),
3355 dwarf_vmatoa ("x", type_offset
));
3357 if (this_set
!= NULL
)
3359 dwarf_vma
*offsets
= this_set
->section_offsets
;
3360 size_t *sizes
= this_set
->section_sizes
;
3362 printf (_(" Section contributions:\n"));
3363 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3364 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3365 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3366 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3367 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3368 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3369 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3370 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3371 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3372 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3373 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3374 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3378 sec_off
= cu_offset
+ initial_length_size
;
3379 if (sec_off
+ compunit
.cu_length
< sec_off
3380 || sec_off
+ compunit
.cu_length
> section
->size
)
3382 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3384 (unsigned long) cu_offset
,
3385 dwarf_vmatoa ("x", compunit
.cu_length
));
3391 start
+= compunit
.cu_length
+ initial_length_size
;
3393 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3395 warn (_("CU at offset %s contains corrupt or "
3396 "unsupported version number: %d.\n"),
3397 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3401 if (compunit
.cu_unit_type
!= DW_UT_compile
3402 && compunit
.cu_unit_type
!= DW_UT_type
)
3404 warn (_("CU at offset %s contains corrupt or "
3405 "unsupported unit type: %d.\n"),
3406 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3412 /* Process the abbrevs used by this compilation unit. */
3413 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3414 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3415 (unsigned long) compunit
.cu_abbrev_offset
,
3416 (unsigned long) abbrev_size
);
3417 /* PR 17531: file:4bcd9ce9. */
3418 else if ((abbrev_base
+ abbrev_size
)
3419 > debug_displays
[abbrev_sec
].section
.size
)
3420 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3421 (unsigned long) abbrev_base
+ abbrev_size
,
3422 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3424 process_abbrev_section
3425 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3426 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3427 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3428 + abbrev_base
+ abbrev_size
));
3433 while (tags
< start
)
3435 unsigned long abbrev_number
;
3436 unsigned long die_offset
;
3437 abbrev_entry
*entry
;
3439 int do_printing
= 1;
3441 die_offset
= tags
- section_begin
;
3443 READ_ULEB (abbrev_number
, tags
, start
);
3445 /* A null DIE marks the end of a list of siblings or it may also be
3446 a section padding. */
3447 if (abbrev_number
== 0)
3449 /* Check if it can be a section padding for the last CU. */
3450 if (level
== 0 && start
== end
)
3454 for (chk
= tags
; chk
< start
; chk
++)
3461 if (!do_loc
&& die_offset
>= dwarf_start_die
3462 && (dwarf_cutoff_level
== -1
3463 || level
< dwarf_cutoff_level
))
3464 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3470 static unsigned num_bogus_warns
= 0;
3472 if (num_bogus_warns
< 3)
3474 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3475 die_offset
, section
->name
);
3477 if (num_bogus_warns
== 3)
3478 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3481 if (dwarf_start_die
!= 0 && level
< saved_level
)
3488 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3492 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3493 saved_level
= level
;
3494 do_printing
= (dwarf_cutoff_level
== -1
3495 || level
< dwarf_cutoff_level
);
3497 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3498 level
, die_offset
, abbrev_number
);
3499 else if (dwarf_cutoff_level
== -1
3500 || last_level
< dwarf_cutoff_level
)
3501 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3506 /* Scan through the abbreviation list until we reach the
3508 for (entry
= first_abbrev
;
3509 entry
&& entry
->entry
!= abbrev_number
;
3510 entry
= entry
->next
)
3515 if (!do_loc
&& do_printing
)
3520 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3521 die_offset
, abbrev_number
);
3525 if (!do_loc
&& do_printing
)
3526 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3531 need_base_address
= 0;
3533 case DW_TAG_compile_unit
:
3534 need_base_address
= 1;
3535 need_dwo_info
= do_loc
;
3537 case DW_TAG_entry_point
:
3538 case DW_TAG_subprogram
:
3539 need_base_address
= 0;
3540 /* Assuming that there is no DW_AT_frame_base. */
3541 have_frame_base
= 0;
3545 debug_info
*debug_info_p
=
3546 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3547 ? debug_information
+ unit
: NULL
;
3549 assert (!debug_info_p
3550 || (debug_info_p
->num_loc_offsets
3551 == debug_info_p
->num_loc_views
));
3553 for (attr
= entry
->first_attr
;
3554 attr
&& attr
->attribute
;
3557 if (! do_loc
&& do_printing
)
3558 /* Show the offset from where the tag was extracted. */
3559 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3560 tags
= read_and_display_attr (attr
->attribute
,
3562 attr
->implicit_const
,
3567 compunit
.cu_pointer_size
,
3569 compunit
.cu_version
,
3571 do_loc
|| ! do_printing
,
3577 /* If a locview attribute appears before a location one,
3578 make sure we don't associate it with an earlier
3581 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3584 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3585 debug_info_p
->num_loc_views
++;
3586 assert (debug_info_p
->num_loc_views
3587 == debug_info_p
->num_loc_offsets
);
3594 warn(_("DIE has locviews without loclist\n"));
3595 debug_info_p
->num_loc_views
--;
3602 if (entry
->children
)
3607 /* Set num_debug_info_entries here so that it can be used to check if
3608 we need to process .debug_loc and .debug_ranges sections. */
3609 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3610 && num_debug_info_entries
== 0
3613 if (num_units
> alloc_num_debug_info_entries
)
3614 num_debug_info_entries
= alloc_num_debug_info_entries
;
3616 num_debug_info_entries
= num_units
;
3625 /* Locate and scan the .debug_info section in the file and record the pointer
3626 sizes and offsets for the compilation units in it. Usually an executable
3627 will have just one pointer size, but this is not guaranteed, and so we try
3628 not to make any assumptions. Returns zero upon failure, or the number of
3629 compilation units upon success. */
3632 load_debug_info (void * file
)
3634 /* If we have already tried and failed to load the .debug_info
3635 section then do not bother to repeat the task. */
3636 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3639 /* If we already have the information there is nothing else to do. */
3640 if (num_debug_info_entries
> 0)
3641 return num_debug_info_entries
;
3643 /* If this is a DWARF package file, load the CU and TU indexes. */
3644 (void) load_cu_tu_indexes (file
);
3646 if (load_debug_section_with_follow (info
, file
)
3647 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3648 return num_debug_info_entries
;
3650 if (load_debug_section_with_follow (info_dwo
, file
)
3651 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3652 abbrev_dwo
, TRUE
, FALSE
))
3653 return num_debug_info_entries
;
3655 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3659 /* Read a DWARF .debug_line section header starting at DATA.
3660 Upon success returns an updated DATA pointer and the LINFO
3661 structure and the END_OF_SEQUENCE pointer will be filled in.
3662 Otherwise returns NULL. */
3664 static unsigned char *
3665 read_debug_line_header (struct dwarf_section
* section
,
3666 unsigned char * data
,
3667 unsigned char * end
,
3668 DWARF2_Internal_LineInfo
* linfo
,
3669 unsigned char ** end_of_sequence
)
3671 unsigned char *hdrptr
;
3672 unsigned int initial_length_size
;
3674 /* Extract information from the Line Number Program Header.
3675 (section 6.2.4 in the Dwarf3 doc). */
3678 /* Get and check the length of the block. */
3679 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3681 if (linfo
->li_length
== 0xffffffff)
3683 /* This section is 64-bit DWARF 3. */
3684 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3685 linfo
->li_offset_size
= 8;
3686 initial_length_size
= 12;
3690 linfo
->li_offset_size
= 4;
3691 initial_length_size
= 4;
3694 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3696 /* If the length field has a relocation against it, then we should
3697 not complain if it is inaccurate (and probably negative). This
3698 happens in object files when the .debug_line section is actually
3699 comprised of several different .debug_line.* sections, (some of
3700 which may be removed by linker garbage collection), and a relocation
3701 is used to compute the correct length once that is done. */
3702 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3704 linfo
->li_length
= (end
- data
) - initial_length_size
;
3708 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3709 (long) linfo
->li_length
);
3714 /* Get and check the version number. */
3715 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3717 if (linfo
->li_version
!= 2
3718 && linfo
->li_version
!= 3
3719 && linfo
->li_version
!= 4
3720 && linfo
->li_version
!= 5)
3722 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3723 "is currently supported.\n"));
3727 if (linfo
->li_version
>= 5)
3729 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
3731 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
3732 if (linfo
->li_segment_size
!= 0)
3734 warn (_("The %s section contains "
3735 "unsupported segment selector size: %d.\n"),
3736 section
->name
, linfo
->li_segment_size
);
3741 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3742 linfo
->li_offset_size
, end
);
3743 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3745 if (linfo
->li_version
>= 4)
3747 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3749 if (linfo
->li_max_ops_per_insn
== 0)
3751 warn (_("Invalid maximum operations per insn.\n"));
3756 linfo
->li_max_ops_per_insn
= 1;
3758 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3759 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3760 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3761 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3763 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3764 /* PR 17512: file:002-117414-0.004. */
3765 if (* end_of_sequence
> end
)
3767 warn (_("Line length %s extends beyond end of section\n"),
3768 dwarf_vmatoa ("u", linfo
->li_length
));
3769 * end_of_sequence
= end
;
3776 static unsigned char *
3777 display_formatted_table (unsigned char * data
,
3778 unsigned char * start
,
3779 unsigned char * end
,
3780 const DWARF2_Internal_LineInfo
* linfo
,
3781 struct dwarf_section
* section
,
3784 unsigned char *format_start
, format_count
, *format
, formati
;
3785 dwarf_vma data_count
, datai
;
3786 unsigned int namepass
, last_entry
= 0;
3787 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
3789 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3790 if (do_checks
&& format_count
> 5)
3791 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
3792 table_name
, format_count
);
3794 format_start
= data
;
3795 for (formati
= 0; formati
< format_count
; formati
++)
3797 SKIP_ULEB (data
, end
);
3798 SKIP_ULEB (data
, end
);
3801 warn (_("%s: Corrupt format description entry\n"), table_name
);
3806 READ_ULEB (data_count
, data
, end
);
3807 if (data_count
== 0)
3809 printf (_("\n The %s is empty.\n"), table_name
);
3812 else if (data
== end
)
3814 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
3815 table_name
, dwarf_vmatoa ("x", data_count
));
3819 else if (format_count
== 0)
3821 warn (_("%s: format count is zero, but the table is not empty\n"),
3826 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
3827 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
3830 printf (_(" Entry"));
3831 /* Delay displaying name as the last entry for better screen layout. */
3832 for (namepass
= 0; namepass
< 2; namepass
++)
3834 format
= format_start
;
3835 for (formati
= 0; formati
< format_count
; formati
++)
3837 dwarf_vma content_type
;
3839 READ_ULEB (content_type
, format
, end
);
3840 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3841 switch (content_type
)
3844 printf (_("\tName"));
3846 case DW_LNCT_directory_index
:
3847 printf (_("\tDir"));
3849 case DW_LNCT_timestamp
:
3850 printf (_("\tTime"));
3853 printf (_("\tSize"));
3856 printf (_("\tMD5\t\t\t"));
3859 printf (_("\t(Unknown format content type %s)"),
3860 dwarf_vmatoa ("u", content_type
));
3862 SKIP_ULEB (format
, end
);
3867 for (datai
= 0; datai
< data_count
; datai
++)
3869 unsigned char *datapass
= data
;
3871 printf (" %d", last_entry
++);
3872 /* Delay displaying name as the last entry for better screen layout. */
3873 for (namepass
= 0; namepass
< 2; namepass
++)
3875 format
= format_start
;
3877 for (formati
= 0; formati
< format_count
; formati
++)
3879 dwarf_vma content_type
, form
;
3881 READ_ULEB (content_type
, format
, end
);
3882 READ_ULEB (form
, format
, end
);
3883 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
3884 0, 0, linfo
->li_offset_size
,
3885 linfo
->li_version
, NULL
,
3886 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3887 section
, NULL
, '\t', -1);
3891 if (data
== end
&& (datai
< data_count
- 1))
3893 warn (_("\n%s: Corrupt entries list\n"), table_name
);
3902 display_debug_lines_raw (struct dwarf_section
* section
,
3903 unsigned char * data
,
3904 unsigned char * end
,
3907 unsigned char *start
= section
->start
;
3908 int verbose_view
= 0;
3910 introduce (section
, TRUE
);
3914 static DWARF2_Internal_LineInfo saved_linfo
;
3915 DWARF2_Internal_LineInfo linfo
;
3916 unsigned char *standard_opcodes
;
3917 unsigned char *end_of_sequence
;
3920 if (const_strneq (section
->name
, ".debug_line.")
3921 /* Note: the following does not apply to .debug_line.dwo sections.
3922 These are full debug_line sections. */
3923 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3925 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3926 section containing just the Line Number Statements. They are
3927 created by the assembler and intended to be used alongside gcc's
3928 -ffunction-sections command line option. When the linker's
3929 garbage collection decides to discard a .text.<foo> section it
3930 can then also discard the line number information in .debug_line.<foo>.
3932 Since the section is a fragment it does not have the details
3933 needed to fill out a LineInfo structure, so instead we use the
3934 details from the last full debug_line section that we processed. */
3935 end_of_sequence
= end
;
3936 standard_opcodes
= NULL
;
3937 linfo
= saved_linfo
;
3938 /* PR 17531: file: 0522b371. */
3939 if (linfo
.li_line_range
== 0)
3941 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3944 reset_state_machine (linfo
.li_default_is_stmt
);
3948 unsigned char * hdrptr
;
3950 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3951 & end_of_sequence
)) == NULL
)
3954 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3955 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3956 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3957 if (linfo
.li_version
>= 5)
3959 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
3960 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
3962 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3963 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3964 if (linfo
.li_version
>= 4)
3965 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3966 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3967 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3968 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3969 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3971 /* PR 17512: file: 1665-6428-0.004. */
3972 if (linfo
.li_line_range
== 0)
3974 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3975 linfo
.li_line_range
= 1;
3978 reset_state_machine (linfo
.li_default_is_stmt
);
3980 /* Display the contents of the Opcodes table. */
3981 standard_opcodes
= hdrptr
;
3983 /* PR 17512: file: 002-417945-0.004. */
3984 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3986 warn (_("Line Base extends beyond end of section\n"));
3990 printf (_("\n Opcodes:\n"));
3992 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3993 printf (ngettext (" Opcode %d has %d arg\n",
3994 " Opcode %d has %d args\n",
3995 standard_opcodes
[i
- 1]),
3996 i
, standard_opcodes
[i
- 1]);
3998 /* Display the contents of the Directory table. */
3999 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4001 if (linfo
.li_version
>= 5)
4003 load_debug_section_with_follow (line_str
, file
);
4005 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4007 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4013 printf (_("\n The Directory Table is empty.\n"));
4016 unsigned int last_dir_entry
= 0;
4018 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4019 (long)(data
- start
));
4021 while (data
< end
&& *data
!= 0)
4023 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4025 data
+= strnlen ((char *) data
, end
- data
) + 1;
4028 /* PR 17512: file: 002-132094-0.004. */
4029 if (data
>= end
- 1)
4033 /* Skip the NUL at the end of the table. */
4036 /* Display the contents of the File Name table. */
4038 printf (_("\n The File Name Table is empty.\n"));
4041 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4042 (long)(data
- start
));
4043 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4045 while (data
< end
&& *data
!= 0)
4047 unsigned char *name
;
4050 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4052 data
+= strnlen ((char *) data
, end
- data
) + 1;
4054 READ_ULEB (val
, data
, end
);
4055 printf ("%s\t", dwarf_vmatoa ("u", val
));
4056 READ_ULEB (val
, data
, end
);
4057 printf ("%s\t", dwarf_vmatoa ("u", val
));
4058 READ_ULEB (val
, data
, end
);
4059 printf ("%s\t", dwarf_vmatoa ("u", val
));
4060 printf ("%.*s\n", (int)(end
- name
), name
);
4064 warn (_("Corrupt file name table entry\n"));
4070 /* Skip the NUL at the end of the table. */
4075 saved_linfo
= linfo
;
4078 /* Now display the statements. */
4079 if (data
>= end_of_sequence
)
4080 printf (_(" No Line Number Statements.\n"));
4083 printf (_(" Line Number Statements:\n"));
4085 while (data
< end_of_sequence
)
4087 unsigned char op_code
;
4088 dwarf_signed_vma adv
;
4091 printf (" [0x%08lx]", (long)(data
- start
));
4095 if (op_code
>= linfo
.li_opcode_base
)
4097 op_code
-= linfo
.li_opcode_base
;
4098 uladv
= (op_code
/ linfo
.li_line_range
);
4099 if (linfo
.li_max_ops_per_insn
== 1)
4101 uladv
*= linfo
.li_min_insn_length
;
4102 state_machine_regs
.address
+= uladv
;
4104 state_machine_regs
.view
= 0;
4105 printf (_(" Special opcode %d: "
4106 "advance Address by %s to 0x%s%s"),
4107 op_code
, dwarf_vmatoa ("u", uladv
),
4108 dwarf_vmatoa ("x", state_machine_regs
.address
),
4109 verbose_view
&& uladv
4110 ? _(" (reset view)") : "");
4115 = ((state_machine_regs
.op_index
+ uladv
)
4116 / linfo
.li_max_ops_per_insn
)
4117 * linfo
.li_min_insn_length
;
4119 state_machine_regs
.address
+= addrdelta
;
4120 state_machine_regs
.op_index
4121 = (state_machine_regs
.op_index
+ uladv
)
4122 % linfo
.li_max_ops_per_insn
;
4124 state_machine_regs
.view
= 0;
4125 printf (_(" Special opcode %d: "
4126 "advance Address by %s to 0x%s[%d]%s"),
4127 op_code
, dwarf_vmatoa ("u", uladv
),
4128 dwarf_vmatoa ("x", state_machine_regs
.address
),
4129 state_machine_regs
.op_index
,
4130 verbose_view
&& addrdelta
4131 ? _(" (reset view)") : "");
4133 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4134 state_machine_regs
.line
+= adv
;
4135 printf (_(" and Line by %s to %d"),
4136 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4137 if (verbose_view
|| state_machine_regs
.view
)
4138 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4141 state_machine_regs
.view
++;
4146 case DW_LNS_extended_op
:
4147 data
+= process_extended_line_op (data
,
4148 linfo
.li_default_is_stmt
,
4153 printf (_(" Copy"));
4154 if (verbose_view
|| state_machine_regs
.view
)
4155 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4158 state_machine_regs
.view
++;
4161 case DW_LNS_advance_pc
:
4162 READ_ULEB (uladv
, data
, end
);
4163 if (linfo
.li_max_ops_per_insn
== 1)
4165 uladv
*= linfo
.li_min_insn_length
;
4166 state_machine_regs
.address
+= uladv
;
4168 state_machine_regs
.view
= 0;
4169 printf (_(" Advance PC by %s to 0x%s%s\n"),
4170 dwarf_vmatoa ("u", uladv
),
4171 dwarf_vmatoa ("x", state_machine_regs
.address
),
4172 verbose_view
&& uladv
4173 ? _(" (reset view)") : "");
4178 = ((state_machine_regs
.op_index
+ uladv
)
4179 / linfo
.li_max_ops_per_insn
)
4180 * linfo
.li_min_insn_length
;
4181 state_machine_regs
.address
4183 state_machine_regs
.op_index
4184 = (state_machine_regs
.op_index
+ uladv
)
4185 % linfo
.li_max_ops_per_insn
;
4187 state_machine_regs
.view
= 0;
4188 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4189 dwarf_vmatoa ("u", uladv
),
4190 dwarf_vmatoa ("x", state_machine_regs
.address
),
4191 state_machine_regs
.op_index
,
4192 verbose_view
&& addrdelta
4193 ? _(" (reset view)") : "");
4197 case DW_LNS_advance_line
:
4198 READ_SLEB (adv
, data
, end
);
4199 state_machine_regs
.line
+= adv
;
4200 printf (_(" Advance Line by %s to %d\n"),
4201 dwarf_vmatoa ("d", adv
),
4202 state_machine_regs
.line
);
4205 case DW_LNS_set_file
:
4206 READ_ULEB (uladv
, data
, end
);
4207 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4208 dwarf_vmatoa ("u", uladv
));
4209 state_machine_regs
.file
= uladv
;
4212 case DW_LNS_set_column
:
4213 READ_ULEB (uladv
, data
, end
);
4214 printf (_(" Set column to %s\n"),
4215 dwarf_vmatoa ("u", uladv
));
4216 state_machine_regs
.column
= uladv
;
4219 case DW_LNS_negate_stmt
:
4220 adv
= state_machine_regs
.is_stmt
;
4222 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4223 state_machine_regs
.is_stmt
= adv
;
4226 case DW_LNS_set_basic_block
:
4227 printf (_(" Set basic block\n"));
4228 state_machine_regs
.basic_block
= 1;
4231 case DW_LNS_const_add_pc
:
4232 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4233 if (linfo
.li_max_ops_per_insn
)
4235 uladv
*= linfo
.li_min_insn_length
;
4236 state_machine_regs
.address
+= uladv
;
4238 state_machine_regs
.view
= 0;
4239 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4240 dwarf_vmatoa ("u", uladv
),
4241 dwarf_vmatoa ("x", state_machine_regs
.address
),
4242 verbose_view
&& uladv
4243 ? _(" (reset view)") : "");
4248 = ((state_machine_regs
.op_index
+ uladv
)
4249 / linfo
.li_max_ops_per_insn
)
4250 * linfo
.li_min_insn_length
;
4251 state_machine_regs
.address
4253 state_machine_regs
.op_index
4254 = (state_machine_regs
.op_index
+ uladv
)
4255 % linfo
.li_max_ops_per_insn
;
4257 state_machine_regs
.view
= 0;
4258 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4259 dwarf_vmatoa ("u", uladv
),
4260 dwarf_vmatoa ("x", state_machine_regs
.address
),
4261 state_machine_regs
.op_index
,
4262 verbose_view
&& addrdelta
4263 ? _(" (reset view)") : "");
4267 case DW_LNS_fixed_advance_pc
:
4268 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4269 state_machine_regs
.address
+= uladv
;
4270 state_machine_regs
.op_index
= 0;
4271 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4272 dwarf_vmatoa ("u", uladv
),
4273 dwarf_vmatoa ("x", state_machine_regs
.address
));
4274 /* Do NOT reset view. */
4277 case DW_LNS_set_prologue_end
:
4278 printf (_(" Set prologue_end to true\n"));
4281 case DW_LNS_set_epilogue_begin
:
4282 printf (_(" Set epilogue_begin to true\n"));
4285 case DW_LNS_set_isa
:
4286 READ_ULEB (uladv
, data
, end
);
4287 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4291 printf (_(" Unknown opcode %d with operands: "), op_code
);
4293 if (standard_opcodes
!= NULL
)
4294 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4296 READ_ULEB (uladv
, data
, end
);
4297 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4298 i
== 1 ? "" : ", ");
4313 unsigned char *name
;
4314 unsigned int directory_index
;
4315 unsigned int modification_date
;
4316 unsigned int length
;
4319 /* Output a decoded representation of the .debug_line section. */
4322 display_debug_lines_decoded (struct dwarf_section
* section
,
4323 unsigned char * start
,
4324 unsigned char * data
,
4325 unsigned char * end
,
4328 static DWARF2_Internal_LineInfo saved_linfo
;
4330 introduce (section
, FALSE
);
4334 /* This loop amounts to one iteration per compilation unit. */
4335 DWARF2_Internal_LineInfo linfo
;
4336 unsigned char *standard_opcodes
;
4337 unsigned char *end_of_sequence
;
4339 File_Entry
*file_table
= NULL
;
4340 unsigned int n_files
= 0;
4341 unsigned char **directory_table
= NULL
;
4342 dwarf_vma n_directories
= 0;
4344 if (const_strneq (section
->name
, ".debug_line.")
4345 /* Note: the following does not apply to .debug_line.dwo sections.
4346 These are full debug_line sections. */
4347 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4349 /* See comment in display_debug_lines_raw(). */
4350 end_of_sequence
= end
;
4351 standard_opcodes
= NULL
;
4352 linfo
= saved_linfo
;
4353 /* PR 17531: file: 0522b371. */
4354 if (linfo
.li_line_range
== 0)
4356 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4359 reset_state_machine (linfo
.li_default_is_stmt
);
4363 unsigned char *hdrptr
;
4365 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4366 & end_of_sequence
)) == NULL
)
4369 /* PR 17531: file: 0522b371. */
4370 if (linfo
.li_line_range
== 0)
4372 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4373 linfo
.li_line_range
= 1;
4375 reset_state_machine (linfo
.li_default_is_stmt
);
4377 /* Save a pointer to the contents of the Opcodes table. */
4378 standard_opcodes
= hdrptr
;
4380 /* Traverse the Directory table just to count entries. */
4381 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4385 warn (_("opcode base of %d extends beyond end of section\n"),
4386 linfo
.li_opcode_base
);
4390 if (linfo
.li_version
>= 5)
4392 unsigned char *format_start
, format_count
, *format
;
4393 dwarf_vma formati
, entryi
;
4395 load_debug_section_with_follow (line_str
, fileptr
);
4397 /* Skip directories format. */
4398 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4399 if (do_checks
&& format_count
> 1)
4400 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4402 format_start
= data
;
4403 for (formati
= 0; formati
< format_count
; formati
++)
4405 SKIP_ULEB (data
, end
);
4406 SKIP_ULEB (data
, end
);
4409 READ_ULEB (n_directories
, data
, end
);
4412 warn (_("Corrupt directories list\n"));
4416 if (n_directories
== 0)
4417 directory_table
= NULL
;
4419 directory_table
= (unsigned char **)
4420 xmalloc (n_directories
* sizeof (unsigned char *));
4422 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4424 unsigned char **pathp
= &directory_table
[entryi
];
4426 format
= format_start
;
4427 for (formati
= 0; formati
< format_count
; formati
++)
4429 dwarf_vma content_type
, form
;
4432 READ_ULEB (content_type
, format
, end
);
4433 READ_ULEB (form
, format
, end
);
4436 warn (_("Corrupt directories list\n"));
4439 switch (content_type
)
4444 case DW_FORM_string
:
4447 case DW_FORM_line_strp
:
4448 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4450 /* Remove const by the cast. */
4451 *pathp
= (unsigned char *)
4452 fetch_indirect_line_string (uvalue
);
4457 data
= read_and_display_attr_value (0, form
, 0, start
,
4459 linfo
.li_offset_size
,
4466 warn (_("Corrupt directories list\n"));
4471 /* Skip files format. */
4472 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4473 if (do_checks
&& format_count
> 5)
4474 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4476 format_start
= data
;
4477 for (formati
= 0; formati
< format_count
; formati
++)
4479 SKIP_ULEB (data
, end
);
4480 SKIP_ULEB (data
, end
);
4483 READ_ULEB (n_files
, data
, end
);
4484 if (data
== end
&& n_files
> 0)
4486 warn (_("Corrupt file name list\n"));
4493 file_table
= (File_Entry
*) xcalloc (1, n_files
4494 * sizeof (File_Entry
));
4496 for (entryi
= 0; entryi
< n_files
; entryi
++)
4498 File_Entry
*file
= &file_table
[entryi
];
4500 format
= format_start
;
4501 for (formati
= 0; formati
< format_count
; formati
++)
4503 dwarf_vma content_type
, form
;
4507 READ_ULEB (content_type
, format
, end
);
4508 READ_ULEB (form
, format
, end
);
4511 warn (_("Corrupt file name list\n"));
4514 switch (content_type
)
4519 case DW_FORM_string
:
4522 case DW_FORM_line_strp
:
4523 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4525 /* Remove const by the cast. */
4526 file
->name
= (unsigned char *)
4527 fetch_indirect_line_string (uvalue
);
4531 case DW_LNCT_directory_index
:
4535 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4539 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4544 READ_ULEB (file
->directory_index
, tmp
, end
);
4549 data
= read_and_display_attr_value (0, form
, 0, start
,
4551 linfo
.li_offset_size
,
4558 warn (_("Corrupt file name list\n"));
4567 unsigned char *ptr_directory_table
= data
;
4569 while (data
< end
&& *data
!= 0)
4571 data
+= strnlen ((char *) data
, end
- data
) + 1;
4578 warn (_("directory table ends unexpectedly\n"));
4583 /* Go through the directory table again to save the directories. */
4584 directory_table
= (unsigned char **)
4585 xmalloc (n_directories
* sizeof (unsigned char *));
4588 while (*ptr_directory_table
!= 0)
4590 directory_table
[i
] = ptr_directory_table
;
4591 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4592 ptr_directory_table
- end
) + 1;
4596 /* Skip the NUL at the end of the table. */
4599 /* Traverse the File Name table just to count the entries. */
4600 if (data
< end
&& *data
!= 0)
4602 unsigned char *ptr_file_name_table
= data
;
4604 while (data
< end
&& *data
!= 0)
4606 /* Skip Name, directory index, last modification
4607 time and length of file. */
4608 data
+= strnlen ((char *) data
, end
- data
) + 1;
4609 SKIP_ULEB (data
, end
);
4610 SKIP_ULEB (data
, end
);
4611 SKIP_ULEB (data
, end
);
4617 warn (_("file table ends unexpectedly\n"));
4622 /* Go through the file table again to save the strings. */
4623 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4626 while (*ptr_file_name_table
!= 0)
4628 file_table
[i
].name
= ptr_file_name_table
;
4629 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4630 end
- ptr_file_name_table
) + 1;
4632 /* We are not interested in directory, time or size. */
4633 READ_ULEB (file_table
[i
].directory_index
,
4634 ptr_file_name_table
, end
);
4635 READ_ULEB (file_table
[i
].modification_date
,
4636 ptr_file_name_table
, end
);
4637 READ_ULEB (file_table
[i
].length
,
4638 ptr_file_name_table
, end
);
4644 /* Skip the NUL at the end of the table. */
4648 /* Print the Compilation Unit's name and a header. */
4649 if (file_table
== NULL
)
4650 printf (_("CU: No directory table\n"));
4651 else if (directory_table
== NULL
)
4652 printf (_("CU: %s:\n"), file_table
[0].name
);
4655 unsigned int ix
= file_table
[0].directory_index
;
4656 const char *directory
;
4661 else if (n_directories
== 0)
4662 directory
= _("<unknown>");
4663 else if (ix
> n_directories
)
4665 warn (_("directory index %u > number of directories %s\n"),
4666 ix
, dwarf_vmatoa ("u", n_directories
));
4667 directory
= _("<corrupt>");
4670 directory
= (char *) directory_table
[ix
- 1];
4672 if (do_wide
|| strlen (directory
) < 76)
4673 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4675 printf ("%s:\n", file_table
[0].name
);
4679 printf (_("File name Line number Starting address View Stmt\n"));
4681 printf (_("CU: Empty file name table\n"));
4682 saved_linfo
= linfo
;
4685 /* This loop iterates through the Dwarf Line Number Program. */
4686 while (data
< end_of_sequence
)
4688 unsigned char op_code
;
4691 unsigned long int uladv
;
4692 int is_special_opcode
= 0;
4697 if (op_code
>= linfo
.li_opcode_base
)
4699 op_code
-= linfo
.li_opcode_base
;
4700 uladv
= (op_code
/ linfo
.li_line_range
);
4701 if (linfo
.li_max_ops_per_insn
== 1)
4703 uladv
*= linfo
.li_min_insn_length
;
4704 state_machine_regs
.address
+= uladv
;
4706 state_machine_regs
.view
= 0;
4711 = ((state_machine_regs
.op_index
+ uladv
)
4712 / linfo
.li_max_ops_per_insn
)
4713 * linfo
.li_min_insn_length
;
4714 state_machine_regs
.address
4716 state_machine_regs
.op_index
4717 = (state_machine_regs
.op_index
+ uladv
)
4718 % linfo
.li_max_ops_per_insn
;
4720 state_machine_regs
.view
= 0;
4723 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4724 state_machine_regs
.line
+= adv
;
4725 is_special_opcode
= 1;
4726 /* Increment view after printing this row. */
4731 case DW_LNS_extended_op
:
4733 unsigned int ext_op_code_len
;
4734 unsigned char ext_op_code
;
4735 unsigned char *op_code_end
;
4736 unsigned char *op_code_data
= data
;
4738 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
4739 op_code_end
= op_code_data
+ ext_op_code_len
;
4740 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
4742 warn (_("Badly formed extended line op encountered!\n"));
4745 ext_op_code
= *op_code_data
++;
4749 switch (ext_op_code
)
4751 case DW_LNE_end_sequence
:
4752 /* Reset stuff after printing this row. */
4754 case DW_LNE_set_address
:
4755 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4757 op_code_end
- op_code_data
,
4759 state_machine_regs
.op_index
= 0;
4760 state_machine_regs
.view
= 0;
4762 case DW_LNE_define_file
:
4763 file_table
= (File_Entry
*) xrealloc
4764 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4766 ++state_machine_regs
.last_file_entry
;
4767 /* Source file name. */
4768 file_table
[n_files
].name
= op_code_data
;
4769 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4770 /* Directory index. */
4771 READ_ULEB (file_table
[n_files
].directory_index
,
4772 op_code_data
, op_code_end
);
4773 /* Last modification time. */
4774 READ_ULEB (file_table
[n_files
].modification_date
,
4775 op_code_data
, op_code_end
);
4777 READ_ULEB (file_table
[n_files
].length
,
4778 op_code_data
, op_code_end
);
4782 case DW_LNE_set_discriminator
:
4783 case DW_LNE_HP_set_sequence
:
4784 /* Simply ignored. */
4788 printf (_("UNKNOWN (%u): length %ld\n"),
4789 ext_op_code
, (long int) (op_code_data
- data
));
4796 /* Increment view after printing this row. */
4799 case DW_LNS_advance_pc
:
4800 READ_ULEB (uladv
, data
, end
);
4801 if (linfo
.li_max_ops_per_insn
== 1)
4803 uladv
*= linfo
.li_min_insn_length
;
4804 state_machine_regs
.address
+= uladv
;
4806 state_machine_regs
.view
= 0;
4811 = ((state_machine_regs
.op_index
+ uladv
)
4812 / linfo
.li_max_ops_per_insn
)
4813 * linfo
.li_min_insn_length
;
4814 state_machine_regs
.address
4816 state_machine_regs
.op_index
4817 = (state_machine_regs
.op_index
+ uladv
)
4818 % linfo
.li_max_ops_per_insn
;
4820 state_machine_regs
.view
= 0;
4824 case DW_LNS_advance_line
:
4825 READ_SLEB (adv
, data
, end
);
4826 state_machine_regs
.line
+= adv
;
4829 case DW_LNS_set_file
:
4830 READ_ULEB (uladv
, data
, end
);
4831 state_machine_regs
.file
= uladv
;
4834 unsigned file
= state_machine_regs
.file
- 1;
4837 if (file_table
== NULL
|| n_files
== 0)
4838 printf (_("\n [Use file table entry %d]\n"), file
);
4840 else if (file
>= n_files
)
4842 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4843 printf (_("\n <over large file table index %u>"), file
);
4845 else if ((dir
= file_table
[file
].directory_index
) == 0)
4846 /* If directory index is 0, that means current directory. */
4847 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4848 else if (directory_table
== NULL
|| n_directories
== 0)
4849 printf (_("\n [Use file %s in directory table entry %d]\n"),
4850 file_table
[file
].name
, dir
);
4852 else if (dir
> n_directories
)
4854 warn (_("directory index %u > number of directories %s\n"),
4855 dir
, dwarf_vmatoa ("u", n_directories
));
4856 printf (_("\n <over large directory table entry %u>\n"), dir
);
4859 printf ("\n%s/%s:\n",
4860 /* The directory index starts counting at 1. */
4861 directory_table
[dir
- 1], file_table
[file
].name
);
4865 case DW_LNS_set_column
:
4866 READ_ULEB (uladv
, data
, end
);
4867 state_machine_regs
.column
= uladv
;
4870 case DW_LNS_negate_stmt
:
4871 adv
= state_machine_regs
.is_stmt
;
4873 state_machine_regs
.is_stmt
= adv
;
4876 case DW_LNS_set_basic_block
:
4877 state_machine_regs
.basic_block
= 1;
4880 case DW_LNS_const_add_pc
:
4881 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4882 if (linfo
.li_max_ops_per_insn
== 1)
4884 uladv
*= linfo
.li_min_insn_length
;
4885 state_machine_regs
.address
+= uladv
;
4887 state_machine_regs
.view
= 0;
4892 = ((state_machine_regs
.op_index
+ uladv
)
4893 / linfo
.li_max_ops_per_insn
)
4894 * linfo
.li_min_insn_length
;
4895 state_machine_regs
.address
4897 state_machine_regs
.op_index
4898 = (state_machine_regs
.op_index
+ uladv
)
4899 % linfo
.li_max_ops_per_insn
;
4901 state_machine_regs
.view
= 0;
4905 case DW_LNS_fixed_advance_pc
:
4906 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4907 state_machine_regs
.address
+= uladv
;
4908 state_machine_regs
.op_index
= 0;
4909 /* Do NOT reset view. */
4912 case DW_LNS_set_prologue_end
:
4915 case DW_LNS_set_epilogue_begin
:
4918 case DW_LNS_set_isa
:
4919 READ_ULEB (uladv
, data
, end
);
4920 printf (_(" Set ISA to %lu\n"), uladv
);
4924 printf (_(" Unknown opcode %d with operands: "), op_code
);
4926 if (standard_opcodes
!= NULL
)
4927 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4931 READ_ULEB (val
, data
, end
);
4932 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
4933 i
== 1 ? "" : ", ");
4939 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4940 to the DWARF address/line matrix. */
4941 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4942 || (xop
== DW_LNS_copy
))
4944 const unsigned int MAX_FILENAME_LENGTH
= 35;
4946 char *newFileName
= NULL
;
4947 size_t fileNameLength
;
4951 unsigned indx
= state_machine_regs
.file
- 1;
4953 if (indx
>= n_files
)
4955 warn (_("corrupt file index %u encountered\n"), indx
);
4956 fileName
= _("<corrupt>");
4959 fileName
= (char *) file_table
[indx
].name
;
4962 fileName
= _("<unknown>");
4964 fileNameLength
= strlen (fileName
);
4966 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4968 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4969 /* Truncate file name */
4970 strncpy (newFileName
,
4971 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4972 MAX_FILENAME_LENGTH
+ 1);
4973 /* FIXME: This is to pacify gcc-10 which can warn that the
4974 strncpy above might leave a non-NUL terminated string
4975 in newFileName. It won't, but gcc's analysis doesn't
4976 quite go far enough to discover this. */
4977 newFileName
[MAX_FILENAME_LENGTH
] = 0;
4981 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4982 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4985 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4987 if (linfo
.li_max_ops_per_insn
== 1)
4988 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4989 newFileName
, state_machine_regs
.line
,
4990 state_machine_regs
.address
);
4992 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4993 newFileName
, state_machine_regs
.line
,
4994 state_machine_regs
.address
,
4995 state_machine_regs
.op_index
);
4999 if (linfo
.li_max_ops_per_insn
== 1)
5000 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5001 newFileName
, state_machine_regs
.line
,
5002 state_machine_regs
.address
);
5004 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5005 newFileName
, state_machine_regs
.line
,
5006 state_machine_regs
.address
,
5007 state_machine_regs
.op_index
);
5010 if (state_machine_regs
.view
)
5011 printf (" %6u", state_machine_regs
.view
);
5015 if (state_machine_regs
.is_stmt
)
5019 state_machine_regs
.view
++;
5021 if (xop
== -DW_LNE_end_sequence
)
5023 reset_state_machine (linfo
.li_default_is_stmt
);
5038 if (directory_table
)
5040 free (directory_table
);
5041 directory_table
= NULL
;
5052 display_debug_lines (struct dwarf_section
*section
, void *file
)
5054 unsigned char *data
= section
->start
;
5055 unsigned char *end
= data
+ section
->size
;
5057 int retValDecoded
= 1;
5059 if (do_debug_lines
== 0)
5060 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5062 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5063 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5065 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5066 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5068 if (!retValRaw
|| !retValDecoded
)
5075 find_debug_info_for_offset (unsigned long offset
)
5079 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5082 for (i
= 0; i
< num_debug_info_entries
; i
++)
5083 if (debug_information
[i
].cu_offset
== offset
)
5084 return debug_information
+ i
;
5090 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5092 /* See gdb/gdb-index.h. */
5093 static const char * const kinds
[] =
5105 return _ (kinds
[kind
]);
5109 display_debug_pubnames_worker (struct dwarf_section
*section
,
5110 void *file ATTRIBUTE_UNUSED
,
5113 DWARF2_Internal_PubNames names
;
5114 unsigned char *start
= section
->start
;
5115 unsigned char *end
= start
+ section
->size
;
5117 /* It does not matter if this load fails,
5118 we test for that later on. */
5119 load_debug_info (file
);
5121 introduce (section
, FALSE
);
5125 unsigned char *data
;
5126 unsigned long sec_off
;
5127 unsigned int offset_size
, initial_length_size
;
5129 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5130 if (names
.pn_length
== 0xffffffff)
5132 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5134 initial_length_size
= 12;
5139 initial_length_size
= 4;
5142 sec_off
= start
- section
->start
;
5143 if (sec_off
+ names
.pn_length
< sec_off
5144 || sec_off
+ names
.pn_length
> section
->size
)
5146 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5148 sec_off
- initial_length_size
,
5149 dwarf_vmatoa ("x", names
.pn_length
));
5154 start
+= names
.pn_length
;
5156 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5157 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5159 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5160 && num_debug_info_entries
> 0
5161 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5162 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5163 (unsigned long) names
.pn_offset
, section
->name
);
5165 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5167 printf (_(" Length: %ld\n"),
5168 (long) names
.pn_length
);
5169 printf (_(" Version: %d\n"),
5171 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5172 (unsigned long) names
.pn_offset
);
5173 printf (_(" Size of area in .debug_info section: %ld\n"),
5174 (long) names
.pn_size
);
5176 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5178 static int warned
= 0;
5182 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5190 printf (_("\n Offset Kind Name\n"));
5192 printf (_("\n Offset\tName\n"));
5196 bfd_size_type maxprint
;
5199 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5204 data
+= offset_size
;
5207 maxprint
= (end
- data
) - 1;
5211 unsigned int kind_data
;
5212 gdb_index_symbol_kind kind
;
5213 const char *kind_name
;
5216 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5219 /* GCC computes the kind as the upper byte in the CU index
5220 word, and then right shifts it by the CU index size.
5221 Left shift KIND to where the gdb-index.h accessor macros
5223 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5224 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5225 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5226 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5227 printf (" %-6lx %s,%-10s %.*s\n",
5228 (unsigned long) offset
, is_static
? _("s") : _("g"),
5229 kind_name
, (int) maxprint
, data
);
5232 printf (" %-6lx\t%.*s\n",
5233 (unsigned long) offset
, (int) maxprint
, data
);
5235 data
+= strnlen ((char *) data
, maxprint
) + 1;
5246 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5248 return display_debug_pubnames_worker (section
, file
, 0);
5252 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5254 return display_debug_pubnames_worker (section
, file
, 1);
5258 display_debug_macinfo (struct dwarf_section
*section
,
5259 void *file ATTRIBUTE_UNUSED
)
5261 unsigned char *start
= section
->start
;
5262 unsigned char *end
= start
+ section
->size
;
5263 unsigned char *curr
= start
;
5264 enum dwarf_macinfo_record_type op
;
5266 introduce (section
, FALSE
);
5270 unsigned int lineno
;
5271 const unsigned char *string
;
5273 op
= (enum dwarf_macinfo_record_type
) *curr
;
5278 case DW_MACINFO_start_file
:
5280 unsigned int filenum
;
5282 READ_ULEB (lineno
, curr
, end
);
5283 READ_ULEB (filenum
, curr
, end
);
5284 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5289 case DW_MACINFO_end_file
:
5290 printf (_(" DW_MACINFO_end_file\n"));
5293 case DW_MACINFO_define
:
5294 READ_ULEB (lineno
, curr
, end
);
5296 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5297 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5301 case DW_MACINFO_undef
:
5302 READ_ULEB (lineno
, curr
, end
);
5304 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5305 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5309 case DW_MACINFO_vendor_ext
:
5311 unsigned int constant
;
5313 READ_ULEB (constant
, curr
, end
);
5315 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5316 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5326 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5327 filename and dirname corresponding to file name table entry with index
5328 FILEIDX. Return NULL on failure. */
5330 static unsigned char *
5331 get_line_filename_and_dirname (dwarf_vma line_offset
,
5333 unsigned char **dir_name
)
5335 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5336 unsigned char *hdrptr
, *dirtable
, *file_name
;
5337 unsigned int offset_size
, initial_length_size
;
5338 unsigned int version
, opcode_base
;
5339 dwarf_vma length
, diridx
;
5340 const unsigned char * end
;
5343 if (section
->start
== NULL
5344 || line_offset
>= section
->size
5348 hdrptr
= section
->start
+ line_offset
;
5349 end
= section
->start
+ section
->size
;
5351 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5352 if (length
== 0xffffffff)
5354 /* This section is 64-bit DWARF 3. */
5355 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5357 initial_length_size
= 12;
5362 initial_length_size
= 4;
5364 if (length
+ initial_length_size
< length
5365 || length
+ initial_length_size
> section
->size
)
5368 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5369 if (version
!= 2 && version
!= 3 && version
!= 4)
5371 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5373 hdrptr
++; /* Skip max_ops_per_insn. */
5374 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5376 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5377 if (opcode_base
== 0)
5380 hdrptr
+= opcode_base
- 1;
5385 /* Skip over dirname table. */
5386 while (*hdrptr
!= '\0')
5388 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5392 hdrptr
++; /* Skip the NUL at the end of the table. */
5394 /* Now skip over preceding filename table entries. */
5395 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5397 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5398 SKIP_ULEB (hdrptr
, end
);
5399 SKIP_ULEB (hdrptr
, end
);
5400 SKIP_ULEB (hdrptr
, end
);
5402 if (hdrptr
>= end
|| *hdrptr
== '\0')
5406 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5409 READ_ULEB (diridx
, hdrptr
, end
);
5412 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5413 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5414 if (dirtable
>= end
|| *dirtable
== '\0')
5416 *dir_name
= dirtable
;
5421 display_debug_macro (struct dwarf_section
*section
,
5424 unsigned char *start
= section
->start
;
5425 unsigned char *end
= start
+ section
->size
;
5426 unsigned char *curr
= start
;
5427 unsigned char *extended_op_buf
[256];
5429 load_debug_section_with_follow (str
, file
);
5430 load_debug_section_with_follow (line
, file
);
5431 load_debug_section_with_follow (str_index
, file
);
5433 introduce (section
, FALSE
);
5437 unsigned int lineno
, version
, flags
;
5438 unsigned int offset_size
= 4;
5439 const unsigned char *string
;
5440 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5441 unsigned char **extended_ops
= NULL
;
5443 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5444 if (version
!= 4 && version
!= 5)
5446 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5451 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5454 printf (_(" Offset: 0x%lx\n"),
5455 (unsigned long) sec_offset
);
5456 printf (_(" Version: %d\n"), version
);
5457 printf (_(" Offset size: %d\n"), offset_size
);
5460 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5461 printf (_(" Offset into .debug_line: 0x%lx\n"),
5462 (unsigned long) line_offset
);
5466 unsigned int i
, count
, op
;
5469 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5471 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5472 extended_ops
= extended_op_buf
;
5475 printf (_(" Extension opcode arguments:\n"));
5476 for (i
= 0; i
< count
; i
++)
5478 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5479 extended_ops
[op
] = curr
;
5480 READ_ULEB (nargs
, curr
, end
);
5482 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5485 printf (_(" DW_MACRO_%02x arguments: "), op
);
5486 for (n
= 0; n
< nargs
; n
++)
5490 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5491 printf ("%s%s", get_FORM_name (form
),
5492 n
== nargs
- 1 ? "\n" : ", ");
5502 case DW_FORM_block1
:
5503 case DW_FORM_block2
:
5504 case DW_FORM_block4
:
5506 case DW_FORM_string
:
5508 case DW_FORM_sec_offset
:
5511 error (_("Invalid extension opcode form %s\n"),
5512 get_FORM_name (form
));
5528 error (_(".debug_macro section not zero terminated\n"));
5532 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5538 case DW_MACRO_define
:
5539 READ_ULEB (lineno
, curr
, end
);
5541 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5542 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5546 case DW_MACRO_undef
:
5547 READ_ULEB (lineno
, curr
, end
);
5549 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5550 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5554 case DW_MACRO_start_file
:
5556 unsigned int filenum
;
5557 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5559 READ_ULEB (lineno
, curr
, end
);
5560 READ_ULEB (filenum
, curr
, end
);
5562 if ((flags
& 2) == 0)
5563 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5566 = get_line_filename_and_dirname (line_offset
, filenum
,
5568 if (file_name
== NULL
)
5569 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5572 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5574 dir_name
!= NULL
? (const char *) dir_name
: "",
5575 dir_name
!= NULL
? "/" : "", file_name
);
5579 case DW_MACRO_end_file
:
5580 printf (_(" DW_MACRO_end_file\n"));
5583 case DW_MACRO_define_strp
:
5584 READ_ULEB (lineno
, curr
, end
);
5585 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5586 string
= fetch_indirect_string (offset
);
5587 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5591 case DW_MACRO_undef_strp
:
5592 READ_ULEB (lineno
, curr
, end
);
5593 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5594 string
= fetch_indirect_string (offset
);
5595 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5599 case DW_MACRO_import
:
5600 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5601 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5602 (unsigned long) offset
);
5605 case DW_MACRO_define_sup
:
5606 READ_ULEB (lineno
, curr
, end
);
5607 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5608 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5609 lineno
, (unsigned long) offset
);
5612 case DW_MACRO_undef_sup
:
5613 READ_ULEB (lineno
, curr
, end
);
5614 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5615 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5616 lineno
, (unsigned long) offset
);
5619 case DW_MACRO_import_sup
:
5620 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5621 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5622 (unsigned long) offset
);
5625 case DW_MACRO_define_strx
:
5626 case DW_MACRO_undef_strx
:
5627 READ_ULEB (lineno
, curr
, end
);
5628 READ_ULEB (offset
, curr
, end
);
5629 string
= (const unsigned char *)
5630 fetch_indexed_string (offset
, NULL
, offset_size
, FALSE
);
5631 if (op
== DW_MACRO_define_strx
)
5632 printf (" DW_MACRO_define_strx ");
5634 printf (" DW_MACRO_undef_strx ");
5636 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
5637 printf (_("lineno : %d macro : %s\n"),
5642 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
5644 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
5648 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5650 error (_(" Unknown macro opcode %02x seen\n"), op
);
5655 /* Skip over unhandled opcodes. */
5657 unsigned char *desc
= extended_ops
[op
];
5658 READ_ULEB (nargs
, desc
, end
);
5661 printf (_(" DW_MACRO_%02x\n"), op
);
5664 printf (_(" DW_MACRO_%02x -"), op
);
5665 for (n
= 0; n
< nargs
; n
++)
5669 /* DW_FORM_implicit_const is not expected here. */
5670 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5672 = read_and_display_attr_value (0, val
, 0,
5673 start
, curr
, end
, 0, 0, offset_size
,
5674 version
, NULL
, 0, NULL
,
5692 display_debug_abbrev (struct dwarf_section
*section
,
5693 void *file ATTRIBUTE_UNUSED
)
5695 abbrev_entry
*entry
;
5696 unsigned char *start
= section
->start
;
5697 unsigned char *end
= start
+ section
->size
;
5699 introduce (section
, FALSE
);
5703 unsigned char *last
;
5708 start
= process_abbrev_section (start
, end
);
5710 if (first_abbrev
== NULL
)
5713 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5715 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5719 printf (" %ld %s [%s]\n",
5721 get_TAG_name (entry
->tag
),
5722 entry
->children
? _("has children") : _("no children"));
5724 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5726 printf (" %-18s %s",
5727 get_AT_name (attr
->attribute
),
5728 get_FORM_name (attr
->form
));
5729 if (attr
->form
== DW_FORM_implicit_const
)
5730 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5742 /* Return true when ADDR is the maximum address, when addresses are
5743 POINTER_SIZE bytes long. */
5746 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5748 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5749 return ((addr
& mask
) == mask
);
5752 /* Display a view pair list starting at *VSTART_PTR and ending at
5753 VLISTEND within SECTION. */
5756 display_view_pair_list (struct dwarf_section
*section
,
5757 unsigned char **vstart_ptr
,
5758 unsigned int debug_info_entry
,
5759 unsigned char *vlistend
)
5761 unsigned char *vstart
= *vstart_ptr
;
5762 unsigned char *section_end
= section
->start
+ section
->size
;
5763 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5765 if (vlistend
< section_end
)
5766 section_end
= vlistend
;
5770 while (vstart
< section_end
)
5772 dwarf_vma off
= vstart
- section
->start
;
5773 dwarf_vma vbegin
, vend
;
5775 READ_ULEB (vbegin
, vstart
, section_end
);
5776 if (vstart
== section_end
)
5779 READ_ULEB (vend
, vstart
, section_end
);
5780 printf (" %8.8lx ", (unsigned long) off
);
5782 print_dwarf_view (vbegin
, pointer_size
, 1);
5783 print_dwarf_view (vend
, pointer_size
, 1);
5784 printf (_("location view pair\n"));
5788 *vstart_ptr
= vstart
;
5791 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5794 display_loc_list (struct dwarf_section
*section
,
5795 unsigned char **start_ptr
,
5796 unsigned int debug_info_entry
,
5798 dwarf_vma base_address
,
5799 unsigned char **vstart_ptr
,
5802 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5803 unsigned char *section_end
= section
->start
+ section
->size
;
5804 unsigned long cu_offset
;
5805 unsigned int pointer_size
;
5806 unsigned int offset_size
;
5811 unsigned short length
;
5812 int need_frame_base
;
5814 if (debug_info_entry
>= num_debug_info_entries
)
5816 warn (_("No debug information available for loc lists of entry: %u\n"),
5821 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5822 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5823 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5824 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5826 if (pointer_size
< 2 || pointer_size
> 8)
5828 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5829 pointer_size
, debug_info_entry
);
5835 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5836 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5838 if (start
+ 2 * pointer_size
> section_end
)
5840 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5841 (unsigned long) offset
);
5845 printf (" %8.8lx ", (unsigned long) off
);
5847 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5848 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5850 if (begin
== 0 && end
== 0)
5852 /* PR 18374: In a object file we can have a location list that
5853 starts with a begin and end of 0 because there are relocations
5854 that need to be applied to the addresses. Actually applying
5855 the relocations now does not help as they will probably resolve
5856 to 0, since the object file has not been fully linked. Real
5857 end of list markers will not have any relocations against them. */
5858 if (! reloc_at (section
, off
)
5859 && ! reloc_at (section
, off
+ pointer_size
))
5861 printf (_("<End of list>\n"));
5866 /* Check base address specifiers. */
5867 if (is_max_address (begin
, pointer_size
)
5868 && !is_max_address (end
, pointer_size
))
5871 print_dwarf_vma (begin
, pointer_size
);
5872 print_dwarf_vma (end
, pointer_size
);
5873 printf (_("(base address)\n"));
5879 off
= offset
+ (vstart
- *start_ptr
);
5881 READ_ULEB (vbegin
, vstart
, section_end
);
5882 print_dwarf_view (vbegin
, pointer_size
, 1);
5884 READ_ULEB (vend
, vstart
, section_end
);
5885 print_dwarf_view (vend
, pointer_size
, 1);
5887 printf (_("views at %8.8lx for:\n %*s "),
5888 (unsigned long) off
, 8, "");
5891 if (start
+ 2 > section_end
)
5893 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5894 (unsigned long) offset
);
5898 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5900 if (start
+ length
> section_end
)
5902 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5903 (unsigned long) offset
);
5907 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5908 print_dwarf_vma (end
+ base_address
, pointer_size
);
5911 need_frame_base
= decode_location_expression (start
,
5916 cu_offset
, section
);
5919 if (need_frame_base
&& !has_frame_base
)
5920 printf (_(" [without DW_AT_frame_base]"));
5922 if (begin
== end
&& vbegin
== vend
)
5923 fputs (_(" (start == end)"), stdout
);
5924 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5925 fputs (_(" (start > end)"), stdout
);
5933 *vstart_ptr
= vstart
;
5936 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5939 display_loclists_list (struct dwarf_section
*section
,
5940 unsigned char **start_ptr
,
5941 unsigned int debug_info_entry
,
5943 dwarf_vma base_address
,
5944 unsigned char **vstart_ptr
,
5947 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5948 unsigned char *section_end
= section
->start
+ section
->size
;
5949 unsigned long cu_offset
;
5950 unsigned int pointer_size
;
5951 unsigned int offset_size
;
5954 /* Initialize it due to a false compiler warning. */
5955 dwarf_vma begin
= -1, vbegin
= -1;
5956 dwarf_vma end
= -1, vend
= -1;
5958 int need_frame_base
;
5960 if (debug_info_entry
>= num_debug_info_entries
)
5962 warn (_("No debug information available for "
5963 "loclists lists of entry: %u\n"),
5968 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5969 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5970 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5971 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5973 if (pointer_size
< 2 || pointer_size
> 8)
5975 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5976 pointer_size
, debug_info_entry
);
5982 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5983 enum dwarf_location_list_entry_type llet
;
5985 if (start
+ 1 > section_end
)
5987 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5988 (unsigned long) offset
);
5992 printf (" %8.8lx ", (unsigned long) off
);
5994 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5996 if (vstart
&& llet
== DW_LLE_offset_pair
)
5998 off
= offset
+ (vstart
- *start_ptr
);
6000 READ_ULEB (vbegin
, vstart
, section_end
);
6001 print_dwarf_view (vbegin
, pointer_size
, 1);
6003 READ_ULEB (vend
, vstart
, section_end
);
6004 print_dwarf_view (vend
, pointer_size
, 1);
6006 printf (_("views at %8.8lx for:\n %*s "),
6007 (unsigned long) off
, 8, "");
6012 case DW_LLE_end_of_list
:
6013 printf (_("<End of list>\n"));
6015 case DW_LLE_offset_pair
:
6016 READ_ULEB (begin
, start
, section_end
);
6017 READ_ULEB (end
, start
, section_end
);
6019 case DW_LLE_base_address
:
6020 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6022 print_dwarf_vma (base_address
, pointer_size
);
6023 printf (_("(base address)\n"));
6025 #ifdef DW_LLE_view_pair
6026 case DW_LLE_view_pair
:
6028 printf (_("View pair entry in loclist with locviews attribute\n"));
6029 READ_ULEB (vbegin
, start
, section_end
);
6030 print_dwarf_view (vbegin
, pointer_size
, 1);
6032 READ_ULEB (vend
, start
, section_end
);
6033 print_dwarf_view (vend
, pointer_size
, 1);
6035 printf (_("views for:\n"));
6039 error (_("Invalid location list entry type %d\n"), llet
);
6042 if (llet
== DW_LLE_end_of_list
)
6044 if (llet
!= DW_LLE_offset_pair
)
6047 if (start
+ 2 > section_end
)
6049 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6050 (unsigned long) offset
);
6054 READ_ULEB (length
, start
, section_end
);
6056 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6057 print_dwarf_vma (end
+ base_address
, pointer_size
);
6060 need_frame_base
= decode_location_expression (start
,
6065 cu_offset
, section
);
6068 if (need_frame_base
&& !has_frame_base
)
6069 printf (_(" [without DW_AT_frame_base]"));
6071 if (begin
== end
&& vbegin
== vend
)
6072 fputs (_(" (start == end)"), stdout
);
6073 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6074 fputs (_(" (start > end)"), stdout
);
6082 if (vbegin
!= vm1
|| vend
!= vm1
)
6083 printf (_("Trailing view pair not used in a range"));
6086 *vstart_ptr
= vstart
;
6089 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6090 right-adjusted in a field of length LEN, and followed by a space. */
6093 print_addr_index (unsigned int idx
, unsigned int len
)
6095 static char buf
[15];
6096 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6097 printf ("%*s ", len
, buf
);
6100 /* Display a location list from a .dwo section. It uses address indexes rather
6101 than embedded addresses. This code closely follows display_loc_list, but the
6102 two are sufficiently different that combining things is very ugly. */
6105 display_loc_list_dwo (struct dwarf_section
*section
,
6106 unsigned char **start_ptr
,
6107 unsigned int debug_info_entry
,
6109 unsigned char **vstart_ptr
,
6112 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6113 unsigned char *section_end
= section
->start
+ section
->size
;
6114 unsigned long cu_offset
;
6115 unsigned int pointer_size
;
6116 unsigned int offset_size
;
6119 unsigned short length
;
6120 int need_frame_base
;
6123 if (debug_info_entry
>= num_debug_info_entries
)
6125 warn (_("No debug information for loc lists of entry: %u\n"),
6130 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6131 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6132 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6133 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6135 if (pointer_size
< 2 || pointer_size
> 8)
6137 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6138 pointer_size
, debug_info_entry
);
6144 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6146 if (start
>= section_end
)
6148 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6149 (unsigned long) offset
);
6153 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6166 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6168 READ_ULEB (view
, vstart
, section_end
);
6169 print_dwarf_view (view
, 8, 1);
6171 READ_ULEB (view
, vstart
, section_end
);
6172 print_dwarf_view (view
, 8, 1);
6174 printf (_("views at %8.8lx for:\n %*s "),
6175 (unsigned long) off
, 8, "");
6183 case 0: /* A terminating entry. */
6185 *vstart_ptr
= vstart
;
6186 printf (_("<End of list>\n"));
6188 case 1: /* A base-address entry. */
6189 READ_ULEB (idx
, start
, section_end
);
6190 print_addr_index (idx
, 8);
6191 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6192 printf (_("(base address selection entry)\n"));
6194 case 2: /* A start/end entry. */
6195 READ_ULEB (idx
, start
, section_end
);
6196 print_addr_index (idx
, 8);
6197 READ_ULEB (idx
, start
, section_end
);
6198 print_addr_index (idx
, 8);
6200 case 3: /* A start/length entry. */
6201 READ_ULEB (idx
, start
, section_end
);
6202 print_addr_index (idx
, 8);
6203 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6204 printf ("%08x ", idx
);
6206 case 4: /* An offset pair entry. */
6207 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6208 printf ("%08x ", idx
);
6209 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6210 printf ("%08x ", idx
);
6213 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6215 *vstart_ptr
= vstart
;
6219 if (start
+ 2 > section_end
)
6221 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6222 (unsigned long) offset
);
6226 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6227 if (start
+ length
> section_end
)
6229 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6230 (unsigned long) offset
);
6235 need_frame_base
= decode_location_expression (start
,
6240 cu_offset
, section
);
6243 if (need_frame_base
&& !has_frame_base
)
6244 printf (_(" [without DW_AT_frame_base]"));
6252 *vstart_ptr
= vstart
;
6255 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6258 static dwarf_vma
*loc_offsets
, *loc_views
;
6261 loc_offsets_compar (const void *ap
, const void *bp
)
6263 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6264 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6266 int ret
= (a
> b
) - (b
> a
);
6270 a
= loc_views
[*(const unsigned int *) ap
];
6271 b
= loc_views
[*(const unsigned int *) bp
];
6273 ret
= (a
> b
) - (b
> a
);
6279 display_debug_loc (struct dwarf_section
*section
, void *file
)
6281 unsigned char *start
= section
->start
, *vstart
= NULL
;
6282 unsigned long bytes
;
6283 unsigned char *section_begin
= start
;
6284 unsigned int num_loc_list
= 0;
6285 unsigned long last_offset
= 0;
6286 unsigned long last_view
= 0;
6287 unsigned int first
= 0;
6290 int seen_first_offset
= 0;
6291 int locs_sorted
= 1;
6292 unsigned char *next
= start
, *vnext
= vstart
;
6293 unsigned int *array
= NULL
;
6294 const char *suffix
= strrchr (section
->name
, '.');
6295 bfd_boolean is_dwo
= FALSE
;
6296 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6297 dwarf_vma expected_start
= 0;
6299 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6302 bytes
= section
->size
;
6306 printf (_("\nThe %s section is empty.\n"), section
->name
);
6312 unsigned char *hdrptr
= section_begin
;
6313 dwarf_vma ll_length
;
6314 unsigned short ll_version
;
6315 unsigned char *end
= section_begin
+ section
->size
;
6316 unsigned char address_size
, segment_selector_size
;
6317 uint32_t offset_entry_count
;
6319 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6320 if (ll_length
== 0xffffffff)
6321 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6323 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6324 if (ll_version
!= 5)
6326 warn (_("The %s section contains corrupt or "
6327 "unsupported version number: %d.\n"),
6328 section
->name
, ll_version
);
6332 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6334 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6335 if (segment_selector_size
!= 0)
6337 warn (_("The %s section contains "
6338 "unsupported segment selector size: %d.\n"),
6339 section
->name
, segment_selector_size
);
6343 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6344 if (offset_entry_count
!= 0)
6346 warn (_("The %s section contains "
6347 "unsupported offset entry count: %d.\n"),
6348 section
->name
, offset_entry_count
);
6352 expected_start
= hdrptr
- section_begin
;
6355 if (load_debug_info (file
) == 0)
6357 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6362 /* Check the order of location list in .debug_info section. If
6363 offsets of location lists are in the ascending order, we can
6364 use `debug_information' directly. */
6365 for (i
= 0; i
< num_debug_info_entries
; i
++)
6369 num
= debug_information
[i
].num_loc_offsets
;
6370 if (num
> num_loc_list
)
6373 /* Check if we can use `debug_information' directly. */
6374 if (locs_sorted
&& num
!= 0)
6376 if (!seen_first_offset
)
6378 /* This is the first location list. */
6379 last_offset
= debug_information
[i
].loc_offsets
[0];
6380 last_view
= debug_information
[i
].loc_views
[0];
6382 seen_first_offset
= 1;
6388 for (; j
< num
; j
++)
6391 debug_information
[i
].loc_offsets
[j
]
6392 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6393 && last_view
> debug_information
[i
].loc_views
[j
]))
6398 last_offset
= debug_information
[i
].loc_offsets
[j
];
6399 last_view
= debug_information
[i
].loc_views
[j
];
6404 if (!seen_first_offset
)
6405 error (_("No location lists in .debug_info section!\n"));
6407 if (debug_information
[first
].num_loc_offsets
> 0
6408 && debug_information
[first
].loc_offsets
[0] != expected_start
6409 && debug_information
[first
].loc_views
[0] != expected_start
)
6410 warn (_("Location lists in %s section start at 0x%s\n"),
6412 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6415 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6417 introduce (section
, FALSE
);
6419 if (reloc_at (section
, 0))
6420 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6422 printf (_(" Offset Begin End Expression\n"));
6424 seen_first_offset
= 0;
6425 for (i
= first
; i
< num_debug_info_entries
; i
++)
6427 dwarf_vma offset
, voffset
;
6428 dwarf_vma base_address
;
6434 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6436 loc_offsets
= debug_information
[i
].loc_offsets
;
6437 loc_views
= debug_information
[i
].loc_views
;
6438 qsort (array
, debug_information
[i
].num_loc_offsets
,
6439 sizeof (*array
), loc_offsets_compar
);
6442 int adjacent_view_loclists
= 1;
6443 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6445 j
= locs_sorted
? k
: array
[k
];
6447 && (debug_information
[i
].loc_offsets
[locs_sorted
6448 ? k
- 1 : array
[k
- 1]]
6449 == debug_information
[i
].loc_offsets
[j
])
6450 && (debug_information
[i
].loc_views
[locs_sorted
6451 ? k
- 1 : array
[k
- 1]]
6452 == debug_information
[i
].loc_views
[j
]))
6454 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6455 offset
= debug_information
[i
].loc_offsets
[j
];
6456 next
= section_begin
+ offset
;
6457 voffset
= debug_information
[i
].loc_views
[j
];
6459 vnext
= section_begin
+ voffset
;
6462 base_address
= debug_information
[i
].base_address
;
6464 if (vnext
&& vnext
< next
)
6467 display_view_pair_list (section
, &vstart
, i
, next
);
6472 if (!seen_first_offset
|| !adjacent_view_loclists
)
6473 seen_first_offset
= 1;
6477 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6478 (unsigned long) (start
- section_begin
),
6479 (unsigned long) offset
);
6480 else if (start
> next
)
6481 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6482 (unsigned long) (start
- section_begin
),
6483 (unsigned long) offset
);
6488 if (offset
>= bytes
)
6490 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6491 (unsigned long) offset
);
6495 if (vnext
&& voffset
>= bytes
)
6497 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6498 (unsigned long) voffset
);
6505 display_loc_list_dwo (section
, &start
, i
, offset
,
6506 &vstart
, has_frame_base
);
6508 display_loc_list (section
, &start
, i
, offset
, base_address
,
6509 &vstart
, has_frame_base
);
6514 warn (_("DWO is not yet supported.\n"));
6516 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6517 &vstart
, has_frame_base
);
6520 /* FIXME: this arrangement is quite simplistic. Nothing
6521 requires locview lists to be adjacent to corresponding
6522 loclists, and a single loclist could be augmented by
6523 different locview lists, and vice-versa, unlikely as it
6524 is that it would make sense to do so. Hopefully we'll
6525 have view pair support built into loclists before we ever
6526 need to address all these possibilities. */
6527 if (adjacent_view_loclists
&& vnext
6528 && vnext
!= start
&& vstart
!= next
)
6530 adjacent_view_loclists
= 0;
6531 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6534 if (vnext
&& vnext
== start
)
6535 display_view_pair_list (section
, &start
, i
, vstart
);
6539 if (start
< section
->start
+ section
->size
)
6540 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6541 "There are %ld unused bytes at the end of section %s\n",
6542 (long) (section
->start
+ section
->size
- start
)),
6543 (long) (section
->start
+ section
->size
- start
), section
->name
);
6550 display_debug_str (struct dwarf_section
*section
,
6551 void *file ATTRIBUTE_UNUSED
)
6553 unsigned char *start
= section
->start
;
6554 unsigned long bytes
= section
->size
;
6555 dwarf_vma addr
= section
->address
;
6559 printf (_("\nThe %s section is empty.\n"), section
->name
);
6563 introduce (section
, FALSE
);
6571 lbytes
= (bytes
> 16 ? 16 : bytes
);
6573 printf (" 0x%8.8lx ", (unsigned long) addr
);
6575 for (j
= 0; j
< 16; j
++)
6578 printf ("%2.2x", start
[j
]);
6586 for (j
= 0; j
< lbytes
; j
++)
6589 if (k
>= ' ' && k
< 0x80)
6608 display_debug_info (struct dwarf_section
*section
, void *file
)
6610 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6614 display_debug_types (struct dwarf_section
*section
, void *file
)
6616 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6620 display_trace_info (struct dwarf_section
*section
, void *file
)
6622 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6626 display_debug_aranges (struct dwarf_section
*section
,
6627 void *file ATTRIBUTE_UNUSED
)
6629 unsigned char *start
= section
->start
;
6630 unsigned char *end
= start
+ section
->size
;
6632 introduce (section
, FALSE
);
6634 /* It does not matter if this load fails,
6635 we test for that later on. */
6636 load_debug_info (file
);
6640 unsigned char *hdrptr
;
6641 DWARF2_Internal_ARange arange
;
6642 unsigned char *addr_ranges
;
6645 unsigned long sec_off
;
6646 unsigned char address_size
;
6648 unsigned int offset_size
;
6649 unsigned int initial_length_size
;
6653 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6654 if (arange
.ar_length
== 0xffffffff)
6656 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6658 initial_length_size
= 12;
6663 initial_length_size
= 4;
6666 sec_off
= hdrptr
- section
->start
;
6667 if (sec_off
+ arange
.ar_length
< sec_off
6668 || sec_off
+ arange
.ar_length
> section
->size
)
6670 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6672 sec_off
- initial_length_size
,
6673 dwarf_vmatoa ("x", arange
.ar_length
));
6677 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6678 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6680 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6681 && num_debug_info_entries
> 0
6682 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6683 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6684 (unsigned long) arange
.ar_info_offset
, section
->name
);
6686 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6687 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6689 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6691 /* PR 19872: A version number of 0 probably means that there is
6692 padding at the end of the .debug_aranges section. Gold puts
6693 it there when performing an incremental link, for example.
6694 So do not generate a warning in this case. */
6695 if (arange
.ar_version
)
6696 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6700 printf (_(" Length: %ld\n"),
6701 (long) arange
.ar_length
);
6702 printf (_(" Version: %d\n"), arange
.ar_version
);
6703 printf (_(" Offset into .debug_info: 0x%lx\n"),
6704 (unsigned long) arange
.ar_info_offset
);
6705 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6706 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6708 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6710 /* PR 17512: file: 001-108546-0.001:0.1. */
6711 if (address_size
== 0 || address_size
> 8)
6713 error (_("Invalid address size in %s section!\n"),
6718 /* The DWARF spec does not require that the address size be a power
6719 of two, but we do. This will have to change if we ever encounter
6720 an uneven architecture. */
6721 if ((address_size
& (address_size
- 1)) != 0)
6723 warn (_("Pointer size + Segment size is not a power of two.\n"));
6727 if (address_size
> 4)
6728 printf (_("\n Address Length\n"));
6730 printf (_("\n Address Length\n"));
6732 addr_ranges
= hdrptr
;
6734 /* Must pad to an alignment boundary that is twice the address size. */
6735 excess
= (hdrptr
- start
) % (2 * address_size
);
6737 addr_ranges
+= (2 * address_size
) - excess
;
6739 start
+= arange
.ar_length
+ initial_length_size
;
6741 while (addr_ranges
+ 2 * address_size
<= start
)
6743 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6744 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6747 print_dwarf_vma (address
, address_size
);
6748 print_dwarf_vma (length
, address_size
);
6758 /* Comparison function for qsort. */
6760 comp_addr_base (const void * v0
, const void * v1
)
6762 debug_info
*info0
= *(debug_info
**) v0
;
6763 debug_info
*info1
= *(debug_info
**) v1
;
6764 return info0
->addr_base
- info1
->addr_base
;
6767 /* Display the debug_addr section. */
6769 display_debug_addr (struct dwarf_section
*section
,
6772 debug_info
**debug_addr_info
;
6773 unsigned char *entry
;
6778 if (section
->size
== 0)
6780 printf (_("\nThe %s section is empty.\n"), section
->name
);
6784 if (load_debug_info (file
) == 0)
6786 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6791 introduce (section
, FALSE
);
6793 /* PR 17531: file: cf38d01b.
6794 We use xcalloc because a corrupt file may not have initialised all of the
6795 fields in the debug_info structure, which means that the sort below might
6796 try to move uninitialised data. */
6797 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6798 sizeof (debug_info
*));
6801 for (i
= 0; i
< num_debug_info_entries
; i
++)
6802 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6804 /* PR 17531: file: cf38d01b. */
6805 if (debug_information
[i
].addr_base
>= section
->size
)
6806 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6807 (unsigned long) debug_information
[i
].addr_base
, i
);
6809 debug_addr_info
[count
++] = debug_information
+ i
;
6812 /* Add a sentinel to make iteration convenient. */
6813 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6814 debug_addr_info
[count
]->addr_base
= section
->size
;
6815 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6817 for (i
= 0; i
< count
; i
++)
6820 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6822 printf (_(" For compilation unit at offset 0x%s:\n"),
6823 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6825 printf (_("\tIndex\tAddress\n"));
6826 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6827 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6831 dwarf_vma base
= byte_get (entry
, address_size
);
6832 printf (_("\t%d:\t"), idx
);
6833 print_dwarf_vma (base
, address_size
);
6835 entry
+= address_size
;
6841 free (debug_addr_info
);
6845 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6848 display_debug_str_offsets (struct dwarf_section
*section
,
6849 void *file ATTRIBUTE_UNUSED
)
6853 if (section
->size
== 0)
6855 printf (_("\nThe %s section is empty.\n"), section
->name
);
6859 unsigned char *start
= section
->start
;
6860 unsigned char *end
= start
+ section
->size
;
6861 unsigned char *curr
= start
;
6863 const char * suffix
= strrchr (section
->name
, '.');
6864 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
6867 load_debug_section_with_follow (str_dwo
, file
);
6869 load_debug_section_with_follow (str
, file
);
6871 introduce (section
, FALSE
);
6876 dwarf_vma entry_length
;
6878 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
6879 /* FIXME: We assume that this means 64-bit DWARF is being used. */
6880 if (length
== 0xffffffff)
6882 SAFE_BYTE_GET (length
, curr
, 8, end
);
6890 /* This is probably an old style .debug_str_offset section which
6891 just contains offsets and no header (and the first offset is 0). */
6892 length
= section
->size
;
6893 curr
= section
->start
;
6895 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6896 printf (_(" Index Offset [String]\n"));
6901 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6903 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
6906 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
6908 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
6910 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6911 printf (_(" Version: %#lx\n"), (unsigned long) version
);
6912 printf (_(" Index Offset [String]\n"));
6915 for (idx
= 0; length
>= entry_length
&& curr
< end
; idx
++)
6918 const unsigned char * string
;
6920 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, end
);
6922 string
= (const unsigned char *)
6923 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
6925 string
= fetch_indirect_string (offset
);
6927 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
6935 /* Each debug_information[x].range_lists[y] gets this representation for
6936 sorting purposes. */
6940 /* The debug_information[x].range_lists[y] value. */
6941 dwarf_vma ranges_offset
;
6943 /* Original debug_information to find parameters of the data. */
6944 debug_info
*debug_info_p
;
6947 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6950 range_entry_compar (const void *ap
, const void *bp
)
6952 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6953 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6954 const dwarf_vma a
= a_re
->ranges_offset
;
6955 const dwarf_vma b
= b_re
->ranges_offset
;
6957 return (a
> b
) - (b
> a
);
6961 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6962 unsigned int pointer_size
, unsigned long offset
,
6963 unsigned long base_address
)
6965 while (start
< finish
)
6970 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6971 if (start
>= finish
)
6973 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6976 printf (" %8.8lx ", offset
);
6978 if (begin
== 0 && end
== 0)
6980 printf (_("<End of list>\n"));
6984 /* Check base address specifiers. */
6985 if (is_max_address (begin
, pointer_size
)
6986 && !is_max_address (end
, pointer_size
))
6989 print_dwarf_vma (begin
, pointer_size
);
6990 print_dwarf_vma (end
, pointer_size
);
6991 printf ("(base address)\n");
6995 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6996 print_dwarf_vma (end
+ base_address
, pointer_size
);
6999 fputs (_("(start == end)"), stdout
);
7000 else if (begin
> end
)
7001 fputs (_("(start > end)"), stdout
);
7008 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7009 unsigned int pointer_size
, unsigned long offset
,
7010 unsigned long base_address
)
7012 unsigned char *next
= start
;
7016 unsigned long off
= offset
+ (start
- next
);
7017 enum dwarf_range_list_entry rlet
;
7018 /* Initialize it due to a false compiler warning. */
7019 dwarf_vma begin
= -1, length
, end
= -1;
7021 if (start
+ 1 > finish
)
7023 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7028 printf (" %8.8lx ", off
);
7030 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7034 case DW_RLE_end_of_list
:
7035 printf (_("<End of list>\n"));
7037 case DW_RLE_base_address
:
7038 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7039 print_dwarf_vma (base_address
, pointer_size
);
7040 printf (_("(base address)\n"));
7042 case DW_RLE_start_length
:
7043 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7044 READ_ULEB (length
, start
, finish
);
7045 end
= begin
+ length
;
7047 case DW_RLE_offset_pair
:
7048 READ_ULEB (begin
, start
, finish
);
7049 READ_ULEB (end
, start
, finish
);
7051 case DW_RLE_start_end
:
7052 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7053 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7056 error (_("Invalid range list entry type %d\n"), rlet
);
7057 rlet
= DW_RLE_end_of_list
;
7060 if (rlet
== DW_RLE_end_of_list
)
7062 if (rlet
== DW_RLE_base_address
)
7065 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7066 print_dwarf_vma (end
+ base_address
, pointer_size
);
7069 fputs (_("(start == end)"), stdout
);
7070 else if (begin
> end
)
7071 fputs (_("(start > end)"), stdout
);
7078 display_debug_ranges (struct dwarf_section
*section
,
7079 void *file ATTRIBUTE_UNUSED
)
7081 unsigned char *start
= section
->start
;
7082 unsigned char *last_start
= start
;
7083 unsigned long bytes
= section
->size
;
7084 unsigned char *section_begin
= start
;
7085 unsigned char *finish
= start
+ bytes
;
7086 unsigned int num_range_list
, i
;
7087 struct range_entry
*range_entries
, *range_entry_fill
;
7088 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7089 /* Initialize it due to a false compiler warning. */
7090 unsigned char address_size
= 0;
7091 dwarf_vma last_offset
= 0;
7095 printf (_("\nThe %s section is empty.\n"), section
->name
);
7101 dwarf_vma initial_length
;
7102 unsigned int initial_length_size
;
7103 unsigned char segment_selector_size
;
7104 unsigned int offset_size
, offset_entry_count
;
7105 unsigned short version
;
7107 /* Get and check the length of the block. */
7108 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7110 if (initial_length
== 0xffffffff)
7112 /* This section is 64-bit DWARF 3. */
7113 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7115 initial_length_size
= 12;
7120 initial_length_size
= 4;
7123 if (initial_length
+ initial_length_size
> section
->size
)
7125 /* If the length field has a relocation against it, then we should
7126 not complain if it is inaccurate (and probably negative).
7127 It is copied from .debug_line handling code. */
7128 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7130 initial_length
= (finish
- start
) - initial_length_size
;
7134 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7135 (long) initial_length
);
7140 /* Get and check the version number. */
7141 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7145 warn (_("Only DWARF version 5 debug_rnglists info "
7146 "is currently supported.\n"));
7150 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7152 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7153 if (segment_selector_size
!= 0)
7155 warn (_("The %s section contains "
7156 "unsupported segment selector size: %d.\n"),
7157 section
->name
, segment_selector_size
);
7161 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7162 if (offset_entry_count
!= 0)
7164 warn (_("The %s section contains "
7165 "unsupported offset entry count: %u.\n"),
7166 section
->name
, offset_entry_count
);
7171 if (load_debug_info (file
) == 0)
7173 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7179 for (i
= 0; i
< num_debug_info_entries
; i
++)
7180 num_range_list
+= debug_information
[i
].num_range_lists
;
7182 if (num_range_list
== 0)
7184 /* This can happen when the file was compiled with -gsplit-debug
7185 which removes references to range lists from the primary .o file. */
7186 printf (_("No range lists in .debug_info section.\n"));
7190 range_entries
= (struct range_entry
*)
7191 xmalloc (sizeof (*range_entries
) * num_range_list
);
7192 range_entry_fill
= range_entries
;
7194 for (i
= 0; i
< num_debug_info_entries
; i
++)
7196 debug_info
*debug_info_p
= &debug_information
[i
];
7199 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7201 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7202 range_entry_fill
->debug_info_p
= debug_info_p
;
7207 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7208 range_entry_compar
);
7210 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7211 warn (_("Range lists in %s section start at 0x%lx\n"),
7212 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7214 introduce (section
, FALSE
);
7216 printf (_(" Offset Begin End\n"));
7218 for (i
= 0; i
< num_range_list
; i
++)
7220 struct range_entry
*range_entry
= &range_entries
[i
];
7221 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7222 unsigned int pointer_size
;
7224 unsigned char *next
;
7225 dwarf_vma base_address
;
7227 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7228 offset
= range_entry
->ranges_offset
;
7229 next
= section_begin
+ offset
;
7230 base_address
= debug_info_p
->base_address
;
7232 /* PR 17512: file: 001-101485-0.001:0.1. */
7233 if (pointer_size
< 2 || pointer_size
> 8)
7235 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7236 pointer_size
, (unsigned long) offset
);
7240 if (next
< section_begin
|| next
>= finish
)
7242 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7243 (unsigned long) offset
, i
);
7247 /* If multiple DWARF entities reference the same range then we will
7248 have multiple entries in the `range_entries' list for the same
7249 offset. Thanks to the sort above these will all be consecutive in
7250 the `range_entries' list, so we can easily ignore duplicates
7252 if (i
> 0 && last_offset
== offset
)
7254 last_offset
= offset
;
7256 if (dwarf_check
!= 0 && i
> 0)
7259 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7260 (unsigned long) (start
- section_begin
),
7261 (unsigned long) (next
- section_begin
), section
->name
);
7262 else if (start
> next
)
7264 if (next
== last_start
)
7266 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7267 (unsigned long) (start
- section_begin
),
7268 (unsigned long) (next
- section_begin
), section
->name
);
7275 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7276 (start
, finish
, pointer_size
, offset
, base_address
);
7280 free (range_entries
);
7285 typedef struct Frame_Chunk
7287 struct Frame_Chunk
*next
;
7288 unsigned char *chunk_start
;
7290 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7291 short int *col_type
;
7294 unsigned int code_factor
;
7298 unsigned int cfa_reg
;
7299 dwarf_vma cfa_offset
;
7301 unsigned char fde_encoding
;
7302 unsigned char cfa_exp
;
7303 unsigned char ptr_size
;
7304 unsigned char segment_size
;
7308 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7309 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7310 static const char *const *dwarf_regnames
;
7311 static unsigned int dwarf_regnames_count
;
7314 /* A marker for a col_type that means this column was never referenced
7315 in the frame info. */
7316 #define DW_CFA_unreferenced (-1)
7318 /* Return 0 if no more space is needed, 1 if more space is needed,
7319 -1 for invalid reg. */
7322 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7324 unsigned int prev
= fc
->ncols
;
7326 if (reg
< (unsigned int) fc
->ncols
)
7329 if (dwarf_regnames_count
> 0
7330 && reg
> dwarf_regnames_count
)
7333 fc
->ncols
= reg
+ 1;
7334 /* PR 17512: file: 10450-2643-0.004.
7335 If reg == -1 then this can happen... */
7339 /* PR 17512: file: 2844a11d. */
7340 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7342 error (_("Unfeasibly large register number: %u\n"), reg
);
7344 /* FIXME: 1024 is an arbitrary limit. Increase it if
7345 we ever encounter a valid binary that exceeds it. */
7349 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7350 sizeof (short int));
7351 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7352 /* PR 17512: file:002-10025-0.005. */
7353 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7355 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7361 while (prev
< fc
->ncols
)
7363 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7364 fc
->col_offset
[prev
] = 0;
7370 static const char *const dwarf_regnames_i386
[] =
7372 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7373 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7374 "eip", "eflags", NULL
, /* 8 - 10 */
7375 "st0", "st1", "st2", "st3", /* 11 - 14 */
7376 "st4", "st5", "st6", "st7", /* 15 - 18 */
7377 NULL
, NULL
, /* 19 - 20 */
7378 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7379 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7380 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7381 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7382 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7383 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7384 "tr", "ldtr", /* 48 - 49 */
7385 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7386 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7387 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7388 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7389 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7390 NULL
, NULL
, NULL
, /* 90 - 92 */
7391 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7394 static const char *const dwarf_regnames_iamcu
[] =
7396 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7397 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7398 "eip", "eflags", NULL
, /* 8 - 10 */
7399 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7400 NULL
, NULL
, /* 19 - 20 */
7401 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7402 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7403 NULL
, NULL
, NULL
, /* 37 - 39 */
7404 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7405 "tr", "ldtr", /* 48 - 49 */
7406 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7407 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7408 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7409 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7410 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7411 NULL
, NULL
, NULL
, /* 90 - 92 */
7412 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7416 init_dwarf_regnames_i386 (void)
7418 dwarf_regnames
= dwarf_regnames_i386
;
7419 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7420 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7424 init_dwarf_regnames_iamcu (void)
7426 dwarf_regnames
= dwarf_regnames_iamcu
;
7427 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7428 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7431 static const char *const dwarf_regnames_x86_64
[] =
7433 "rax", "rdx", "rcx", "rbx",
7434 "rsi", "rdi", "rbp", "rsp",
7435 "r8", "r9", "r10", "r11",
7436 "r12", "r13", "r14", "r15",
7438 "xmm0", "xmm1", "xmm2", "xmm3",
7439 "xmm4", "xmm5", "xmm6", "xmm7",
7440 "xmm8", "xmm9", "xmm10", "xmm11",
7441 "xmm12", "xmm13", "xmm14", "xmm15",
7442 "st0", "st1", "st2", "st3",
7443 "st4", "st5", "st6", "st7",
7444 "mm0", "mm1", "mm2", "mm3",
7445 "mm4", "mm5", "mm6", "mm7",
7447 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7448 "fs.base", "gs.base", NULL
, NULL
,
7450 "mxcsr", "fcw", "fsw",
7451 "xmm16", "xmm17", "xmm18", "xmm19",
7452 "xmm20", "xmm21", "xmm22", "xmm23",
7453 "xmm24", "xmm25", "xmm26", "xmm27",
7454 "xmm28", "xmm29", "xmm30", "xmm31",
7455 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7456 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7457 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7458 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7459 NULL
, NULL
, NULL
, /* 115 - 117 */
7460 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7464 init_dwarf_regnames_x86_64 (void)
7466 dwarf_regnames
= dwarf_regnames_x86_64
;
7467 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7468 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7471 static const char *const dwarf_regnames_aarch64
[] =
7473 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7474 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7475 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7476 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7477 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7478 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7479 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7480 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7481 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7482 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7483 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7484 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7485 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7486 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7487 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7488 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7492 init_dwarf_regnames_aarch64 (void)
7494 dwarf_regnames
= dwarf_regnames_aarch64
;
7495 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7496 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7499 static const char *const dwarf_regnames_s390
[] =
7501 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7502 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7503 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7504 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7505 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7506 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7507 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7508 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7509 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7512 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7513 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7517 init_dwarf_regnames_s390 (void)
7519 dwarf_regnames
= dwarf_regnames_s390
;
7520 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7521 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7524 static const char *const dwarf_regnames_riscv
[] =
7526 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7527 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7528 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7529 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7530 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7531 "fs0", "fs1", /* 40 - 41 */
7532 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7533 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7534 "fs10", "fs11", /* 58 - 59 */
7535 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7538 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7539 the large number of CSRs. */
7542 regname_internal_riscv (unsigned int regno
)
7544 const char *name
= NULL
;
7546 /* Lookup in the table first, this covers GPR and FPR. */
7547 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7548 name
= dwarf_regnames_riscv
[regno
];
7549 else if (regno
>= 4096 && regno
<= 8191)
7551 /* This might be a CSR, these live in a sparse number space from 4096
7552 to 8191 These numbers are defined in the RISC-V ELF ABI
7556 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
7557 case VALUE + 4096: name = #NAME; break;
7558 #include "opcode/riscv-opc.h"
7563 static char csr_name
[10];
7564 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7575 init_dwarf_regnames_riscv (void)
7577 dwarf_regnames
= NULL
;
7578 dwarf_regnames_count
= 8192;
7579 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7583 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7585 dwarf_regnames_lookup_func
= NULL
;
7590 init_dwarf_regnames_i386 ();
7594 init_dwarf_regnames_iamcu ();
7600 init_dwarf_regnames_x86_64 ();
7604 init_dwarf_regnames_aarch64 ();
7608 init_dwarf_regnames_s390 ();
7612 init_dwarf_regnames_riscv ();
7620 /* Initialize the DWARF register name lookup state based on the
7621 architecture and specific machine type of a BFD. */
7624 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7627 dwarf_regnames_lookup_func
= NULL
;
7634 case bfd_mach_x86_64
:
7635 case bfd_mach_x86_64_intel_syntax
:
7636 case bfd_mach_x86_64_nacl
:
7637 case bfd_mach_x64_32
:
7638 case bfd_mach_x64_32_intel_syntax
:
7639 case bfd_mach_x64_32_nacl
:
7640 init_dwarf_regnames_x86_64 ();
7644 init_dwarf_regnames_i386 ();
7649 case bfd_arch_iamcu
:
7650 init_dwarf_regnames_iamcu ();
7653 case bfd_arch_aarch64
:
7654 init_dwarf_regnames_aarch64();
7658 init_dwarf_regnames_s390 ();
7661 case bfd_arch_riscv
:
7662 init_dwarf_regnames_riscv ();
7671 regname_internal_by_table_only (unsigned int regno
)
7673 if (dwarf_regnames
!= NULL
7674 && regno
< dwarf_regnames_count
7675 && dwarf_regnames
[regno
] != NULL
)
7676 return dwarf_regnames
[regno
];
7682 regname (unsigned int regno
, int name_only_p
)
7684 static char reg
[64];
7686 const char *name
= NULL
;
7688 if (dwarf_regnames_lookup_func
!= NULL
)
7689 name
= dwarf_regnames_lookup_func (regno
);
7695 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7698 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7703 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7708 if (*max_regs
!= fc
->ncols
)
7709 *max_regs
= fc
->ncols
;
7711 if (*need_col_headers
)
7713 static const char *sloc
= " LOC";
7715 *need_col_headers
= 0;
7717 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7719 for (r
= 0; r
< *max_regs
; r
++)
7720 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7725 printf ("%-5s ", regname (r
, 1));
7731 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7733 strcpy (tmp
, "exp");
7735 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7736 printf ("%-8s ", tmp
);
7738 for (r
= 0; r
< fc
->ncols
; r
++)
7740 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7742 switch (fc
->col_type
[r
])
7744 case DW_CFA_undefined
:
7747 case DW_CFA_same_value
:
7751 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7753 case DW_CFA_val_offset
:
7754 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7756 case DW_CFA_register
:
7757 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7759 case DW_CFA_expression
:
7760 strcpy (tmp
, "exp");
7762 case DW_CFA_val_expression
:
7763 strcpy (tmp
, "vexp");
7766 strcpy (tmp
, "n/a");
7769 printf ("%-5s ", tmp
);
7775 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7777 static unsigned char *
7778 read_cie (unsigned char *start
, unsigned char *end
,
7779 Frame_Chunk
**p_cie
, int *p_version
,
7780 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7784 unsigned char *augmentation_data
= NULL
;
7785 bfd_size_type augmentation_data_len
= 0;
7788 /* PR 17512: file: 001-228113-0.004. */
7792 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7793 memset (fc
, 0, sizeof (Frame_Chunk
));
7795 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7796 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7800 fc
->augmentation
= (char *) start
;
7801 /* PR 17512: file: 001-228113-0.004.
7802 Skip past augmentation name, but avoid running off the end of the data. */
7804 if (* start
++ == '\0')
7808 warn (_("No terminator for augmentation name\n"));
7812 if (strcmp (fc
->augmentation
, "eh") == 0)
7813 start
+= eh_addr_size
;
7817 GET (fc
->ptr_size
, 1);
7818 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7820 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7824 GET (fc
->segment_size
, 1);
7825 /* PR 17512: file: e99d2804. */
7826 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7828 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7832 eh_addr_size
= fc
->ptr_size
;
7836 fc
->ptr_size
= eh_addr_size
;
7837 fc
->segment_size
= 0;
7840 READ_ULEB (fc
->code_factor
, start
, end
);
7841 READ_SLEB (fc
->data_factor
, start
, end
);
7849 READ_ULEB (fc
->ra
, start
, end
);
7852 if (fc
->augmentation
[0] == 'z')
7854 READ_ULEB (augmentation_data_len
, start
, end
);
7855 augmentation_data
= start
;
7856 /* PR 17512: file: 11042-2589-0.004. */
7857 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7859 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7860 dwarf_vmatoa ("x", augmentation_data_len
),
7861 (unsigned long) (end
- start
));
7864 start
+= augmentation_data_len
;
7867 if (augmentation_data_len
)
7871 unsigned char *qend
;
7873 p
= (unsigned char *) fc
->augmentation
+ 1;
7874 q
= augmentation_data
;
7875 qend
= q
+ augmentation_data_len
;
7877 while (p
< end
&& q
< qend
)
7882 q
+= 1 + size_of_encoded_value (*q
);
7884 fc
->fde_encoding
= *q
++;
7893 /* Note - it is OK if this loop terminates with q < qend.
7894 Padding may have been inserted to align the end of the CIE. */
7899 *p_version
= version
;
7902 *p_aug_len
= augmentation_data_len
;
7903 *p_aug
= augmentation_data
;
7908 free (fc
->col_offset
);
7909 free (fc
->col_type
);
7914 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7915 If do_wide is not enabled, then formats the output to fit into 80 columns.
7916 PRINTED contains the number of characters already written to the current
7920 display_data (bfd_size_type printed
,
7921 const unsigned char * data
,
7922 const bfd_size_type len
)
7924 if (do_wide
|| len
< ((80 - printed
) / 3))
7925 for (printed
= 0; printed
< len
; ++printed
)
7926 printf (" %02x", data
[printed
]);
7929 for (printed
= 0; printed
< len
; ++printed
)
7931 if (printed
% (80 / 3) == 0)
7933 printf (" %02x", data
[printed
]);
7938 /* Prints out the contents on the augmentation data array.
7939 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7942 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7946 i
= printf (_(" Augmentation data: "));
7947 display_data (i
, data
, len
);
7951 display_debug_frames (struct dwarf_section
*section
,
7952 void *file ATTRIBUTE_UNUSED
)
7954 unsigned char *start
= section
->start
;
7955 unsigned char *end
= start
+ section
->size
;
7956 unsigned char *section_start
= start
;
7957 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7958 Frame_Chunk
*remembered_state
= NULL
;
7960 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7961 unsigned int max_regs
= 0;
7962 const char *bad_reg
= _("bad register: ");
7963 unsigned int saved_eh_addr_size
= eh_addr_size
;
7965 introduce (section
, FALSE
);
7969 unsigned char *saved_start
;
7970 unsigned char *block_end
;
7975 int need_col_headers
= 1;
7976 unsigned char *augmentation_data
= NULL
;
7977 bfd_size_type augmentation_data_len
= 0;
7978 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7979 unsigned int offset_size
;
7980 unsigned int initial_length_size
;
7981 bfd_boolean all_nops
;
7982 static Frame_Chunk fde_fc
;
7984 saved_start
= start
;
7986 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7990 printf ("\n%08lx ZERO terminator\n\n",
7991 (unsigned long)(saved_start
- section_start
));
7992 /* Skip any zero terminators that directly follow.
7993 A corrupt section size could have loaded a whole
7994 slew of zero filled memory bytes. eg
7995 PR 17512: file: 070-19381-0.004. */
7996 while (start
< end
&& * start
== 0)
8001 if (length
== 0xffffffff)
8003 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8005 initial_length_size
= 12;
8010 initial_length_size
= 4;
8013 block_end
= saved_start
+ length
+ initial_length_size
;
8014 if (block_end
> end
|| block_end
< start
)
8016 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8017 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8018 (unsigned long) (saved_start
- section_start
));
8022 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8024 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8025 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8030 start
= read_cie (start
, end
, &cie
, &version
,
8031 &augmentation_data_len
, &augmentation_data
);
8032 /* PR 17512: file: 027-135133-0.005. */
8039 fc
->chunk_start
= saved_start
;
8040 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8043 if (frame_need_space (fc
, mreg
) < 0)
8045 if (fc
->fde_encoding
)
8046 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8048 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8049 print_dwarf_vma (length
, fc
->ptr_size
);
8050 print_dwarf_vma (cie_id
, offset_size
);
8052 if (do_debug_frames_interp
)
8054 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8055 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8060 printf (" Version: %d\n", version
);
8061 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8064 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8065 printf (" Segment Size: %u\n", fc
->segment_size
);
8067 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8068 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8069 printf (" Return address column: %d\n", fc
->ra
);
8071 if (augmentation_data_len
)
8072 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8079 unsigned char *look_for
;
8080 unsigned long segment_selector
;
8084 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8085 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8088 look_for
= section_start
+ cie_id
;
8090 if (look_for
<= saved_start
)
8092 for (cie
= chunks
; cie
; cie
= cie
->next
)
8093 if (cie
->chunk_start
== look_for
)
8098 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8099 if (cie
->chunk_start
== look_for
)
8103 unsigned int off_size
;
8104 unsigned char *cie_scan
;
8106 cie_scan
= look_for
;
8108 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8109 if (length
== 0xffffffff)
8111 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8118 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8121 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8122 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8127 read_cie (cie_scan
, end
, &cie
, &version
,
8128 &augmentation_data_len
, &augmentation_data
);
8129 /* PR 17512: file: 3450-2098-0.004. */
8132 warn (_("Failed to read CIE information\n"));
8135 cie
->next
= forward_refs
;
8137 cie
->chunk_start
= look_for
;
8138 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8141 if (frame_need_space (cie
, mreg
) < 0)
8143 warn (_("Invalid max register\n"));
8146 if (cie
->fde_encoding
)
8148 = size_of_encoded_value (cie
->fde_encoding
);
8155 memset (fc
, 0, sizeof (Frame_Chunk
));
8159 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8160 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8161 (unsigned long) (saved_start
- section_start
));
8163 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8164 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8165 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8167 warn (_("Invalid max register\n"));
8171 fc
->augmentation
= "";
8172 fc
->fde_encoding
= 0;
8173 fc
->ptr_size
= eh_addr_size
;
8174 fc
->segment_size
= 0;
8178 fc
->ncols
= cie
->ncols
;
8179 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8180 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8181 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8182 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8183 fc
->augmentation
= cie
->augmentation
;
8184 fc
->ptr_size
= cie
->ptr_size
;
8185 eh_addr_size
= cie
->ptr_size
;
8186 fc
->segment_size
= cie
->segment_size
;
8187 fc
->code_factor
= cie
->code_factor
;
8188 fc
->data_factor
= cie
->data_factor
;
8189 fc
->cfa_reg
= cie
->cfa_reg
;
8190 fc
->cfa_offset
= cie
->cfa_offset
;
8192 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8194 warn (_("Invalid max register\n"));
8197 fc
->fde_encoding
= cie
->fde_encoding
;
8200 if (fc
->fde_encoding
)
8201 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8203 segment_selector
= 0;
8204 if (fc
->segment_size
)
8206 if (fc
->segment_size
> sizeof (segment_selector
))
8208 /* PR 17512: file: 9e196b3e. */
8209 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8210 fc
->segment_size
= 4;
8212 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8215 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8217 /* FIXME: It appears that sometimes the final pc_range value is
8218 encoded in less than encoded_ptr_size bytes. See the x86_64
8219 run of the "objcopy on compressed debug sections" test for an
8221 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8223 if (cie
->augmentation
[0] == 'z')
8225 READ_ULEB (augmentation_data_len
, start
, end
);
8226 augmentation_data
= start
;
8227 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8228 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8230 warn (_("Augmentation data too long: 0x%s, "
8231 "expected at most %#lx\n"),
8232 dwarf_vmatoa ("x", augmentation_data_len
),
8233 (unsigned long) (end
- start
));
8235 augmentation_data
= NULL
;
8236 augmentation_data_len
= 0;
8238 start
+= augmentation_data_len
;
8241 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8242 (unsigned long)(saved_start
- section_start
),
8243 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8244 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8245 (unsigned long)(cie
->chunk_start
- section_start
));
8247 if (fc
->segment_size
)
8248 printf ("%04lx:", segment_selector
);
8251 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8252 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8254 if (! do_debug_frames_interp
&& augmentation_data_len
)
8256 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8261 /* At this point, fc is the current chunk, cie (if any) is set, and
8262 we're about to interpret instructions for the chunk. */
8263 /* ??? At present we need to do this always, since this sizes the
8264 fc->col_type and fc->col_offset arrays, which we write into always.
8265 We should probably split the interpreted and non-interpreted bits
8266 into two different routines, since there's so much that doesn't
8267 really overlap between them. */
8268 if (1 || do_debug_frames_interp
)
8270 /* Start by making a pass over the chunk, allocating storage
8271 and taking note of what registers are used. */
8272 unsigned char *tmp
= start
;
8274 while (start
< block_end
)
8276 unsigned int reg
, op
, opa
;
8278 unsigned char * new_start
;
8285 /* Warning: if you add any more cases to this switch, be
8286 sure to add them to the corresponding switch below. */
8289 case DW_CFA_advance_loc
:
8292 SKIP_ULEB (start
, end
);
8293 if (frame_need_space (fc
, opa
) >= 0)
8294 fc
->col_type
[opa
] = DW_CFA_undefined
;
8296 case DW_CFA_restore
:
8297 if (frame_need_space (fc
, opa
) >= 0)
8298 fc
->col_type
[opa
] = DW_CFA_undefined
;
8300 case DW_CFA_set_loc
:
8301 start
+= encoded_ptr_size
;
8303 case DW_CFA_advance_loc1
:
8306 case DW_CFA_advance_loc2
:
8309 case DW_CFA_advance_loc4
:
8312 case DW_CFA_offset_extended
:
8313 case DW_CFA_val_offset
:
8314 READ_ULEB (reg
, start
, end
);
8315 SKIP_ULEB (start
, end
);
8316 if (frame_need_space (fc
, reg
) >= 0)
8317 fc
->col_type
[reg
] = DW_CFA_undefined
;
8319 case DW_CFA_restore_extended
:
8320 READ_ULEB (reg
, start
, end
);
8321 if (frame_need_space (fc
, reg
) >= 0)
8322 fc
->col_type
[reg
] = DW_CFA_undefined
;
8324 case DW_CFA_undefined
:
8325 READ_ULEB (reg
, start
, end
);
8326 if (frame_need_space (fc
, reg
) >= 0)
8327 fc
->col_type
[reg
] = DW_CFA_undefined
;
8329 case DW_CFA_same_value
:
8330 READ_ULEB (reg
, start
, end
);
8331 if (frame_need_space (fc
, reg
) >= 0)
8332 fc
->col_type
[reg
] = DW_CFA_undefined
;
8334 case DW_CFA_register
:
8335 READ_ULEB (reg
, start
, end
);
8336 SKIP_ULEB (start
, end
);
8337 if (frame_need_space (fc
, reg
) >= 0)
8338 fc
->col_type
[reg
] = DW_CFA_undefined
;
8340 case DW_CFA_def_cfa
:
8341 SKIP_ULEB (start
, end
);
8342 SKIP_ULEB (start
, end
);
8344 case DW_CFA_def_cfa_register
:
8345 SKIP_ULEB (start
, end
);
8347 case DW_CFA_def_cfa_offset
:
8348 SKIP_ULEB (start
, end
);
8350 case DW_CFA_def_cfa_expression
:
8351 READ_ULEB (temp
, start
, end
);
8352 new_start
= start
+ temp
;
8353 if (new_start
< start
)
8355 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8361 case DW_CFA_expression
:
8362 case DW_CFA_val_expression
:
8363 READ_ULEB (reg
, start
, end
);
8364 READ_ULEB (temp
, start
, end
);
8365 new_start
= start
+ temp
;
8366 if (new_start
< start
)
8368 /* PR 17512: file:306-192417-0.005. */
8369 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8374 if (frame_need_space (fc
, reg
) >= 0)
8375 fc
->col_type
[reg
] = DW_CFA_undefined
;
8377 case DW_CFA_offset_extended_sf
:
8378 case DW_CFA_val_offset_sf
:
8379 READ_ULEB (reg
, start
, end
);
8380 SKIP_SLEB (start
, end
);
8381 if (frame_need_space (fc
, reg
) >= 0)
8382 fc
->col_type
[reg
] = DW_CFA_undefined
;
8384 case DW_CFA_def_cfa_sf
:
8385 SKIP_ULEB (start
, end
);
8386 SKIP_SLEB (start
, end
);
8388 case DW_CFA_def_cfa_offset_sf
:
8389 SKIP_SLEB (start
, end
);
8391 case DW_CFA_MIPS_advance_loc8
:
8394 case DW_CFA_GNU_args_size
:
8395 SKIP_ULEB (start
, end
);
8397 case DW_CFA_GNU_negative_offset_extended
:
8398 READ_ULEB (reg
, start
, end
);
8399 SKIP_ULEB (start
, end
);
8400 if (frame_need_space (fc
, reg
) >= 0)
8401 fc
->col_type
[reg
] = DW_CFA_undefined
;
8412 /* Now we know what registers are used, make a second pass over
8413 the chunk, this time actually printing out the info. */
8415 while (start
< block_end
)
8417 unsigned char * tmp
;
8419 unsigned long ul
, roffs
;
8420 /* Note: It is tempting to use an unsigned long for 'reg' but there
8421 are various functions, notably frame_space_needed() that assume that
8422 reg is an unsigned int. */
8427 const char *reg_prefix
= "";
8434 /* Make a note if something other than DW_CFA_nop happens. */
8435 if (op
!= DW_CFA_nop
)
8438 /* Warning: if you add any more cases to this switch, be
8439 sure to add them to the corresponding switch above. */
8442 case DW_CFA_advance_loc
:
8443 if (do_debug_frames_interp
)
8444 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8446 printf (" DW_CFA_advance_loc: %d to %s\n",
8447 opa
* fc
->code_factor
,
8448 dwarf_vmatoa_1 (NULL
,
8449 fc
->pc_begin
+ opa
* fc
->code_factor
,
8451 fc
->pc_begin
+= opa
* fc
->code_factor
;
8455 READ_ULEB (roffs
, start
, end
);
8456 if (opa
>= (unsigned int) fc
->ncols
)
8457 reg_prefix
= bad_reg
;
8458 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8459 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8460 reg_prefix
, regname (opa
, 0),
8461 roffs
* fc
->data_factor
);
8462 if (*reg_prefix
== '\0')
8464 fc
->col_type
[opa
] = DW_CFA_offset
;
8465 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8469 case DW_CFA_restore
:
8470 if (opa
>= (unsigned int) fc
->ncols
)
8471 reg_prefix
= bad_reg
;
8472 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8473 printf (" DW_CFA_restore: %s%s\n",
8474 reg_prefix
, regname (opa
, 0));
8475 if (*reg_prefix
!= '\0')
8478 if (opa
>= (unsigned int) cie
->ncols
8479 || (do_debug_frames_interp
8480 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8482 fc
->col_type
[opa
] = DW_CFA_undefined
;
8483 fc
->col_offset
[opa
] = 0;
8487 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8488 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8492 case DW_CFA_set_loc
:
8493 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8494 if (do_debug_frames_interp
)
8495 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8497 printf (" DW_CFA_set_loc: %s\n",
8498 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8502 case DW_CFA_advance_loc1
:
8503 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8504 if (do_debug_frames_interp
)
8505 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8507 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8508 (unsigned long) (ofs
* fc
->code_factor
),
8509 dwarf_vmatoa_1 (NULL
,
8510 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8512 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8515 case DW_CFA_advance_loc2
:
8516 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8517 if (do_debug_frames_interp
)
8518 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8520 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8521 (unsigned long) (ofs
* fc
->code_factor
),
8522 dwarf_vmatoa_1 (NULL
,
8523 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8525 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8528 case DW_CFA_advance_loc4
:
8529 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8530 if (do_debug_frames_interp
)
8531 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8533 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8534 (unsigned long) (ofs
* fc
->code_factor
),
8535 dwarf_vmatoa_1 (NULL
,
8536 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8538 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8541 case DW_CFA_offset_extended
:
8542 READ_ULEB (reg
, start
, end
);
8543 READ_ULEB (roffs
, start
, end
);
8544 if (reg
>= (unsigned int) fc
->ncols
)
8545 reg_prefix
= bad_reg
;
8546 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8547 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8548 reg_prefix
, regname (reg
, 0),
8549 roffs
* fc
->data_factor
);
8550 if (*reg_prefix
== '\0')
8552 fc
->col_type
[reg
] = DW_CFA_offset
;
8553 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8557 case DW_CFA_val_offset
:
8558 READ_ULEB (reg
, start
, end
);
8559 READ_ULEB (roffs
, start
, end
);
8560 if (reg
>= (unsigned int) fc
->ncols
)
8561 reg_prefix
= bad_reg
;
8562 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8563 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8564 reg_prefix
, regname (reg
, 0),
8565 roffs
* fc
->data_factor
);
8566 if (*reg_prefix
== '\0')
8568 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8569 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8573 case DW_CFA_restore_extended
:
8574 READ_ULEB (reg
, start
, end
);
8575 if (reg
>= (unsigned int) fc
->ncols
)
8576 reg_prefix
= bad_reg
;
8577 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8578 printf (" DW_CFA_restore_extended: %s%s\n",
8579 reg_prefix
, regname (reg
, 0));
8580 if (*reg_prefix
!= '\0')
8583 if (reg
>= (unsigned int) cie
->ncols
)
8585 fc
->col_type
[reg
] = DW_CFA_undefined
;
8586 fc
->col_offset
[reg
] = 0;
8590 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8591 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8595 case DW_CFA_undefined
:
8596 READ_ULEB (reg
, start
, end
);
8597 if (reg
>= (unsigned int) fc
->ncols
)
8598 reg_prefix
= bad_reg
;
8599 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8600 printf (" DW_CFA_undefined: %s%s\n",
8601 reg_prefix
, regname (reg
, 0));
8602 if (*reg_prefix
== '\0')
8604 fc
->col_type
[reg
] = DW_CFA_undefined
;
8605 fc
->col_offset
[reg
] = 0;
8609 case DW_CFA_same_value
:
8610 READ_ULEB (reg
, start
, end
);
8611 if (reg
>= (unsigned int) fc
->ncols
)
8612 reg_prefix
= bad_reg
;
8613 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8614 printf (" DW_CFA_same_value: %s%s\n",
8615 reg_prefix
, regname (reg
, 0));
8616 if (*reg_prefix
== '\0')
8618 fc
->col_type
[reg
] = DW_CFA_same_value
;
8619 fc
->col_offset
[reg
] = 0;
8623 case DW_CFA_register
:
8624 READ_ULEB (reg
, start
, end
);
8625 READ_ULEB (roffs
, start
, end
);
8626 if (reg
>= (unsigned int) fc
->ncols
)
8627 reg_prefix
= bad_reg
;
8628 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8630 printf (" DW_CFA_register: %s%s in ",
8631 reg_prefix
, regname (reg
, 0));
8632 puts (regname (roffs
, 0));
8634 if (*reg_prefix
== '\0')
8636 fc
->col_type
[reg
] = DW_CFA_register
;
8637 fc
->col_offset
[reg
] = roffs
;
8641 case DW_CFA_remember_state
:
8642 if (! do_debug_frames_interp
)
8643 printf (" DW_CFA_remember_state\n");
8644 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8645 rs
->cfa_offset
= fc
->cfa_offset
;
8646 rs
->cfa_reg
= fc
->cfa_reg
;
8648 rs
->cfa_exp
= fc
->cfa_exp
;
8649 rs
->ncols
= fc
->ncols
;
8650 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8651 sizeof (* rs
->col_type
));
8652 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8653 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8654 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8655 rs
->next
= remembered_state
;
8656 remembered_state
= rs
;
8659 case DW_CFA_restore_state
:
8660 if (! do_debug_frames_interp
)
8661 printf (" DW_CFA_restore_state\n");
8662 rs
= remembered_state
;
8665 remembered_state
= rs
->next
;
8666 fc
->cfa_offset
= rs
->cfa_offset
;
8667 fc
->cfa_reg
= rs
->cfa_reg
;
8669 fc
->cfa_exp
= rs
->cfa_exp
;
8670 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8672 warn (_("Invalid column number in saved frame state\n"));
8676 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8677 memcpy (fc
->col_offset
, rs
->col_offset
,
8678 rs
->ncols
* sizeof (* rs
->col_offset
));
8679 free (rs
->col_type
);
8680 free (rs
->col_offset
);
8683 else if (do_debug_frames_interp
)
8684 printf ("Mismatched DW_CFA_restore_state\n");
8687 case DW_CFA_def_cfa
:
8688 READ_ULEB (fc
->cfa_reg
, start
, end
);
8689 READ_ULEB (fc
->cfa_offset
, start
, end
);
8691 if (! do_debug_frames_interp
)
8692 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8693 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8696 case DW_CFA_def_cfa_register
:
8697 READ_ULEB (fc
->cfa_reg
, start
, end
);
8699 if (! do_debug_frames_interp
)
8700 printf (" DW_CFA_def_cfa_register: %s\n",
8701 regname (fc
->cfa_reg
, 0));
8704 case DW_CFA_def_cfa_offset
:
8705 READ_ULEB (fc
->cfa_offset
, start
, end
);
8706 if (! do_debug_frames_interp
)
8707 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8711 if (! do_debug_frames_interp
)
8712 printf (" DW_CFA_nop\n");
8715 case DW_CFA_def_cfa_expression
:
8716 READ_ULEB (ul
, start
, end
);
8717 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8719 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8722 if (! do_debug_frames_interp
)
8724 printf (" DW_CFA_def_cfa_expression (");
8725 decode_location_expression (start
, eh_addr_size
, 0, -1,
8733 case DW_CFA_expression
:
8734 READ_ULEB (reg
, start
, end
);
8735 READ_ULEB (ul
, start
, end
);
8736 if (reg
>= (unsigned int) fc
->ncols
)
8737 reg_prefix
= bad_reg
;
8738 /* PR 17512: file: 069-133014-0.006. */
8739 /* PR 17512: file: 98c02eb4. */
8741 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8743 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8746 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8748 printf (" DW_CFA_expression: %s%s (",
8749 reg_prefix
, regname (reg
, 0));
8750 decode_location_expression (start
, eh_addr_size
, 0, -1,
8754 if (*reg_prefix
== '\0')
8755 fc
->col_type
[reg
] = DW_CFA_expression
;
8759 case DW_CFA_val_expression
:
8760 READ_ULEB (reg
, start
, end
);
8761 READ_ULEB (ul
, start
, end
);
8762 if (reg
>= (unsigned int) fc
->ncols
)
8763 reg_prefix
= bad_reg
;
8765 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8767 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8770 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8772 printf (" DW_CFA_val_expression: %s%s (",
8773 reg_prefix
, regname (reg
, 0));
8774 decode_location_expression (start
, eh_addr_size
, 0, -1,
8778 if (*reg_prefix
== '\0')
8779 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8783 case DW_CFA_offset_extended_sf
:
8784 READ_ULEB (reg
, start
, end
);
8785 READ_SLEB (l
, start
, end
);
8786 if (frame_need_space (fc
, reg
) < 0)
8787 reg_prefix
= bad_reg
;
8788 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8789 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8790 reg_prefix
, regname (reg
, 0),
8791 (long)(l
* fc
->data_factor
));
8792 if (*reg_prefix
== '\0')
8794 fc
->col_type
[reg
] = DW_CFA_offset
;
8795 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8799 case DW_CFA_val_offset_sf
:
8800 READ_ULEB (reg
, start
, end
);
8801 READ_SLEB (l
, start
, end
);
8802 if (frame_need_space (fc
, reg
) < 0)
8803 reg_prefix
= bad_reg
;
8804 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8805 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8806 reg_prefix
, regname (reg
, 0),
8807 (long)(l
* fc
->data_factor
));
8808 if (*reg_prefix
== '\0')
8810 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8811 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8815 case DW_CFA_def_cfa_sf
:
8816 READ_ULEB (fc
->cfa_reg
, start
, end
);
8817 READ_ULEB (fc
->cfa_offset
, start
, end
);
8818 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8820 if (! do_debug_frames_interp
)
8821 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8822 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8825 case DW_CFA_def_cfa_offset_sf
:
8826 READ_ULEB (fc
->cfa_offset
, start
, end
);
8827 fc
->cfa_offset
*= fc
->data_factor
;
8828 if (! do_debug_frames_interp
)
8829 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8832 case DW_CFA_MIPS_advance_loc8
:
8833 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8834 if (do_debug_frames_interp
)
8835 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8837 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8838 (unsigned long) (ofs
* fc
->code_factor
),
8839 dwarf_vmatoa_1 (NULL
,
8840 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8842 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8845 case DW_CFA_GNU_window_save
:
8846 if (! do_debug_frames_interp
)
8847 printf (" DW_CFA_GNU_window_save\n");
8850 case DW_CFA_GNU_args_size
:
8851 READ_ULEB (ul
, start
, end
);
8852 if (! do_debug_frames_interp
)
8853 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8856 case DW_CFA_GNU_negative_offset_extended
:
8857 READ_ULEB (reg
, start
, end
);
8858 READ_SLEB (l
, start
, end
);
8860 if (frame_need_space (fc
, reg
) < 0)
8861 reg_prefix
= bad_reg
;
8862 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8863 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8864 reg_prefix
, regname (reg
, 0),
8865 (long)(l
* fc
->data_factor
));
8866 if (*reg_prefix
== '\0')
8868 fc
->col_type
[reg
] = DW_CFA_offset
;
8869 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8874 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8875 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8877 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8882 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8883 if (do_debug_frames_interp
&& ! all_nops
)
8884 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8886 if (fde_fc
.col_type
!= NULL
)
8888 free (fde_fc
.col_type
);
8889 fde_fc
.col_type
= NULL
;
8891 if (fde_fc
.col_offset
!= NULL
)
8893 free (fde_fc
.col_offset
);
8894 fde_fc
.col_offset
= NULL
;
8898 eh_addr_size
= saved_eh_addr_size
;
8903 while (remembered_state
!= NULL
)
8905 rs
= remembered_state
;
8906 remembered_state
= rs
->next
;
8907 free (rs
->col_type
);
8908 free (rs
->col_offset
);
8909 rs
->next
= NULL
; /* Paranoia. */
8913 while (chunks
!= NULL
)
8917 free (rs
->col_type
);
8918 free (rs
->col_offset
);
8919 rs
->next
= NULL
; /* Paranoia. */
8923 while (forward_refs
!= NULL
)
8926 forward_refs
= rs
->next
;
8927 free (rs
->col_type
);
8928 free (rs
->col_offset
);
8929 rs
->next
= NULL
; /* Paranoia. */
8939 display_debug_names (struct dwarf_section
*section
, void *file
)
8941 unsigned char *hdrptr
= section
->start
;
8942 dwarf_vma unit_length
;
8943 unsigned char *unit_start
;
8944 const unsigned char *const section_end
= section
->start
+ section
->size
;
8945 unsigned char *unit_end
;
8947 introduce (section
, FALSE
);
8949 load_debug_section_with_follow (str
, file
);
8951 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8953 unsigned int offset_size
;
8954 uint16_t dwarf_version
, padding
;
8955 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8956 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8957 uint32_t augmentation_string_size
;
8959 unsigned long sec_off
;
8960 bfd_boolean augmentation_printable
;
8961 const char *augmentation_string
;
8963 unit_start
= hdrptr
;
8965 /* Get and check the length of the block. */
8966 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8968 if (unit_length
== 0xffffffff)
8970 /* This section is 64-bit DWARF. */
8971 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8976 unit_end
= hdrptr
+ unit_length
;
8978 sec_off
= hdrptr
- section
->start
;
8979 if (sec_off
+ unit_length
< sec_off
8980 || sec_off
+ unit_length
> section
->size
)
8982 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8984 (unsigned long) (unit_start
- section
->start
),
8985 dwarf_vmatoa ("x", unit_length
));
8989 /* Get and check the version number. */
8990 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8991 printf (_("Version %ld\n"), (long) dwarf_version
);
8993 /* Prior versions did not exist, and future versions may not be
8994 backwards compatible. */
8995 if (dwarf_version
!= 5)
8997 warn (_("Only DWARF version 5 .debug_names "
8998 "is currently supported.\n"));
9002 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9004 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9007 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9008 if (comp_unit_count
== 0)
9009 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9011 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9012 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9013 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9014 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9015 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9017 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9018 if (augmentation_string_size
% 4 != 0)
9020 warn (_("Augmentation string length %u must be rounded up "
9021 "to a multiple of 4 in .debug_names.\n"),
9022 augmentation_string_size
);
9023 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9026 printf (_("Augmentation string:"));
9028 augmentation_printable
= TRUE
;
9029 augmentation_string
= (const char *) hdrptr
;
9031 for (i
= 0; i
< augmentation_string_size
; i
++)
9035 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9036 printf (" %02x", uc
);
9038 if (uc
!= 0 && !ISPRINT (uc
))
9039 augmentation_printable
= FALSE
;
9042 if (augmentation_printable
)
9046 i
< augmentation_string_size
&& augmentation_string
[i
];
9048 putchar (augmentation_string
[i
]);
9053 printf (_("CU table:\n"));
9054 for (i
= 0; i
< comp_unit_count
; i
++)
9058 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9059 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9063 printf (_("TU table:\n"));
9064 for (i
= 0; i
< local_type_unit_count
; i
++)
9068 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9069 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9073 printf (_("Foreign TU table:\n"));
9074 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9078 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9079 printf (_("[%3u] "), i
);
9080 print_dwarf_vma (signature
, 8);
9085 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9086 hdrptr
+= bucket_count
* sizeof (uint32_t);
9087 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9088 hdrptr
+= name_count
* sizeof (uint32_t);
9089 unsigned char *const name_table_string_offsets
= hdrptr
;
9090 hdrptr
+= name_count
* offset_size
;
9091 unsigned char *const name_table_entry_offsets
= hdrptr
;
9092 hdrptr
+= name_count
* offset_size
;
9093 unsigned char *const abbrev_table
= hdrptr
;
9094 hdrptr
+= abbrev_table_size
;
9095 const unsigned char *const abbrev_table_end
= hdrptr
;
9096 unsigned char *const entry_pool
= hdrptr
;
9097 if (hdrptr
> unit_end
)
9099 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9100 "for unit 0x%lx in the debug_names\n"),
9101 (long) (hdrptr
- section
->start
),
9102 (long) (unit_end
- section
->start
),
9103 (long) (unit_start
- section
->start
));
9107 size_t buckets_filled
= 0;
9109 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9111 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9116 printf (ngettext ("Used %zu of %lu bucket.\n",
9117 "Used %zu of %lu buckets.\n",
9119 buckets_filled
, (unsigned long) bucket_count
);
9121 uint32_t hash_prev
= 0;
9122 size_t hash_clash_count
= 0;
9123 size_t longest_clash
= 0;
9124 size_t this_length
= 0;
9126 for (hashi
= 0; hashi
< name_count
; hashi
++)
9128 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9132 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9136 longest_clash
= MAX (longest_clash
, this_length
);
9141 hash_prev
= hash_this
;
9143 printf (_("Out of %lu items there are %zu bucket clashes"
9144 " (longest of %zu entries).\n"),
9145 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9146 assert (name_count
== buckets_filled
+ hash_clash_count
);
9148 struct abbrev_lookup_entry
9150 dwarf_vma abbrev_tag
;
9151 unsigned char *abbrev_lookup_ptr
;
9153 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9154 size_t abbrev_lookup_used
= 0;
9155 size_t abbrev_lookup_allocated
= 0;
9157 unsigned char *abbrevptr
= abbrev_table
;
9160 dwarf_vma abbrev_tag
;
9162 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9163 if (abbrev_tag
== 0)
9165 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9167 abbrev_lookup_allocated
= MAX (0x100,
9168 abbrev_lookup_allocated
* 2);
9169 abbrev_lookup
= xrealloc (abbrev_lookup
,
9170 (abbrev_lookup_allocated
9171 * sizeof (*abbrev_lookup
)));
9173 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9174 struct abbrev_lookup_entry
*entry
;
9175 for (entry
= abbrev_lookup
;
9176 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9178 if (entry
->abbrev_tag
== abbrev_tag
)
9180 warn (_("Duplicate abbreviation tag %lu "
9181 "in unit 0x%lx in the debug_names\n"),
9182 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9185 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9186 entry
->abbrev_tag
= abbrev_tag
;
9187 entry
->abbrev_lookup_ptr
= abbrevptr
;
9189 /* Skip DWARF tag. */
9190 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9193 dwarf_vma xindex
, form
;
9195 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9196 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9197 if (xindex
== 0 && form
== 0)
9202 printf (_("\nSymbol table:\n"));
9204 for (namei
= 0; namei
< name_count
; ++namei
)
9206 uint64_t string_offset
, entry_offset
;
9208 SAFE_BYTE_GET (string_offset
,
9209 name_table_string_offsets
+ namei
* offset_size
,
9210 offset_size
, unit_end
);
9211 SAFE_BYTE_GET (entry_offset
,
9212 name_table_entry_offsets
+ namei
* offset_size
,
9213 offset_size
, unit_end
);
9215 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9216 fetch_indirect_string (string_offset
));
9218 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9220 /* We need to scan first whether there is a single or multiple
9221 entries. TAGNO is -2 for the first entry, it is -1 for the
9222 initial tag read of the second entry, then it becomes 0 for the
9223 first entry for real printing etc. */
9225 /* Initialize it due to a false compiler warning. */
9226 dwarf_vma second_abbrev_tag
= -1;
9229 dwarf_vma abbrev_tag
;
9230 dwarf_vma dwarf_tag
;
9231 const struct abbrev_lookup_entry
*entry
;
9233 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9236 second_abbrev_tag
= abbrev_tag
;
9238 entryptr
= entry_pool
+ entry_offset
;
9241 if (abbrev_tag
== 0)
9245 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9246 (unsigned long) abbrev_tag
);
9248 for (entry
= abbrev_lookup
;
9249 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9251 if (entry
->abbrev_tag
== abbrev_tag
)
9253 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9255 warn (_("Undefined abbreviation tag %lu "
9256 "in unit 0x%lx in the debug_names\n"),
9258 (long) (unit_start
- section
->start
));
9261 abbrevptr
= entry
->abbrev_lookup_ptr
;
9262 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9264 printf (" %s", get_TAG_name (dwarf_tag
));
9267 dwarf_vma xindex
, form
;
9269 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9270 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9271 if (xindex
== 0 && form
== 0)
9275 printf (" %s", get_IDX_name (xindex
));
9276 entryptr
= read_and_display_attr_value (0, form
, 0,
9277 unit_start
, entryptr
, unit_end
,
9279 dwarf_version
, NULL
,
9286 printf (_(" <no entries>"));
9290 free (abbrev_lookup
);
9297 display_debug_links (struct dwarf_section
* section
,
9298 void * file ATTRIBUTE_UNUSED
)
9300 const unsigned char * filename
;
9301 unsigned int filelen
;
9303 introduce (section
, FALSE
);
9305 /* The .gnu_debuglink section is formatted as:
9306 (c-string) Filename.
9307 (padding) If needed to reach a 4 byte boundary.
9308 (uint32_t) CRC32 value.
9310 The .gun_debugaltlink section is formatted as:
9311 (c-string) Filename.
9312 (binary) Build-ID. */
9314 filename
= section
->start
;
9315 filelen
= strnlen ((const char *) filename
, section
->size
);
9316 if (filelen
== section
->size
)
9318 warn (_("The debuglink filename is corrupt/missing\n"));
9322 printf (_(" Separate debug info file: %s\n"), filename
);
9324 if (const_strneq (section
->name
, ".gnu_debuglink"))
9327 unsigned int crc_offset
;
9329 crc_offset
= filelen
+ 1;
9330 crc_offset
= (crc_offset
+ 3) & ~3;
9331 if (crc_offset
+ 4 > section
->size
)
9333 warn (_("CRC offset missing/truncated\n"));
9337 crc32
= byte_get (filename
+ crc_offset
, 4);
9339 printf (_(" CRC value: %#x\n"), crc32
);
9341 if (crc_offset
+ 4 < section
->size
)
9343 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9344 (long)(section
->size
- (crc_offset
+ 4)));
9348 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9350 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9351 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9352 bfd_size_type printed
;
9354 /* FIXME: Should we support smaller build-id notes ? */
9355 if (build_id_len
< 0x14)
9357 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9361 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9362 display_data (printed
, build_id
, build_id_len
);
9371 display_gdb_index (struct dwarf_section
*section
,
9372 void *file ATTRIBUTE_UNUSED
)
9374 unsigned char *start
= section
->start
;
9376 uint32_t cu_list_offset
, tu_list_offset
;
9377 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9378 unsigned int cu_list_elements
, tu_list_elements
;
9379 unsigned int address_table_size
, symbol_table_slots
;
9380 unsigned char *cu_list
, *tu_list
;
9381 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9384 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9386 introduce (section
, FALSE
);
9388 if (section
->size
< 6 * sizeof (uint32_t))
9390 warn (_("Truncated header in the %s section.\n"), section
->name
);
9394 version
= byte_get_little_endian (start
, 4);
9395 printf (_("Version %ld\n"), (long) version
);
9397 /* Prior versions are obsolete, and future versions may not be
9398 backwards compatible. */
9399 if (version
< 3 || version
> 8)
9401 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9405 warn (_("The address table data in version 3 may be wrong.\n"));
9407 warn (_("Version 4 does not support case insensitive lookups.\n"));
9409 warn (_("Version 5 does not include inlined functions.\n"));
9411 warn (_("Version 6 does not include symbol attributes.\n"));
9412 /* Version 7 indices generated by Gold have bad type unit references,
9413 PR binutils/15021. But we don't know if the index was generated by
9414 Gold or not, so to avoid worrying users with gdb-generated indices
9415 we say nothing for version 7 here. */
9417 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9418 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9419 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9420 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9421 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9423 if (cu_list_offset
> section
->size
9424 || tu_list_offset
> section
->size
9425 || address_table_offset
> section
->size
9426 || symbol_table_offset
> section
->size
9427 || constant_pool_offset
> section
->size
)
9429 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9433 /* PR 17531: file: 418d0a8a. */
9434 if (tu_list_offset
< cu_list_offset
)
9436 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9437 tu_list_offset
, cu_list_offset
);
9441 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9443 if (address_table_offset
< tu_list_offset
)
9445 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9446 address_table_offset
, tu_list_offset
);
9450 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9452 /* PR 17531: file: 18a47d3d. */
9453 if (symbol_table_offset
< address_table_offset
)
9455 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9456 symbol_table_offset
, address_table_offset
);
9460 address_table_size
= symbol_table_offset
- address_table_offset
;
9462 if (constant_pool_offset
< symbol_table_offset
)
9464 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9465 constant_pool_offset
, symbol_table_offset
);
9469 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9471 cu_list
= start
+ cu_list_offset
;
9472 tu_list
= start
+ tu_list_offset
;
9473 address_table
= start
+ address_table_offset
;
9474 symbol_table
= start
+ symbol_table_offset
;
9475 constant_pool
= start
+ constant_pool_offset
;
9477 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9479 warn (_("Address table extends beyond end of section.\n"));
9483 printf (_("\nCU table:\n"));
9484 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9486 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9487 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9489 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9490 (unsigned long) cu_offset
,
9491 (unsigned long) (cu_offset
+ cu_length
- 1));
9494 printf (_("\nTU table:\n"));
9495 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9497 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9498 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9499 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9501 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9502 (unsigned long) tu_offset
,
9503 (unsigned long) type_offset
);
9504 print_dwarf_vma (signature
, 8);
9508 printf (_("\nAddress table:\n"));
9509 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9512 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9513 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9514 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9516 print_dwarf_vma (low
, 8);
9517 print_dwarf_vma (high
, 8);
9518 printf (_("%lu\n"), (unsigned long) cu_index
);
9521 printf (_("\nSymbol table:\n"));
9522 for (i
= 0; i
< symbol_table_slots
; ++i
)
9524 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9525 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9526 uint32_t num_cus
, cu
;
9528 if (name_offset
!= 0
9529 || cu_vector_offset
!= 0)
9532 unsigned char * adr
;
9534 adr
= constant_pool
+ name_offset
;
9535 /* PR 17531: file: 5b7b07ad. */
9536 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9538 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9539 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9543 printf ("[%3u] %.*s:", i
,
9544 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9545 constant_pool
+ name_offset
);
9547 adr
= constant_pool
+ cu_vector_offset
;
9548 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9550 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9551 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9552 cu_vector_offset
, i
);
9556 num_cus
= byte_get_little_endian (adr
, 4);
9558 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9559 if (num_cus
* 4 < num_cus
9560 || adr
>= section
->start
+ section
->size
9561 || adr
< constant_pool
)
9563 printf ("<invalid number of CUs: %d>\n", num_cus
);
9564 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9572 for (j
= 0; j
< num_cus
; ++j
)
9575 gdb_index_symbol_kind kind
;
9577 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9578 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9579 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9580 cu
= GDB_INDEX_CU_VALUE (cu
);
9581 /* Convert to TU number if it's for a type unit. */
9582 if (cu
>= cu_list_elements
/ 2)
9583 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9584 (unsigned long) (cu
- cu_list_elements
/ 2));
9586 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9588 printf (" [%s, %s]",
9589 is_static
? _("static") : _("global"),
9590 get_gdb_index_symbol_kind_name (kind
));
9602 /* Pre-allocate enough space for the CU/TU sets needed. */
9605 prealloc_cu_tu_list (unsigned int nshndx
)
9607 if (shndx_pool
== NULL
)
9609 shndx_pool_size
= nshndx
;
9610 shndx_pool_used
= 0;
9611 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9612 sizeof (unsigned int));
9616 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9617 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9618 sizeof (unsigned int));
9623 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9625 if (shndx_pool_used
>= shndx_pool_size
)
9627 error (_("Internal error: out of space in the shndx pool.\n"));
9630 shndx_pool
[shndx_pool_used
++] = shndx
;
9634 end_cu_tu_entry (void)
9636 if (shndx_pool_used
>= shndx_pool_size
)
9638 error (_("Internal error: out of space in the shndx pool.\n"));
9641 shndx_pool
[shndx_pool_used
++] = 0;
9644 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9647 get_DW_SECT_short_name (unsigned int dw_sect
)
9649 static char buf
[16];
9657 case DW_SECT_ABBREV
:
9663 case DW_SECT_STR_OFFSETS
:
9665 case DW_SECT_MACINFO
:
9673 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9677 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9678 These sections are extensions for Fission.
9679 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9682 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9684 unsigned char *phdr
= section
->start
;
9685 unsigned char *limit
= phdr
+ section
->size
;
9686 unsigned char *phash
;
9687 unsigned char *pindex
;
9688 unsigned char *ppool
;
9689 unsigned int version
;
9690 unsigned int ncols
= 0;
9692 unsigned int nslots
;
9695 dwarf_vma signature_high
;
9696 dwarf_vma signature_low
;
9699 /* PR 17512: file: 002-168123-0.004. */
9702 warn (_("Section %s is empty\n"), section
->name
);
9705 /* PR 17512: file: 002-376-0.004. */
9706 if (section
->size
< 24)
9708 warn (_("Section %s is too small to contain a CU/TU header\n"),
9713 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9715 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9716 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9717 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9720 pindex
= phash
+ (size_t) nslots
* 8;
9721 ppool
= pindex
+ (size_t) nslots
* 4;
9725 introduce (section
, FALSE
);
9727 printf (_(" Version: %u\n"), version
);
9729 printf (_(" Number of columns: %u\n"), ncols
);
9730 printf (_(" Number of used entries: %u\n"), nused
);
9731 printf (_(" Number of slots: %u\n\n"), nslots
);
9734 /* PR 17531: file: 45d69832. */
9735 if ((size_t) nslots
* 8 / 8 != nslots
9736 || phash
< phdr
|| phash
> limit
9737 || pindex
< phash
|| pindex
> limit
9738 || ppool
< pindex
|| ppool
> limit
)
9740 warn (ngettext ("Section %s is too small for %u slot\n",
9741 "Section %s is too small for %u slots\n",
9743 section
->name
, nslots
);
9750 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9751 for (i
= 0; i
< nslots
; i
++)
9753 unsigned char *shndx_list
;
9756 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9757 if (signature_high
!= 0 || signature_low
!= 0)
9759 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9760 shndx_list
= ppool
+ j
* 4;
9761 /* PR 17531: file: 705e010d. */
9762 if (shndx_list
< ppool
)
9764 warn (_("Section index pool located before start of section\n"));
9769 printf (_(" [%3d] Signature: 0x%s Sections: "),
9770 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9771 buf
, sizeof (buf
)));
9774 if (shndx_list
>= limit
)
9776 warn (_("Section %s too small for shndx pool\n"),
9780 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9784 printf (" %d", shndx
);
9786 add_shndx_to_cu_tu_entry (shndx
);
9798 else if (version
== 2)
9801 unsigned int dw_sect
;
9802 unsigned char *ph
= phash
;
9803 unsigned char *pi
= pindex
;
9804 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9805 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9806 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9807 bfd_boolean is_tu_index
;
9808 struct cu_tu_set
*this_set
= NULL
;
9810 unsigned char *prow
;
9812 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9814 /* PR 17531: file: 0dd159bf.
9815 Check for integer overflow (can occur when size_t is 32-bit)
9816 with overlarge ncols or nused values. */
9818 && ((size_t) ncols
* 4 / 4 != ncols
9819 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9820 || poffsets
< ppool
|| poffsets
> limit
9821 || psizes
< poffsets
|| psizes
> limit
9822 || pend
< psizes
|| pend
> limit
))
9824 warn (_("Section %s too small for offset and size tables\n"),
9831 printf (_(" Offset table\n"));
9832 printf (" slot %-16s ",
9833 is_tu_index
? _("signature") : _("dwo_id"));
9840 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9846 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9853 for (j
= 0; j
< ncols
; j
++)
9855 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9856 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9861 for (i
= 0; i
< nslots
; i
++)
9863 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9865 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9868 /* PR 17531: file: a05f6ab3. */
9871 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9878 size_t num_copy
= sizeof (uint64_t);
9880 /* PR 23064: Beware of buffer overflow. */
9881 if (ph
+ num_copy
< limit
)
9882 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9885 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9890 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9891 /* PR 17531: file: b8ce60a8. */
9892 if (prow
< poffsets
|| prow
> limit
)
9894 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9900 printf (_(" [%3d] 0x%s"),
9901 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9902 buf
, sizeof (buf
)));
9903 for (j
= 0; j
< ncols
; j
++)
9905 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9907 printf (" %8d", val
);
9910 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9912 /* PR 17531: file: 10796eb3. */
9913 if (dw_sect
>= DW_SECT_MAX
)
9914 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9916 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9932 printf (_(" Size table\n"));
9933 printf (" slot %-16s ",
9934 is_tu_index
? _("signature") : _("dwo_id"));
9937 for (j
= 0; j
< ncols
; j
++)
9939 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9941 printf (" %8s", get_DW_SECT_short_name (val
));
9947 for (i
= 0; i
< nslots
; i
++)
9949 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9951 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9954 prow
= psizes
+ (row
- 1) * ncols
* 4;
9957 printf (_(" [%3d] 0x%s"),
9958 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9959 buf
, sizeof (buf
)));
9961 for (j
= 0; j
< ncols
; j
++)
9963 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9965 printf (" %8d", val
);
9968 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9969 if (dw_sect
>= DW_SECT_MAX
)
9970 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9972 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9984 else if (do_display
)
9985 printf (_(" Unsupported version (%d)\n"), version
);
9993 /* Load the CU and TU indexes if present. This will build a list of
9994 section sets that we can use to associate a .debug_info.dwo section
9995 with its associated .debug_abbrev.dwo section in a .dwp file. */
9998 load_cu_tu_indexes (void *file
)
10000 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10002 /* If we have already loaded (or tried to load) the CU and TU indexes
10003 then do not bother to repeat the task. */
10004 if (cu_tu_indexes_read
== -1)
10006 cu_tu_indexes_read
= TRUE
;
10008 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10009 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10010 cu_tu_indexes_read
= FALSE
;
10012 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10013 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10014 cu_tu_indexes_read
= FALSE
;
10017 return (bfd_boolean
) cu_tu_indexes_read
;
10020 /* Find the set of sections that includes section SHNDX. */
10023 find_cu_tu_set (void *file
, unsigned int shndx
)
10027 if (! load_cu_tu_indexes (file
))
10030 /* Find SHNDX in the shndx pool. */
10031 for (i
= 0; i
< shndx_pool_used
; i
++)
10032 if (shndx_pool
[i
] == shndx
)
10035 if (i
>= shndx_pool_used
)
10038 /* Now backup to find the first entry in the set. */
10039 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10042 return shndx_pool
+ i
;
10045 /* Display a .debug_cu_index or .debug_tu_index section. */
10048 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10050 return process_cu_tu_index (section
, 1);
10054 display_debug_not_supported (struct dwarf_section
*section
,
10055 void *file ATTRIBUTE_UNUSED
)
10057 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10063 /* Like malloc, but takes two parameters like calloc.
10064 Verifies that the first parameter is not too large.
10065 Note: does *not* initialise the allocated memory to zero. */
10068 cmalloc (size_t nmemb
, size_t size
)
10070 /* Check for overflow. */
10071 if (nmemb
>= ~(size_t) 0 / size
)
10074 return xmalloc (nmemb
* size
);
10077 /* Like xmalloc, but takes two parameters like calloc.
10078 Verifies that the first parameter is not too large.
10079 Note: does *not* initialise the allocated memory to zero. */
10082 xcmalloc (size_t nmemb
, size_t size
)
10084 /* Check for overflow. */
10085 if (nmemb
>= ~(size_t) 0 / size
)
10088 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10093 return xmalloc (nmemb
* size
);
10096 /* Like xrealloc, but takes three parameters.
10097 Verifies that the second parameter is not too large.
10098 Note: does *not* initialise any new memory to zero. */
10101 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10103 /* Check for overflow. */
10104 if (nmemb
>= ~(size_t) 0 / size
)
10106 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10111 return xrealloc (ptr
, nmemb
* size
);
10114 /* Like xcalloc, but verifies that the first parameter is not too large. */
10117 xcalloc2 (size_t nmemb
, size_t size
)
10119 /* Check for overflow. */
10120 if (nmemb
>= ~(size_t) 0 / size
)
10122 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10127 return xcalloc (nmemb
, size
);
10130 static unsigned long
10131 calc_gnu_debuglink_crc32 (unsigned long crc
,
10132 const unsigned char * buf
,
10135 static const unsigned long crc32_table
[256] =
10137 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10138 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10139 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10140 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10141 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10142 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10143 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10144 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10145 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10146 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10147 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10148 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10149 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10150 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10151 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10152 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10153 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10154 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10155 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10156 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10157 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10158 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10159 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10160 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10161 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10162 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10163 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10164 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10165 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10166 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10167 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10168 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10169 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10170 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10171 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10172 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10173 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10174 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10175 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10176 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10177 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10178 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10179 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10180 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10181 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10182 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10183 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10184 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10185 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10186 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10187 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10190 const unsigned char *end
;
10192 crc
= ~crc
& 0xffffffff;
10193 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10194 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10195 return ~crc
& 0xffffffff;
10198 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10199 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10202 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10204 static unsigned char buffer
[8 * 1024];
10206 bfd_size_type count
;
10207 unsigned long crc
= 0;
10210 sep_data
= open_debug_file (pathname
);
10211 if (sep_data
== NULL
)
10214 /* Yes - we are opening the file twice... */
10215 f
= fopen (pathname
, "rb");
10218 /* Paranoia: This should never happen. */
10219 close_debug_file (sep_data
);
10220 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10224 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10225 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10229 if (crc
!= * (unsigned long *) crc_pointer
)
10231 close_debug_file (sep_data
);
10232 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10240 static const char *
10241 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10244 unsigned int crc_offset
;
10245 unsigned long * crc32
= (unsigned long *) data
;
10247 /* The name is first.
10248 The CRC value is stored after the filename, aligned up to 4 bytes. */
10249 name
= (const char *) section
->start
;
10252 crc_offset
= strnlen (name
, section
->size
) + 1;
10253 crc_offset
= (crc_offset
+ 3) & ~3;
10254 if (crc_offset
+ 4 > section
->size
)
10257 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10262 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10264 void * sep_data
= open_debug_file (filename
);
10266 if (sep_data
== NULL
)
10269 /* FIXME: We should now extract the build-id in the separate file
10275 typedef struct build_id_data
10278 const unsigned char * data
;
10281 static const char *
10282 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10285 bfd_size_type namelen
;
10286 bfd_size_type id_len
;
10287 Build_id_data
* build_id_data
;
10289 /* The name is first.
10290 The build-id follows immediately, with no padding, up to the section's end. */
10292 name
= (const char *) section
->start
;
10293 namelen
= strnlen (name
, section
->size
) + 1;
10294 if (namelen
>= section
->size
)
10297 id_len
= section
->size
- namelen
;
10301 build_id_data
= calloc (1, sizeof * build_id_data
);
10302 if (build_id_data
== NULL
)
10305 build_id_data
->len
= id_len
;
10306 build_id_data
->data
= section
->start
+ namelen
;
10308 * (Build_id_data
**) data
= build_id_data
;
10314 add_separate_debug_file (const char * filename
, void * handle
)
10316 separate_info
* i
= xmalloc (sizeof * i
);
10318 i
->filename
= filename
;
10319 i
->handle
= handle
;
10320 i
->next
= first_separate_info
;
10321 first_separate_info
= i
;
10324 #if HAVE_LIBDEBUGINFOD
10325 /* Query debuginfod servers for the target debuglink or debugaltlink
10326 file. If successful, store the path of the file in filename and
10327 return TRUE, otherwise return FALSE. */
10330 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10334 size_t build_id_len
;
10335 unsigned char * build_id
;
10337 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10339 /* Get the build-id of file. */
10340 build_id
= get_build_id (file
);
10343 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10345 /* Get the build-id of the debugaltlink file. */
10346 unsigned int filelen
;
10348 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10349 if (filelen
== section
->size
)
10350 /* Corrupt debugaltlink. */
10353 build_id
= section
->start
+ filelen
+ 1;
10354 build_id_len
= section
->size
- (filelen
+ 1);
10356 if (build_id_len
== 0)
10365 debuginfod_client
* client
;
10367 client
= debuginfod_begin ();
10368 if (client
== NULL
)
10371 /* Query debuginfod servers for the target file. If found its path
10372 will be stored in filename. */
10373 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10374 debuginfod_end (client
);
10376 /* Only free build_id if we allocated space for a hex string
10377 in get_build_id (). */
10378 if (build_id_len
== 0)
10383 /* File successfully retrieved. Close fd since we want to
10384 use open_debug_file () on filename instead. */
10395 load_separate_debug_info (const char * main_filename
,
10396 struct dwarf_section
* xlink
,
10397 parse_func_type parse_func
,
10398 check_func_type check_func
,
10400 void * file ATTRIBUTE_UNUSED
)
10402 const char * separate_filename
;
10403 char * debug_filename
;
10405 size_t canon_dirlen
;
10408 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10410 warn (_("Corrupt debuglink section: %s\n"),
10411 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10415 /* Attempt to locate the separate file.
10416 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10418 canon_dir
= lrealpath (main_filename
);
10420 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10421 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10423 canon_dir
[canon_dirlen
] = '\0';
10426 #define DEBUGDIR "/lib/debug"
10428 #ifndef EXTRA_DEBUG_ROOT1
10429 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10431 #ifndef EXTRA_DEBUG_ROOT2
10432 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10435 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10437 + strlen (".debug/")
10438 #ifdef EXTRA_DEBUG_ROOT1
10439 + strlen (EXTRA_DEBUG_ROOT1
)
10441 #ifdef EXTRA_DEBUG_ROOT2
10442 + strlen (EXTRA_DEBUG_ROOT2
)
10444 + strlen (separate_filename
)
10446 if (debug_filename
== NULL
)
10448 warn (_("Out of memory"));
10453 /* First try in the current directory. */
10454 sprintf (debug_filename
, "%s", separate_filename
);
10455 if (check_func (debug_filename
, func_data
))
10458 /* Then try in a subdirectory called .debug. */
10459 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10460 if (check_func (debug_filename
, func_data
))
10463 /* Then try in the same directory as the original file. */
10464 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10465 if (check_func (debug_filename
, func_data
))
10468 /* And the .debug subdirectory of that directory. */
10469 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10470 if (check_func (debug_filename
, func_data
))
10473 #ifdef EXTRA_DEBUG_ROOT1
10474 /* Try the first extra debug file root. */
10475 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10476 if (check_func (debug_filename
, func_data
))
10479 /* Try the first extra debug file root. */
10480 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10481 if (check_func (debug_filename
, func_data
))
10485 #ifdef EXTRA_DEBUG_ROOT2
10486 /* Try the second extra debug file root. */
10487 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10488 if (check_func (debug_filename
, func_data
))
10492 /* Then try in the global debug_filename directory. */
10493 strcpy (debug_filename
, DEBUGDIR
);
10494 dirlen
= strlen (DEBUGDIR
) - 1;
10495 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10496 strcat (debug_filename
, "/");
10497 strcat (debug_filename
, (const char *) separate_filename
);
10499 if (check_func (debug_filename
, func_data
))
10502 #if HAVE_LIBDEBUGINFOD
10504 char * tmp_filename
;
10506 if (debuginfod_fetch_separate_debug_info (xlink
,
10510 /* File successfully downloaded from server, replace
10511 debug_filename with the file's path. */
10512 free (debug_filename
);
10513 debug_filename
= tmp_filename
;
10519 /* Failed to find the file. */
10520 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10521 warn (_("tried: %s\n"), debug_filename
);
10523 #ifdef EXTRA_DEBUG_ROOT2
10524 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10525 warn (_("tried: %s\n"), debug_filename
);
10528 #ifdef EXTRA_DEBUG_ROOT1
10529 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10530 warn (_("tried: %s\n"), debug_filename
);
10532 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10533 warn (_("tried: %s\n"), debug_filename
);
10536 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10537 warn (_("tried: %s\n"), debug_filename
);
10539 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10540 warn (_("tried: %s\n"), debug_filename
);
10542 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10543 warn (_("tried: %s\n"), debug_filename
);
10545 sprintf (debug_filename
, "%s", separate_filename
);
10546 warn (_("tried: %s\n"), debug_filename
);
10548 #if HAVE_LIBDEBUGINFOD
10550 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10554 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10559 free (debug_filename
);
10565 void * debug_handle
;
10567 /* Now open the file.... */
10568 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10570 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10571 free (debug_filename
);
10575 /* FIXME: We do not check to see if there are any other separate debug info
10576 files that would also match. */
10578 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10579 add_separate_debug_file (debug_filename
, debug_handle
);
10581 /* Do not free debug_filename - it might be referenced inside
10582 the structure returned by open_debug_file(). */
10583 return debug_handle
;
10586 /* Attempt to load a separate dwarf object file. */
10589 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10591 char * separate_filename
;
10592 void * separate_handle
;
10594 /* FIXME: Skip adding / if dwo_dir ends in /. */
10595 separate_filename
= concat (dir
, "/", name
, NULL
);
10596 if (separate_filename
== NULL
)
10598 warn (_("Out of memory allocating dwo filename\n"));
10602 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10604 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10605 free (separate_filename
);
10609 /* FIXME: We should check the dwo_id. */
10611 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10612 add_separate_debug_file (separate_filename
, separate_handle
);
10613 /* Note - separate_filename will be freed in free_debug_memory(). */
10614 return separate_handle
;
10617 /* Load the separate debug info file(s) attached to FILE, if any exist.
10618 Returns TRUE if any were found, FALSE otherwise.
10619 If TRUE is returned then the linked list starting at first_separate_info
10620 will be populated with open file handles. */
10623 load_separate_debug_files (void * file
, const char * filename
)
10625 /* Skip this operation if we are not interested in debug links. */
10626 if (! do_follow_links
&& ! do_debug_links
)
10629 /* See if there are any dwo links. */
10630 if (load_debug_section (str
, file
)
10631 && load_debug_section (abbrev
, file
)
10632 && load_debug_section (info
, file
))
10636 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10638 bfd_boolean introduced
= FALSE
;
10640 const char * dir
= NULL
;
10641 const char * id
= NULL
;
10643 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10645 switch (dwinfo
->type
)
10648 if (do_debug_links
)
10652 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10653 debug_displays
[info
].section
.uncompressed_name
);
10657 printf (_(" Name: %s\n"), dwinfo
->value
);
10658 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10660 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10662 printf (_(" ID: <unknown>\n"));
10666 if (do_follow_links
)
10667 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10671 dir
= dwinfo
->value
;
10675 id
= dwinfo
->value
;
10679 error (_("Unexpected DWO INFO type"));
10686 if (! do_follow_links
)
10687 /* The other debug links will be displayed by display_debug_links()
10688 so we do not need to do any further processing here. */
10691 /* FIXME: We do not check for the presence of both link sections in the same file. */
10692 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10693 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10694 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10696 if (load_debug_section (gnu_debugaltlink
, file
))
10698 Build_id_data
* build_id_data
;
10700 load_separate_debug_info (filename
,
10701 & debug_displays
[gnu_debugaltlink
].section
,
10702 parse_gnu_debugaltlink
,
10703 check_gnu_debugaltlink
,
10708 if (load_debug_section (gnu_debuglink
, file
))
10710 unsigned long crc32
;
10712 load_separate_debug_info (filename
,
10713 & debug_displays
[gnu_debuglink
].section
,
10714 parse_gnu_debuglink
,
10715 check_gnu_debuglink
,
10720 if (first_separate_info
!= NULL
)
10723 do_follow_links
= 0;
10728 free_debug_memory (void)
10734 for (i
= 0; i
< max
; i
++)
10735 free_debug_section ((enum dwarf_section_display_enum
) i
);
10737 if (debug_information
!= NULL
)
10739 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10741 for (i
= 0; i
< num_debug_info_entries
; i
++)
10743 if (!debug_information
[i
].max_loc_offsets
)
10745 free (debug_information
[i
].loc_offsets
);
10746 free (debug_information
[i
].have_frame_base
);
10748 if (!debug_information
[i
].max_range_lists
)
10749 free (debug_information
[i
].range_lists
);
10752 free (debug_information
);
10753 debug_information
= NULL
;
10754 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10758 separate_info
* next
;
10760 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10762 close_debug_file (d
->handle
);
10763 free ((void *) d
->filename
);
10767 first_separate_info
= NULL
;
10773 dwarf_select_sections_by_names (const char *names
)
10777 const char * option
;
10781 debug_dump_long_opts
;
10783 static const debug_dump_long_opts opts_table
[] =
10785 /* Please keep this table alpha- sorted. */
10786 { "Ranges", & do_debug_ranges
, 1 },
10787 { "abbrev", & do_debug_abbrevs
, 1 },
10788 { "addr", & do_debug_addr
, 1 },
10789 { "aranges", & do_debug_aranges
, 1 },
10790 { "cu_index", & do_debug_cu_index
, 1 },
10791 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10792 { "follow-links", & do_follow_links
, 1 },
10793 { "frames", & do_debug_frames
, 1 },
10794 { "frames-interp", & do_debug_frames_interp
, 1 },
10795 /* The special .gdb_index section. */
10796 { "gdb_index", & do_gdb_index
, 1 },
10797 { "info", & do_debug_info
, 1 },
10798 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10799 { "links", & do_debug_links
, 1 },
10800 { "loc", & do_debug_loc
, 1 },
10801 { "macro", & do_debug_macinfo
, 1 },
10802 { "pubnames", & do_debug_pubnames
, 1 },
10803 { "pubtypes", & do_debug_pubtypes
, 1 },
10804 /* This entry is for compatibility
10805 with earlier versions of readelf. */
10806 { "ranges", & do_debug_aranges
, 1 },
10807 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10808 { "str", & do_debug_str
, 1 },
10809 { "str-offsets", & do_debug_str_offsets
, 1 },
10810 /* These trace_* sections are used by Itanium VMS. */
10811 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10812 { "trace_aranges", & do_trace_aranges
, 1 },
10813 { "trace_info", & do_trace_info
, 1 },
10822 const debug_dump_long_opts
* entry
;
10824 for (entry
= opts_table
; entry
->option
; entry
++)
10826 size_t len
= strlen (entry
->option
);
10828 if (strncmp (p
, entry
->option
, len
) == 0
10829 && (p
[len
] == ',' || p
[len
] == '\0'))
10831 * entry
->variable
|= entry
->val
;
10833 /* The --debug-dump=frames-interp option also
10834 enables the --debug-dump=frames option. */
10835 if (do_debug_frames_interp
)
10836 do_debug_frames
= 1;
10843 if (entry
->option
== NULL
)
10845 warn (_("Unrecognized debug option '%s'\n"), p
);
10846 p
= strchr (p
, ',');
10857 dwarf_select_sections_by_letters (const char *letters
)
10859 unsigned int lindex
= 0;
10861 while (letters
[lindex
])
10862 switch (letters
[lindex
++])
10864 case 'A': do_debug_addr
= 1; break;
10865 case 'a': do_debug_abbrevs
= 1; break;
10866 case 'c': do_debug_cu_index
= 1; break;
10867 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10868 case 'f': do_debug_frames
= 1; break;
10869 case 'g': do_gdb_index
= 1; break;
10870 case 'i': do_debug_info
= 1; break;
10871 case 'K': do_follow_links
= 1; break;
10872 case 'k': do_debug_links
= 1; break;
10873 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10874 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10875 case 'm': do_debug_macinfo
= 1; break;
10876 case 'O': do_debug_str_offsets
= 1; break;
10877 case 'o': do_debug_loc
= 1; break;
10878 case 'p': do_debug_pubnames
= 1; break;
10879 case 'R': do_debug_ranges
= 1; break;
10880 case 'r': do_debug_aranges
= 1; break;
10881 case 's': do_debug_str
= 1; break;
10882 case 'T': do_trace_aranges
= 1; break;
10883 case 't': do_debug_pubtypes
= 1; break;
10884 case 'U': do_trace_info
= 1; break;
10885 case 'u': do_trace_abbrevs
= 1; break;
10888 warn (_("Unrecognized debug option '%s'\n"), letters
);
10894 dwarf_select_sections_all (void)
10897 do_debug_abbrevs
= 1;
10898 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10899 do_debug_pubnames
= 1;
10900 do_debug_pubtypes
= 1;
10901 do_debug_aranges
= 1;
10902 do_debug_ranges
= 1;
10903 do_debug_frames
= 1;
10904 do_debug_macinfo
= 1;
10909 do_trace_abbrevs
= 1;
10910 do_trace_aranges
= 1;
10912 do_debug_cu_index
= 1;
10913 do_follow_links
= 1;
10914 do_debug_links
= 1;
10915 do_debug_str_offsets
= 1;
10918 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10919 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10921 /* N.B. The order here must match the order in section_display_enum. */
10923 struct dwarf_section_display debug_displays
[] =
10925 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10926 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10927 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10928 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10929 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10930 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10931 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10932 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10933 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10934 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10935 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10936 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10937 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10938 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10939 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10940 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10941 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10942 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10943 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10944 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10945 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10946 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10947 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10948 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10949 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10950 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10951 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10952 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10953 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10954 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10955 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10956 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10957 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10958 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10959 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10960 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10961 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10962 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10963 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10964 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10965 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10966 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10967 /* Separate debug info files can containt their own .debug_str section,
10968 and this might be in *addition* to a .debug_str section already present
10969 in the main file. Hence we need to have two entries for .debug_str. */
10970 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10973 /* A static assertion. */
10974 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];