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
)
6851 if (section
->size
== 0)
6853 printf (_("\nThe %s section is empty.\n"), section
->name
);
6857 unsigned char *start
= section
->start
;
6858 unsigned char *end
= start
+ section
->size
;
6859 unsigned char *curr
= start
;
6861 const char * suffix
= strrchr (section
->name
, '.');
6862 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
6865 load_debug_section_with_follow (str_dwo
, file
);
6867 load_debug_section_with_follow (str
, file
);
6869 introduce (section
, FALSE
);
6874 dwarf_vma entry_length
;
6876 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
6877 /* FIXME: We assume that this means 64-bit DWARF is being used. */
6878 if (length
== 0xffffffff)
6880 SAFE_BYTE_GET (length
, curr
, 8, end
);
6888 /* This is probably an old style .debug_str_offset section which
6889 just contains offsets and no header (and the first offset is 0). */
6890 length
= section
->size
;
6891 curr
= section
->start
;
6893 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6894 printf (_(" Index Offset [String]\n"));
6899 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6901 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
6904 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
6906 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
6908 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6909 printf (_(" Version: %#lx\n"), (unsigned long) version
);
6910 printf (_(" Index Offset [String]\n"));
6913 unsigned long index
;
6914 for (index
= 0; length
>= entry_length
&& curr
< end
; index
++)
6917 const unsigned char * string
;
6919 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, end
);
6921 string
= (const unsigned char *)
6922 fetch_indexed_string (index
, NULL
, entry_length
, dwo
);
6924 string
= fetch_indirect_string (offset
);
6926 printf (" %8lu %8s %s\n", index
, dwarf_vmatoa ("x", offset
),
6934 /* Each debug_information[x].range_lists[y] gets this representation for
6935 sorting purposes. */
6939 /* The debug_information[x].range_lists[y] value. */
6940 dwarf_vma ranges_offset
;
6942 /* Original debug_information to find parameters of the data. */
6943 debug_info
*debug_info_p
;
6946 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6949 range_entry_compar (const void *ap
, const void *bp
)
6951 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6952 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6953 const dwarf_vma a
= a_re
->ranges_offset
;
6954 const dwarf_vma b
= b_re
->ranges_offset
;
6956 return (a
> b
) - (b
> a
);
6960 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6961 unsigned int pointer_size
, unsigned long offset
,
6962 unsigned long base_address
)
6964 while (start
< finish
)
6969 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6970 if (start
>= finish
)
6972 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6975 printf (" %8.8lx ", offset
);
6977 if (begin
== 0 && end
== 0)
6979 printf (_("<End of list>\n"));
6983 /* Check base address specifiers. */
6984 if (is_max_address (begin
, pointer_size
)
6985 && !is_max_address (end
, pointer_size
))
6988 print_dwarf_vma (begin
, pointer_size
);
6989 print_dwarf_vma (end
, pointer_size
);
6990 printf ("(base address)\n");
6994 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6995 print_dwarf_vma (end
+ base_address
, pointer_size
);
6998 fputs (_("(start == end)"), stdout
);
6999 else if (begin
> end
)
7000 fputs (_("(start > end)"), stdout
);
7007 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7008 unsigned int pointer_size
, unsigned long offset
,
7009 unsigned long base_address
)
7011 unsigned char *next
= start
;
7015 unsigned long off
= offset
+ (start
- next
);
7016 enum dwarf_range_list_entry rlet
;
7017 /* Initialize it due to a false compiler warning. */
7018 dwarf_vma begin
= -1, length
, end
= -1;
7020 if (start
+ 1 > finish
)
7022 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7027 printf (" %8.8lx ", off
);
7029 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7033 case DW_RLE_end_of_list
:
7034 printf (_("<End of list>\n"));
7036 case DW_RLE_base_address
:
7037 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7038 print_dwarf_vma (base_address
, pointer_size
);
7039 printf (_("(base address)\n"));
7041 case DW_RLE_start_length
:
7042 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7043 READ_ULEB (length
, start
, finish
);
7044 end
= begin
+ length
;
7046 case DW_RLE_offset_pair
:
7047 READ_ULEB (begin
, start
, finish
);
7048 READ_ULEB (end
, start
, finish
);
7050 case DW_RLE_start_end
:
7051 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7052 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7055 error (_("Invalid range list entry type %d\n"), rlet
);
7056 rlet
= DW_RLE_end_of_list
;
7059 if (rlet
== DW_RLE_end_of_list
)
7061 if (rlet
== DW_RLE_base_address
)
7064 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7065 print_dwarf_vma (end
+ base_address
, pointer_size
);
7068 fputs (_("(start == end)"), stdout
);
7069 else if (begin
> end
)
7070 fputs (_("(start > end)"), stdout
);
7077 display_debug_ranges (struct dwarf_section
*section
,
7078 void *file ATTRIBUTE_UNUSED
)
7080 unsigned char *start
= section
->start
;
7081 unsigned char *last_start
= start
;
7082 unsigned long bytes
= section
->size
;
7083 unsigned char *section_begin
= start
;
7084 unsigned char *finish
= start
+ bytes
;
7085 unsigned int num_range_list
, i
;
7086 struct range_entry
*range_entries
, *range_entry_fill
;
7087 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7088 /* Initialize it due to a false compiler warning. */
7089 unsigned char address_size
= 0;
7090 dwarf_vma last_offset
= 0;
7094 printf (_("\nThe %s section is empty.\n"), section
->name
);
7100 dwarf_vma initial_length
;
7101 unsigned int initial_length_size
;
7102 unsigned char segment_selector_size
;
7103 unsigned int offset_size
, offset_entry_count
;
7104 unsigned short version
;
7106 /* Get and check the length of the block. */
7107 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7109 if (initial_length
== 0xffffffff)
7111 /* This section is 64-bit DWARF 3. */
7112 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7114 initial_length_size
= 12;
7119 initial_length_size
= 4;
7122 if (initial_length
+ initial_length_size
> section
->size
)
7124 /* If the length field has a relocation against it, then we should
7125 not complain if it is inaccurate (and probably negative).
7126 It is copied from .debug_line handling code. */
7127 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7129 initial_length
= (finish
- start
) - initial_length_size
;
7133 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7134 (long) initial_length
);
7139 /* Get and check the version number. */
7140 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7144 warn (_("Only DWARF version 5 debug_rnglists info "
7145 "is currently supported.\n"));
7149 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7151 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7152 if (segment_selector_size
!= 0)
7154 warn (_("The %s section contains "
7155 "unsupported segment selector size: %d.\n"),
7156 section
->name
, segment_selector_size
);
7160 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7161 if (offset_entry_count
!= 0)
7163 warn (_("The %s section contains "
7164 "unsupported offset entry count: %u.\n"),
7165 section
->name
, offset_entry_count
);
7170 if (load_debug_info (file
) == 0)
7172 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7178 for (i
= 0; i
< num_debug_info_entries
; i
++)
7179 num_range_list
+= debug_information
[i
].num_range_lists
;
7181 if (num_range_list
== 0)
7183 /* This can happen when the file was compiled with -gsplit-debug
7184 which removes references to range lists from the primary .o file. */
7185 printf (_("No range lists in .debug_info section.\n"));
7189 range_entries
= (struct range_entry
*)
7190 xmalloc (sizeof (*range_entries
) * num_range_list
);
7191 range_entry_fill
= range_entries
;
7193 for (i
= 0; i
< num_debug_info_entries
; i
++)
7195 debug_info
*debug_info_p
= &debug_information
[i
];
7198 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7200 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7201 range_entry_fill
->debug_info_p
= debug_info_p
;
7206 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7207 range_entry_compar
);
7209 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7210 warn (_("Range lists in %s section start at 0x%lx\n"),
7211 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7213 introduce (section
, FALSE
);
7215 printf (_(" Offset Begin End\n"));
7217 for (i
= 0; i
< num_range_list
; i
++)
7219 struct range_entry
*range_entry
= &range_entries
[i
];
7220 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7221 unsigned int pointer_size
;
7223 unsigned char *next
;
7224 dwarf_vma base_address
;
7226 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7227 offset
= range_entry
->ranges_offset
;
7228 next
= section_begin
+ offset
;
7229 base_address
= debug_info_p
->base_address
;
7231 /* PR 17512: file: 001-101485-0.001:0.1. */
7232 if (pointer_size
< 2 || pointer_size
> 8)
7234 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7235 pointer_size
, (unsigned long) offset
);
7239 if (next
< section_begin
|| next
>= finish
)
7241 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7242 (unsigned long) offset
, i
);
7246 /* If multiple DWARF entities reference the same range then we will
7247 have multiple entries in the `range_entries' list for the same
7248 offset. Thanks to the sort above these will all be consecutive in
7249 the `range_entries' list, so we can easily ignore duplicates
7251 if (i
> 0 && last_offset
== offset
)
7253 last_offset
= offset
;
7255 if (dwarf_check
!= 0 && i
> 0)
7258 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7259 (unsigned long) (start
- section_begin
),
7260 (unsigned long) (next
- section_begin
), section
->name
);
7261 else if (start
> next
)
7263 if (next
== last_start
)
7265 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7266 (unsigned long) (start
- section_begin
),
7267 (unsigned long) (next
- section_begin
), section
->name
);
7274 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7275 (start
, finish
, pointer_size
, offset
, base_address
);
7279 free (range_entries
);
7284 typedef struct Frame_Chunk
7286 struct Frame_Chunk
*next
;
7287 unsigned char *chunk_start
;
7289 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7290 short int *col_type
;
7293 unsigned int code_factor
;
7297 unsigned int cfa_reg
;
7298 dwarf_vma cfa_offset
;
7300 unsigned char fde_encoding
;
7301 unsigned char cfa_exp
;
7302 unsigned char ptr_size
;
7303 unsigned char segment_size
;
7307 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7308 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7309 static const char *const *dwarf_regnames
;
7310 static unsigned int dwarf_regnames_count
;
7313 /* A marker for a col_type that means this column was never referenced
7314 in the frame info. */
7315 #define DW_CFA_unreferenced (-1)
7317 /* Return 0 if no more space is needed, 1 if more space is needed,
7318 -1 for invalid reg. */
7321 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7323 unsigned int prev
= fc
->ncols
;
7325 if (reg
< (unsigned int) fc
->ncols
)
7328 if (dwarf_regnames_count
> 0
7329 && reg
> dwarf_regnames_count
)
7332 fc
->ncols
= reg
+ 1;
7333 /* PR 17512: file: 10450-2643-0.004.
7334 If reg == -1 then this can happen... */
7338 /* PR 17512: file: 2844a11d. */
7339 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7341 error (_("Unfeasibly large register number: %u\n"), reg
);
7343 /* FIXME: 1024 is an arbitrary limit. Increase it if
7344 we ever encounter a valid binary that exceeds it. */
7348 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7349 sizeof (short int));
7350 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7351 /* PR 17512: file:002-10025-0.005. */
7352 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7354 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7360 while (prev
< fc
->ncols
)
7362 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7363 fc
->col_offset
[prev
] = 0;
7369 static const char *const dwarf_regnames_i386
[] =
7371 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7372 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7373 "eip", "eflags", NULL
, /* 8 - 10 */
7374 "st0", "st1", "st2", "st3", /* 11 - 14 */
7375 "st4", "st5", "st6", "st7", /* 15 - 18 */
7376 NULL
, NULL
, /* 19 - 20 */
7377 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7378 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7379 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7380 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7381 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7382 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7383 "tr", "ldtr", /* 48 - 49 */
7384 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7385 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7386 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7387 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7388 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7389 NULL
, NULL
, NULL
, /* 90 - 92 */
7390 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7393 static const char *const dwarf_regnames_iamcu
[] =
7395 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7396 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7397 "eip", "eflags", NULL
, /* 8 - 10 */
7398 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7399 NULL
, NULL
, /* 19 - 20 */
7400 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7401 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7402 NULL
, NULL
, NULL
, /* 37 - 39 */
7403 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7404 "tr", "ldtr", /* 48 - 49 */
7405 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7406 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7407 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7408 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7409 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7410 NULL
, NULL
, NULL
, /* 90 - 92 */
7411 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7415 init_dwarf_regnames_i386 (void)
7417 dwarf_regnames
= dwarf_regnames_i386
;
7418 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7419 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7423 init_dwarf_regnames_iamcu (void)
7425 dwarf_regnames
= dwarf_regnames_iamcu
;
7426 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7427 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7430 static const char *const dwarf_regnames_x86_64
[] =
7432 "rax", "rdx", "rcx", "rbx",
7433 "rsi", "rdi", "rbp", "rsp",
7434 "r8", "r9", "r10", "r11",
7435 "r12", "r13", "r14", "r15",
7437 "xmm0", "xmm1", "xmm2", "xmm3",
7438 "xmm4", "xmm5", "xmm6", "xmm7",
7439 "xmm8", "xmm9", "xmm10", "xmm11",
7440 "xmm12", "xmm13", "xmm14", "xmm15",
7441 "st0", "st1", "st2", "st3",
7442 "st4", "st5", "st6", "st7",
7443 "mm0", "mm1", "mm2", "mm3",
7444 "mm4", "mm5", "mm6", "mm7",
7446 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7447 "fs.base", "gs.base", NULL
, NULL
,
7449 "mxcsr", "fcw", "fsw",
7450 "xmm16", "xmm17", "xmm18", "xmm19",
7451 "xmm20", "xmm21", "xmm22", "xmm23",
7452 "xmm24", "xmm25", "xmm26", "xmm27",
7453 "xmm28", "xmm29", "xmm30", "xmm31",
7454 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7455 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7456 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7457 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7458 NULL
, NULL
, NULL
, /* 115 - 117 */
7459 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7463 init_dwarf_regnames_x86_64 (void)
7465 dwarf_regnames
= dwarf_regnames_x86_64
;
7466 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7467 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7470 static const char *const dwarf_regnames_aarch64
[] =
7472 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7473 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7474 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7475 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7476 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7477 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7478 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7479 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7480 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7481 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7482 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7483 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7484 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7485 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7486 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7487 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7491 init_dwarf_regnames_aarch64 (void)
7493 dwarf_regnames
= dwarf_regnames_aarch64
;
7494 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7495 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7498 static const char *const dwarf_regnames_s390
[] =
7500 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7501 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7502 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7503 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7504 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7505 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7506 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7507 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7508 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7511 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7512 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7516 init_dwarf_regnames_s390 (void)
7518 dwarf_regnames
= dwarf_regnames_s390
;
7519 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7520 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7523 static const char *const dwarf_regnames_riscv
[] =
7525 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7526 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7527 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7528 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7529 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7530 "fs0", "fs1", /* 40 - 41 */
7531 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7532 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7533 "fs10", "fs11", /* 58 - 59 */
7534 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7537 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7538 the large number of CSRs. */
7541 regname_internal_riscv (unsigned int regno
)
7543 const char *name
= NULL
;
7545 /* Lookup in the table first, this covers GPR and FPR. */
7546 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7547 name
= dwarf_regnames_riscv
[regno
];
7548 else if (regno
>= 4096 && regno
<= 8191)
7550 /* This might be a CSR, these live in a sparse number space from 4096
7551 to 8191 These numbers are defined in the RISC-V ELF ABI
7555 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
7556 case VALUE + 4096: name = #NAME; break;
7557 #include "opcode/riscv-opc.h"
7562 static char csr_name
[10];
7563 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7574 init_dwarf_regnames_riscv (void)
7576 dwarf_regnames
= NULL
;
7577 dwarf_regnames_count
= 8192;
7578 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7582 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7584 dwarf_regnames_lookup_func
= NULL
;
7589 init_dwarf_regnames_i386 ();
7593 init_dwarf_regnames_iamcu ();
7599 init_dwarf_regnames_x86_64 ();
7603 init_dwarf_regnames_aarch64 ();
7607 init_dwarf_regnames_s390 ();
7611 init_dwarf_regnames_riscv ();
7619 /* Initialize the DWARF register name lookup state based on the
7620 architecture and specific machine type of a BFD. */
7623 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7626 dwarf_regnames_lookup_func
= NULL
;
7633 case bfd_mach_x86_64
:
7634 case bfd_mach_x86_64_intel_syntax
:
7635 case bfd_mach_x86_64_nacl
:
7636 case bfd_mach_x64_32
:
7637 case bfd_mach_x64_32_intel_syntax
:
7638 case bfd_mach_x64_32_nacl
:
7639 init_dwarf_regnames_x86_64 ();
7643 init_dwarf_regnames_i386 ();
7648 case bfd_arch_iamcu
:
7649 init_dwarf_regnames_iamcu ();
7652 case bfd_arch_aarch64
:
7653 init_dwarf_regnames_aarch64();
7657 init_dwarf_regnames_s390 ();
7660 case bfd_arch_riscv
:
7661 init_dwarf_regnames_riscv ();
7670 regname_internal_by_table_only (unsigned int regno
)
7672 if (dwarf_regnames
!= NULL
7673 && regno
< dwarf_regnames_count
7674 && dwarf_regnames
[regno
] != NULL
)
7675 return dwarf_regnames
[regno
];
7681 regname (unsigned int regno
, int name_only_p
)
7683 static char reg
[64];
7685 const char *name
= NULL
;
7687 if (dwarf_regnames_lookup_func
!= NULL
)
7688 name
= dwarf_regnames_lookup_func (regno
);
7694 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7697 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7702 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7707 if (*max_regs
!= fc
->ncols
)
7708 *max_regs
= fc
->ncols
;
7710 if (*need_col_headers
)
7712 static const char *sloc
= " LOC";
7714 *need_col_headers
= 0;
7716 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7718 for (r
= 0; r
< *max_regs
; r
++)
7719 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7724 printf ("%-5s ", regname (r
, 1));
7730 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7732 strcpy (tmp
, "exp");
7734 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7735 printf ("%-8s ", tmp
);
7737 for (r
= 0; r
< fc
->ncols
; r
++)
7739 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7741 switch (fc
->col_type
[r
])
7743 case DW_CFA_undefined
:
7746 case DW_CFA_same_value
:
7750 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7752 case DW_CFA_val_offset
:
7753 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7755 case DW_CFA_register
:
7756 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7758 case DW_CFA_expression
:
7759 strcpy (tmp
, "exp");
7761 case DW_CFA_val_expression
:
7762 strcpy (tmp
, "vexp");
7765 strcpy (tmp
, "n/a");
7768 printf ("%-5s ", tmp
);
7774 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7776 static unsigned char *
7777 read_cie (unsigned char *start
, unsigned char *end
,
7778 Frame_Chunk
**p_cie
, int *p_version
,
7779 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7783 unsigned char *augmentation_data
= NULL
;
7784 bfd_size_type augmentation_data_len
= 0;
7787 /* PR 17512: file: 001-228113-0.004. */
7791 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7792 memset (fc
, 0, sizeof (Frame_Chunk
));
7794 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7795 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7799 fc
->augmentation
= (char *) start
;
7800 /* PR 17512: file: 001-228113-0.004.
7801 Skip past augmentation name, but avoid running off the end of the data. */
7803 if (* start
++ == '\0')
7807 warn (_("No terminator for augmentation name\n"));
7811 if (strcmp (fc
->augmentation
, "eh") == 0)
7812 start
+= eh_addr_size
;
7816 GET (fc
->ptr_size
, 1);
7817 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7819 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7823 GET (fc
->segment_size
, 1);
7824 /* PR 17512: file: e99d2804. */
7825 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7827 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7831 eh_addr_size
= fc
->ptr_size
;
7835 fc
->ptr_size
= eh_addr_size
;
7836 fc
->segment_size
= 0;
7839 READ_ULEB (fc
->code_factor
, start
, end
);
7840 READ_SLEB (fc
->data_factor
, start
, end
);
7848 READ_ULEB (fc
->ra
, start
, end
);
7851 if (fc
->augmentation
[0] == 'z')
7853 READ_ULEB (augmentation_data_len
, start
, end
);
7854 augmentation_data
= start
;
7855 /* PR 17512: file: 11042-2589-0.004. */
7856 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7858 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7859 dwarf_vmatoa ("x", augmentation_data_len
),
7860 (unsigned long) (end
- start
));
7863 start
+= augmentation_data_len
;
7866 if (augmentation_data_len
)
7870 unsigned char *qend
;
7872 p
= (unsigned char *) fc
->augmentation
+ 1;
7873 q
= augmentation_data
;
7874 qend
= q
+ augmentation_data_len
;
7876 while (p
< end
&& q
< qend
)
7881 q
+= 1 + size_of_encoded_value (*q
);
7883 fc
->fde_encoding
= *q
++;
7892 /* Note - it is OK if this loop terminates with q < qend.
7893 Padding may have been inserted to align the end of the CIE. */
7898 *p_version
= version
;
7901 *p_aug_len
= augmentation_data_len
;
7902 *p_aug
= augmentation_data
;
7907 free (fc
->col_offset
);
7908 free (fc
->col_type
);
7913 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7914 If do_wide is not enabled, then formats the output to fit into 80 columns.
7915 PRINTED contains the number of characters already written to the current
7919 display_data (bfd_size_type printed
,
7920 const unsigned char * data
,
7921 const bfd_size_type len
)
7923 if (do_wide
|| len
< ((80 - printed
) / 3))
7924 for (printed
= 0; printed
< len
; ++printed
)
7925 printf (" %02x", data
[printed
]);
7928 for (printed
= 0; printed
< len
; ++printed
)
7930 if (printed
% (80 / 3) == 0)
7932 printf (" %02x", data
[printed
]);
7937 /* Prints out the contents on the augmentation data array.
7938 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7941 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7945 i
= printf (_(" Augmentation data: "));
7946 display_data (i
, data
, len
);
7950 display_debug_frames (struct dwarf_section
*section
,
7951 void *file ATTRIBUTE_UNUSED
)
7953 unsigned char *start
= section
->start
;
7954 unsigned char *end
= start
+ section
->size
;
7955 unsigned char *section_start
= start
;
7956 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7957 Frame_Chunk
*remembered_state
= NULL
;
7959 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7960 unsigned int max_regs
= 0;
7961 const char *bad_reg
= _("bad register: ");
7962 unsigned int saved_eh_addr_size
= eh_addr_size
;
7964 introduce (section
, FALSE
);
7968 unsigned char *saved_start
;
7969 unsigned char *block_end
;
7974 int need_col_headers
= 1;
7975 unsigned char *augmentation_data
= NULL
;
7976 bfd_size_type augmentation_data_len
= 0;
7977 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7978 unsigned int offset_size
;
7979 unsigned int initial_length_size
;
7980 bfd_boolean all_nops
;
7981 static Frame_Chunk fde_fc
;
7983 saved_start
= start
;
7985 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7989 printf ("\n%08lx ZERO terminator\n\n",
7990 (unsigned long)(saved_start
- section_start
));
7991 /* Skip any zero terminators that directly follow.
7992 A corrupt section size could have loaded a whole
7993 slew of zero filled memory bytes. eg
7994 PR 17512: file: 070-19381-0.004. */
7995 while (start
< end
&& * start
== 0)
8000 if (length
== 0xffffffff)
8002 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8004 initial_length_size
= 12;
8009 initial_length_size
= 4;
8012 block_end
= saved_start
+ length
+ initial_length_size
;
8013 if (block_end
> end
|| block_end
< start
)
8015 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8016 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8017 (unsigned long) (saved_start
- section_start
));
8021 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8023 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8024 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8029 start
= read_cie (start
, end
, &cie
, &version
,
8030 &augmentation_data_len
, &augmentation_data
);
8031 /* PR 17512: file: 027-135133-0.005. */
8038 fc
->chunk_start
= saved_start
;
8039 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8042 if (frame_need_space (fc
, mreg
) < 0)
8044 if (fc
->fde_encoding
)
8045 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8047 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8048 print_dwarf_vma (length
, fc
->ptr_size
);
8049 print_dwarf_vma (cie_id
, offset_size
);
8051 if (do_debug_frames_interp
)
8053 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8054 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8059 printf (" Version: %d\n", version
);
8060 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8063 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8064 printf (" Segment Size: %u\n", fc
->segment_size
);
8066 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8067 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8068 printf (" Return address column: %d\n", fc
->ra
);
8070 if (augmentation_data_len
)
8071 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8078 unsigned char *look_for
;
8079 unsigned long segment_selector
;
8083 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8084 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8087 look_for
= section_start
+ cie_id
;
8089 if (look_for
<= saved_start
)
8091 for (cie
= chunks
; cie
; cie
= cie
->next
)
8092 if (cie
->chunk_start
== look_for
)
8097 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8098 if (cie
->chunk_start
== look_for
)
8102 unsigned int off_size
;
8103 unsigned char *cie_scan
;
8105 cie_scan
= look_for
;
8107 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8108 if (length
== 0xffffffff)
8110 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8117 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8120 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8121 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8126 read_cie (cie_scan
, end
, &cie
, &version
,
8127 &augmentation_data_len
, &augmentation_data
);
8128 /* PR 17512: file: 3450-2098-0.004. */
8131 warn (_("Failed to read CIE information\n"));
8134 cie
->next
= forward_refs
;
8136 cie
->chunk_start
= look_for
;
8137 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8140 if (frame_need_space (cie
, mreg
) < 0)
8142 warn (_("Invalid max register\n"));
8145 if (cie
->fde_encoding
)
8147 = size_of_encoded_value (cie
->fde_encoding
);
8154 memset (fc
, 0, sizeof (Frame_Chunk
));
8158 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8159 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8160 (unsigned long) (saved_start
- section_start
));
8162 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8163 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8164 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8166 warn (_("Invalid max register\n"));
8170 fc
->augmentation
= "";
8171 fc
->fde_encoding
= 0;
8172 fc
->ptr_size
= eh_addr_size
;
8173 fc
->segment_size
= 0;
8177 fc
->ncols
= cie
->ncols
;
8178 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8179 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8180 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8181 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8182 fc
->augmentation
= cie
->augmentation
;
8183 fc
->ptr_size
= cie
->ptr_size
;
8184 eh_addr_size
= cie
->ptr_size
;
8185 fc
->segment_size
= cie
->segment_size
;
8186 fc
->code_factor
= cie
->code_factor
;
8187 fc
->data_factor
= cie
->data_factor
;
8188 fc
->cfa_reg
= cie
->cfa_reg
;
8189 fc
->cfa_offset
= cie
->cfa_offset
;
8191 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8193 warn (_("Invalid max register\n"));
8196 fc
->fde_encoding
= cie
->fde_encoding
;
8199 if (fc
->fde_encoding
)
8200 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8202 segment_selector
= 0;
8203 if (fc
->segment_size
)
8205 if (fc
->segment_size
> sizeof (segment_selector
))
8207 /* PR 17512: file: 9e196b3e. */
8208 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8209 fc
->segment_size
= 4;
8211 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8214 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8216 /* FIXME: It appears that sometimes the final pc_range value is
8217 encoded in less than encoded_ptr_size bytes. See the x86_64
8218 run of the "objcopy on compressed debug sections" test for an
8220 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8222 if (cie
->augmentation
[0] == 'z')
8224 READ_ULEB (augmentation_data_len
, start
, end
);
8225 augmentation_data
= start
;
8226 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8227 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8229 warn (_("Augmentation data too long: 0x%s, "
8230 "expected at most %#lx\n"),
8231 dwarf_vmatoa ("x", augmentation_data_len
),
8232 (unsigned long) (end
- start
));
8234 augmentation_data
= NULL
;
8235 augmentation_data_len
= 0;
8237 start
+= augmentation_data_len
;
8240 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8241 (unsigned long)(saved_start
- section_start
),
8242 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8243 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8244 (unsigned long)(cie
->chunk_start
- section_start
));
8246 if (fc
->segment_size
)
8247 printf ("%04lx:", segment_selector
);
8250 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8251 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8253 if (! do_debug_frames_interp
&& augmentation_data_len
)
8255 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8260 /* At this point, fc is the current chunk, cie (if any) is set, and
8261 we're about to interpret instructions for the chunk. */
8262 /* ??? At present we need to do this always, since this sizes the
8263 fc->col_type and fc->col_offset arrays, which we write into always.
8264 We should probably split the interpreted and non-interpreted bits
8265 into two different routines, since there's so much that doesn't
8266 really overlap between them. */
8267 if (1 || do_debug_frames_interp
)
8269 /* Start by making a pass over the chunk, allocating storage
8270 and taking note of what registers are used. */
8271 unsigned char *tmp
= start
;
8273 while (start
< block_end
)
8275 unsigned int reg
, op
, opa
;
8277 unsigned char * new_start
;
8284 /* Warning: if you add any more cases to this switch, be
8285 sure to add them to the corresponding switch below. */
8288 case DW_CFA_advance_loc
:
8291 SKIP_ULEB (start
, end
);
8292 if (frame_need_space (fc
, opa
) >= 0)
8293 fc
->col_type
[opa
] = DW_CFA_undefined
;
8295 case DW_CFA_restore
:
8296 if (frame_need_space (fc
, opa
) >= 0)
8297 fc
->col_type
[opa
] = DW_CFA_undefined
;
8299 case DW_CFA_set_loc
:
8300 start
+= encoded_ptr_size
;
8302 case DW_CFA_advance_loc1
:
8305 case DW_CFA_advance_loc2
:
8308 case DW_CFA_advance_loc4
:
8311 case DW_CFA_offset_extended
:
8312 case DW_CFA_val_offset
:
8313 READ_ULEB (reg
, start
, end
);
8314 SKIP_ULEB (start
, end
);
8315 if (frame_need_space (fc
, reg
) >= 0)
8316 fc
->col_type
[reg
] = DW_CFA_undefined
;
8318 case DW_CFA_restore_extended
:
8319 READ_ULEB (reg
, start
, end
);
8320 if (frame_need_space (fc
, reg
) >= 0)
8321 fc
->col_type
[reg
] = DW_CFA_undefined
;
8323 case DW_CFA_undefined
:
8324 READ_ULEB (reg
, start
, end
);
8325 if (frame_need_space (fc
, reg
) >= 0)
8326 fc
->col_type
[reg
] = DW_CFA_undefined
;
8328 case DW_CFA_same_value
:
8329 READ_ULEB (reg
, start
, end
);
8330 if (frame_need_space (fc
, reg
) >= 0)
8331 fc
->col_type
[reg
] = DW_CFA_undefined
;
8333 case DW_CFA_register
:
8334 READ_ULEB (reg
, start
, end
);
8335 SKIP_ULEB (start
, end
);
8336 if (frame_need_space (fc
, reg
) >= 0)
8337 fc
->col_type
[reg
] = DW_CFA_undefined
;
8339 case DW_CFA_def_cfa
:
8340 SKIP_ULEB (start
, end
);
8341 SKIP_ULEB (start
, end
);
8343 case DW_CFA_def_cfa_register
:
8344 SKIP_ULEB (start
, end
);
8346 case DW_CFA_def_cfa_offset
:
8347 SKIP_ULEB (start
, end
);
8349 case DW_CFA_def_cfa_expression
:
8350 READ_ULEB (temp
, start
, end
);
8351 new_start
= start
+ temp
;
8352 if (new_start
< start
)
8354 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8360 case DW_CFA_expression
:
8361 case DW_CFA_val_expression
:
8362 READ_ULEB (reg
, start
, end
);
8363 READ_ULEB (temp
, start
, end
);
8364 new_start
= start
+ temp
;
8365 if (new_start
< start
)
8367 /* PR 17512: file:306-192417-0.005. */
8368 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8373 if (frame_need_space (fc
, reg
) >= 0)
8374 fc
->col_type
[reg
] = DW_CFA_undefined
;
8376 case DW_CFA_offset_extended_sf
:
8377 case DW_CFA_val_offset_sf
:
8378 READ_ULEB (reg
, start
, end
);
8379 SKIP_SLEB (start
, end
);
8380 if (frame_need_space (fc
, reg
) >= 0)
8381 fc
->col_type
[reg
] = DW_CFA_undefined
;
8383 case DW_CFA_def_cfa_sf
:
8384 SKIP_ULEB (start
, end
);
8385 SKIP_SLEB (start
, end
);
8387 case DW_CFA_def_cfa_offset_sf
:
8388 SKIP_SLEB (start
, end
);
8390 case DW_CFA_MIPS_advance_loc8
:
8393 case DW_CFA_GNU_args_size
:
8394 SKIP_ULEB (start
, end
);
8396 case DW_CFA_GNU_negative_offset_extended
:
8397 READ_ULEB (reg
, start
, end
);
8398 SKIP_ULEB (start
, end
);
8399 if (frame_need_space (fc
, reg
) >= 0)
8400 fc
->col_type
[reg
] = DW_CFA_undefined
;
8411 /* Now we know what registers are used, make a second pass over
8412 the chunk, this time actually printing out the info. */
8414 while (start
< block_end
)
8416 unsigned char * tmp
;
8418 unsigned long ul
, roffs
;
8419 /* Note: It is tempting to use an unsigned long for 'reg' but there
8420 are various functions, notably frame_space_needed() that assume that
8421 reg is an unsigned int. */
8426 const char *reg_prefix
= "";
8433 /* Make a note if something other than DW_CFA_nop happens. */
8434 if (op
!= DW_CFA_nop
)
8437 /* Warning: if you add any more cases to this switch, be
8438 sure to add them to the corresponding switch above. */
8441 case DW_CFA_advance_loc
:
8442 if (do_debug_frames_interp
)
8443 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8445 printf (" DW_CFA_advance_loc: %d to %s\n",
8446 opa
* fc
->code_factor
,
8447 dwarf_vmatoa_1 (NULL
,
8448 fc
->pc_begin
+ opa
* fc
->code_factor
,
8450 fc
->pc_begin
+= opa
* fc
->code_factor
;
8454 READ_ULEB (roffs
, start
, end
);
8455 if (opa
>= (unsigned int) fc
->ncols
)
8456 reg_prefix
= bad_reg
;
8457 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8458 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8459 reg_prefix
, regname (opa
, 0),
8460 roffs
* fc
->data_factor
);
8461 if (*reg_prefix
== '\0')
8463 fc
->col_type
[opa
] = DW_CFA_offset
;
8464 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8468 case DW_CFA_restore
:
8469 if (opa
>= (unsigned int) fc
->ncols
)
8470 reg_prefix
= bad_reg
;
8471 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8472 printf (" DW_CFA_restore: %s%s\n",
8473 reg_prefix
, regname (opa
, 0));
8474 if (*reg_prefix
!= '\0')
8477 if (opa
>= (unsigned int) cie
->ncols
8478 || (do_debug_frames_interp
8479 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8481 fc
->col_type
[opa
] = DW_CFA_undefined
;
8482 fc
->col_offset
[opa
] = 0;
8486 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8487 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8491 case DW_CFA_set_loc
:
8492 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8493 if (do_debug_frames_interp
)
8494 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8496 printf (" DW_CFA_set_loc: %s\n",
8497 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8501 case DW_CFA_advance_loc1
:
8502 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8503 if (do_debug_frames_interp
)
8504 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8506 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8507 (unsigned long) (ofs
* fc
->code_factor
),
8508 dwarf_vmatoa_1 (NULL
,
8509 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8511 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8514 case DW_CFA_advance_loc2
:
8515 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8516 if (do_debug_frames_interp
)
8517 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8519 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8520 (unsigned long) (ofs
* fc
->code_factor
),
8521 dwarf_vmatoa_1 (NULL
,
8522 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8524 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8527 case DW_CFA_advance_loc4
:
8528 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8529 if (do_debug_frames_interp
)
8530 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8532 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8533 (unsigned long) (ofs
* fc
->code_factor
),
8534 dwarf_vmatoa_1 (NULL
,
8535 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8537 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8540 case DW_CFA_offset_extended
:
8541 READ_ULEB (reg
, start
, end
);
8542 READ_ULEB (roffs
, start
, end
);
8543 if (reg
>= (unsigned int) fc
->ncols
)
8544 reg_prefix
= bad_reg
;
8545 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8546 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8547 reg_prefix
, regname (reg
, 0),
8548 roffs
* fc
->data_factor
);
8549 if (*reg_prefix
== '\0')
8551 fc
->col_type
[reg
] = DW_CFA_offset
;
8552 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8556 case DW_CFA_val_offset
:
8557 READ_ULEB (reg
, start
, end
);
8558 READ_ULEB (roffs
, start
, end
);
8559 if (reg
>= (unsigned int) fc
->ncols
)
8560 reg_prefix
= bad_reg
;
8561 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8562 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8563 reg_prefix
, regname (reg
, 0),
8564 roffs
* fc
->data_factor
);
8565 if (*reg_prefix
== '\0')
8567 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8568 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8572 case DW_CFA_restore_extended
:
8573 READ_ULEB (reg
, start
, end
);
8574 if (reg
>= (unsigned int) fc
->ncols
)
8575 reg_prefix
= bad_reg
;
8576 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8577 printf (" DW_CFA_restore_extended: %s%s\n",
8578 reg_prefix
, regname (reg
, 0));
8579 if (*reg_prefix
!= '\0')
8582 if (reg
>= (unsigned int) cie
->ncols
)
8584 fc
->col_type
[reg
] = DW_CFA_undefined
;
8585 fc
->col_offset
[reg
] = 0;
8589 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8590 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8594 case DW_CFA_undefined
:
8595 READ_ULEB (reg
, start
, end
);
8596 if (reg
>= (unsigned int) fc
->ncols
)
8597 reg_prefix
= bad_reg
;
8598 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8599 printf (" DW_CFA_undefined: %s%s\n",
8600 reg_prefix
, regname (reg
, 0));
8601 if (*reg_prefix
== '\0')
8603 fc
->col_type
[reg
] = DW_CFA_undefined
;
8604 fc
->col_offset
[reg
] = 0;
8608 case DW_CFA_same_value
:
8609 READ_ULEB (reg
, start
, end
);
8610 if (reg
>= (unsigned int) fc
->ncols
)
8611 reg_prefix
= bad_reg
;
8612 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8613 printf (" DW_CFA_same_value: %s%s\n",
8614 reg_prefix
, regname (reg
, 0));
8615 if (*reg_prefix
== '\0')
8617 fc
->col_type
[reg
] = DW_CFA_same_value
;
8618 fc
->col_offset
[reg
] = 0;
8622 case DW_CFA_register
:
8623 READ_ULEB (reg
, start
, end
);
8624 READ_ULEB (roffs
, start
, end
);
8625 if (reg
>= (unsigned int) fc
->ncols
)
8626 reg_prefix
= bad_reg
;
8627 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8629 printf (" DW_CFA_register: %s%s in ",
8630 reg_prefix
, regname (reg
, 0));
8631 puts (regname (roffs
, 0));
8633 if (*reg_prefix
== '\0')
8635 fc
->col_type
[reg
] = DW_CFA_register
;
8636 fc
->col_offset
[reg
] = roffs
;
8640 case DW_CFA_remember_state
:
8641 if (! do_debug_frames_interp
)
8642 printf (" DW_CFA_remember_state\n");
8643 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8644 rs
->cfa_offset
= fc
->cfa_offset
;
8645 rs
->cfa_reg
= fc
->cfa_reg
;
8647 rs
->cfa_exp
= fc
->cfa_exp
;
8648 rs
->ncols
= fc
->ncols
;
8649 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8650 sizeof (* rs
->col_type
));
8651 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8652 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8653 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8654 rs
->next
= remembered_state
;
8655 remembered_state
= rs
;
8658 case DW_CFA_restore_state
:
8659 if (! do_debug_frames_interp
)
8660 printf (" DW_CFA_restore_state\n");
8661 rs
= remembered_state
;
8664 remembered_state
= rs
->next
;
8665 fc
->cfa_offset
= rs
->cfa_offset
;
8666 fc
->cfa_reg
= rs
->cfa_reg
;
8668 fc
->cfa_exp
= rs
->cfa_exp
;
8669 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8671 warn (_("Invalid column number in saved frame state\n"));
8675 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8676 memcpy (fc
->col_offset
, rs
->col_offset
,
8677 rs
->ncols
* sizeof (* rs
->col_offset
));
8678 free (rs
->col_type
);
8679 free (rs
->col_offset
);
8682 else if (do_debug_frames_interp
)
8683 printf ("Mismatched DW_CFA_restore_state\n");
8686 case DW_CFA_def_cfa
:
8687 READ_ULEB (fc
->cfa_reg
, start
, end
);
8688 READ_ULEB (fc
->cfa_offset
, start
, end
);
8690 if (! do_debug_frames_interp
)
8691 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8692 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8695 case DW_CFA_def_cfa_register
:
8696 READ_ULEB (fc
->cfa_reg
, start
, end
);
8698 if (! do_debug_frames_interp
)
8699 printf (" DW_CFA_def_cfa_register: %s\n",
8700 regname (fc
->cfa_reg
, 0));
8703 case DW_CFA_def_cfa_offset
:
8704 READ_ULEB (fc
->cfa_offset
, start
, end
);
8705 if (! do_debug_frames_interp
)
8706 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8710 if (! do_debug_frames_interp
)
8711 printf (" DW_CFA_nop\n");
8714 case DW_CFA_def_cfa_expression
:
8715 READ_ULEB (ul
, start
, end
);
8716 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8718 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8721 if (! do_debug_frames_interp
)
8723 printf (" DW_CFA_def_cfa_expression (");
8724 decode_location_expression (start
, eh_addr_size
, 0, -1,
8732 case DW_CFA_expression
:
8733 READ_ULEB (reg
, start
, end
);
8734 READ_ULEB (ul
, start
, end
);
8735 if (reg
>= (unsigned int) fc
->ncols
)
8736 reg_prefix
= bad_reg
;
8737 /* PR 17512: file: 069-133014-0.006. */
8738 /* PR 17512: file: 98c02eb4. */
8740 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8742 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8745 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8747 printf (" DW_CFA_expression: %s%s (",
8748 reg_prefix
, regname (reg
, 0));
8749 decode_location_expression (start
, eh_addr_size
, 0, -1,
8753 if (*reg_prefix
== '\0')
8754 fc
->col_type
[reg
] = DW_CFA_expression
;
8758 case DW_CFA_val_expression
:
8759 READ_ULEB (reg
, start
, end
);
8760 READ_ULEB (ul
, start
, end
);
8761 if (reg
>= (unsigned int) fc
->ncols
)
8762 reg_prefix
= bad_reg
;
8764 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8766 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8769 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8771 printf (" DW_CFA_val_expression: %s%s (",
8772 reg_prefix
, regname (reg
, 0));
8773 decode_location_expression (start
, eh_addr_size
, 0, -1,
8777 if (*reg_prefix
== '\0')
8778 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8782 case DW_CFA_offset_extended_sf
:
8783 READ_ULEB (reg
, start
, end
);
8784 READ_SLEB (l
, start
, end
);
8785 if (frame_need_space (fc
, reg
) < 0)
8786 reg_prefix
= bad_reg
;
8787 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8788 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8789 reg_prefix
, regname (reg
, 0),
8790 (long)(l
* fc
->data_factor
));
8791 if (*reg_prefix
== '\0')
8793 fc
->col_type
[reg
] = DW_CFA_offset
;
8794 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8798 case DW_CFA_val_offset_sf
:
8799 READ_ULEB (reg
, start
, end
);
8800 READ_SLEB (l
, start
, end
);
8801 if (frame_need_space (fc
, reg
) < 0)
8802 reg_prefix
= bad_reg
;
8803 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8804 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8805 reg_prefix
, regname (reg
, 0),
8806 (long)(l
* fc
->data_factor
));
8807 if (*reg_prefix
== '\0')
8809 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8810 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8814 case DW_CFA_def_cfa_sf
:
8815 READ_ULEB (fc
->cfa_reg
, start
, end
);
8816 READ_ULEB (fc
->cfa_offset
, start
, end
);
8817 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8819 if (! do_debug_frames_interp
)
8820 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8821 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8824 case DW_CFA_def_cfa_offset_sf
:
8825 READ_ULEB (fc
->cfa_offset
, start
, end
);
8826 fc
->cfa_offset
*= fc
->data_factor
;
8827 if (! do_debug_frames_interp
)
8828 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8831 case DW_CFA_MIPS_advance_loc8
:
8832 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8833 if (do_debug_frames_interp
)
8834 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8836 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8837 (unsigned long) (ofs
* fc
->code_factor
),
8838 dwarf_vmatoa_1 (NULL
,
8839 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8841 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8844 case DW_CFA_GNU_window_save
:
8845 if (! do_debug_frames_interp
)
8846 printf (" DW_CFA_GNU_window_save\n");
8849 case DW_CFA_GNU_args_size
:
8850 READ_ULEB (ul
, start
, end
);
8851 if (! do_debug_frames_interp
)
8852 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8855 case DW_CFA_GNU_negative_offset_extended
:
8856 READ_ULEB (reg
, start
, end
);
8857 READ_SLEB (l
, start
, end
);
8859 if (frame_need_space (fc
, reg
) < 0)
8860 reg_prefix
= bad_reg
;
8861 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8862 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8863 reg_prefix
, regname (reg
, 0),
8864 (long)(l
* fc
->data_factor
));
8865 if (*reg_prefix
== '\0')
8867 fc
->col_type
[reg
] = DW_CFA_offset
;
8868 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8873 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8874 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8876 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8881 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8882 if (do_debug_frames_interp
&& ! all_nops
)
8883 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8885 if (fde_fc
.col_type
!= NULL
)
8887 free (fde_fc
.col_type
);
8888 fde_fc
.col_type
= NULL
;
8890 if (fde_fc
.col_offset
!= NULL
)
8892 free (fde_fc
.col_offset
);
8893 fde_fc
.col_offset
= NULL
;
8897 eh_addr_size
= saved_eh_addr_size
;
8902 while (remembered_state
!= NULL
)
8904 rs
= remembered_state
;
8905 remembered_state
= rs
->next
;
8906 free (rs
->col_type
);
8907 free (rs
->col_offset
);
8908 rs
->next
= NULL
; /* Paranoia. */
8912 while (chunks
!= NULL
)
8916 free (rs
->col_type
);
8917 free (rs
->col_offset
);
8918 rs
->next
= NULL
; /* Paranoia. */
8922 while (forward_refs
!= NULL
)
8925 forward_refs
= rs
->next
;
8926 free (rs
->col_type
);
8927 free (rs
->col_offset
);
8928 rs
->next
= NULL
; /* Paranoia. */
8938 display_debug_names (struct dwarf_section
*section
, void *file
)
8940 unsigned char *hdrptr
= section
->start
;
8941 dwarf_vma unit_length
;
8942 unsigned char *unit_start
;
8943 const unsigned char *const section_end
= section
->start
+ section
->size
;
8944 unsigned char *unit_end
;
8946 introduce (section
, FALSE
);
8948 load_debug_section_with_follow (str
, file
);
8950 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8952 unsigned int offset_size
;
8953 uint16_t dwarf_version
, padding
;
8954 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8955 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8956 uint32_t augmentation_string_size
;
8958 unsigned long sec_off
;
8959 bfd_boolean augmentation_printable
;
8960 const char *augmentation_string
;
8962 unit_start
= hdrptr
;
8964 /* Get and check the length of the block. */
8965 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8967 if (unit_length
== 0xffffffff)
8969 /* This section is 64-bit DWARF. */
8970 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8975 unit_end
= hdrptr
+ unit_length
;
8977 sec_off
= hdrptr
- section
->start
;
8978 if (sec_off
+ unit_length
< sec_off
8979 || sec_off
+ unit_length
> section
->size
)
8981 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8983 (unsigned long) (unit_start
- section
->start
),
8984 dwarf_vmatoa ("x", unit_length
));
8988 /* Get and check the version number. */
8989 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8990 printf (_("Version %ld\n"), (long) dwarf_version
);
8992 /* Prior versions did not exist, and future versions may not be
8993 backwards compatible. */
8994 if (dwarf_version
!= 5)
8996 warn (_("Only DWARF version 5 .debug_names "
8997 "is currently supported.\n"));
9001 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9003 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9006 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9007 if (comp_unit_count
== 0)
9008 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9010 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9011 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9012 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9013 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9014 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9016 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9017 if (augmentation_string_size
% 4 != 0)
9019 warn (_("Augmentation string length %u must be rounded up "
9020 "to a multiple of 4 in .debug_names.\n"),
9021 augmentation_string_size
);
9022 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9025 printf (_("Augmentation string:"));
9027 augmentation_printable
= TRUE
;
9028 augmentation_string
= (const char *) hdrptr
;
9030 for (i
= 0; i
< augmentation_string_size
; i
++)
9034 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9035 printf (" %02x", uc
);
9037 if (uc
!= 0 && !ISPRINT (uc
))
9038 augmentation_printable
= FALSE
;
9041 if (augmentation_printable
)
9045 i
< augmentation_string_size
&& augmentation_string
[i
];
9047 putchar (augmentation_string
[i
]);
9052 printf (_("CU table:\n"));
9053 for (i
= 0; i
< comp_unit_count
; i
++)
9057 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9058 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9062 printf (_("TU table:\n"));
9063 for (i
= 0; i
< local_type_unit_count
; i
++)
9067 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9068 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9072 printf (_("Foreign TU table:\n"));
9073 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9077 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9078 printf (_("[%3u] "), i
);
9079 print_dwarf_vma (signature
, 8);
9084 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9085 hdrptr
+= bucket_count
* sizeof (uint32_t);
9086 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9087 hdrptr
+= name_count
* sizeof (uint32_t);
9088 unsigned char *const name_table_string_offsets
= hdrptr
;
9089 hdrptr
+= name_count
* offset_size
;
9090 unsigned char *const name_table_entry_offsets
= hdrptr
;
9091 hdrptr
+= name_count
* offset_size
;
9092 unsigned char *const abbrev_table
= hdrptr
;
9093 hdrptr
+= abbrev_table_size
;
9094 const unsigned char *const abbrev_table_end
= hdrptr
;
9095 unsigned char *const entry_pool
= hdrptr
;
9096 if (hdrptr
> unit_end
)
9098 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9099 "for unit 0x%lx in the debug_names\n"),
9100 (long) (hdrptr
- section
->start
),
9101 (long) (unit_end
- section
->start
),
9102 (long) (unit_start
- section
->start
));
9106 size_t buckets_filled
= 0;
9108 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9110 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9115 printf (ngettext ("Used %zu of %lu bucket.\n",
9116 "Used %zu of %lu buckets.\n",
9118 buckets_filled
, (unsigned long) bucket_count
);
9120 uint32_t hash_prev
= 0;
9121 size_t hash_clash_count
= 0;
9122 size_t longest_clash
= 0;
9123 size_t this_length
= 0;
9125 for (hashi
= 0; hashi
< name_count
; hashi
++)
9127 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9131 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9135 longest_clash
= MAX (longest_clash
, this_length
);
9140 hash_prev
= hash_this
;
9142 printf (_("Out of %lu items there are %zu bucket clashes"
9143 " (longest of %zu entries).\n"),
9144 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9145 assert (name_count
== buckets_filled
+ hash_clash_count
);
9147 struct abbrev_lookup_entry
9149 dwarf_vma abbrev_tag
;
9150 unsigned char *abbrev_lookup_ptr
;
9152 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9153 size_t abbrev_lookup_used
= 0;
9154 size_t abbrev_lookup_allocated
= 0;
9156 unsigned char *abbrevptr
= abbrev_table
;
9159 dwarf_vma abbrev_tag
;
9161 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9162 if (abbrev_tag
== 0)
9164 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9166 abbrev_lookup_allocated
= MAX (0x100,
9167 abbrev_lookup_allocated
* 2);
9168 abbrev_lookup
= xrealloc (abbrev_lookup
,
9169 (abbrev_lookup_allocated
9170 * sizeof (*abbrev_lookup
)));
9172 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9173 struct abbrev_lookup_entry
*entry
;
9174 for (entry
= abbrev_lookup
;
9175 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9177 if (entry
->abbrev_tag
== abbrev_tag
)
9179 warn (_("Duplicate abbreviation tag %lu "
9180 "in unit 0x%lx in the debug_names\n"),
9181 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9184 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9185 entry
->abbrev_tag
= abbrev_tag
;
9186 entry
->abbrev_lookup_ptr
= abbrevptr
;
9188 /* Skip DWARF tag. */
9189 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9192 dwarf_vma xindex
, form
;
9194 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9195 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9196 if (xindex
== 0 && form
== 0)
9201 printf (_("\nSymbol table:\n"));
9203 for (namei
= 0; namei
< name_count
; ++namei
)
9205 uint64_t string_offset
, entry_offset
;
9207 SAFE_BYTE_GET (string_offset
,
9208 name_table_string_offsets
+ namei
* offset_size
,
9209 offset_size
, unit_end
);
9210 SAFE_BYTE_GET (entry_offset
,
9211 name_table_entry_offsets
+ namei
* offset_size
,
9212 offset_size
, unit_end
);
9214 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9215 fetch_indirect_string (string_offset
));
9217 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9219 // We need to scan first whether there is a single or multiple
9220 // entries. TAGNO is -2 for the first entry, it is -1 for the
9221 // initial tag read of the second entry, then it becomes 0 for the
9222 // first entry for real printing etc.
9224 /* Initialize it due to a false compiler warning. */
9225 dwarf_vma second_abbrev_tag
= -1;
9228 dwarf_vma abbrev_tag
;
9229 dwarf_vma dwarf_tag
;
9230 const struct abbrev_lookup_entry
*entry
;
9232 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9235 second_abbrev_tag
= abbrev_tag
;
9237 entryptr
= entry_pool
+ entry_offset
;
9240 if (abbrev_tag
== 0)
9244 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9245 (unsigned long) abbrev_tag
);
9247 for (entry
= abbrev_lookup
;
9248 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9250 if (entry
->abbrev_tag
== abbrev_tag
)
9252 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9254 warn (_("Undefined abbreviation tag %lu "
9255 "in unit 0x%lx in the debug_names\n"),
9257 (long) (unit_start
- section
->start
));
9260 abbrevptr
= entry
->abbrev_lookup_ptr
;
9261 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9263 printf (" %s", get_TAG_name (dwarf_tag
));
9266 dwarf_vma xindex
, form
;
9268 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9269 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9270 if (xindex
== 0 && form
== 0)
9274 printf (" %s", get_IDX_name (xindex
));
9275 entryptr
= read_and_display_attr_value (0, form
, 0,
9276 unit_start
, entryptr
, unit_end
,
9278 dwarf_version
, NULL
,
9285 printf (_(" <no entries>"));
9289 free (abbrev_lookup
);
9296 display_debug_links (struct dwarf_section
* section
,
9297 void * file ATTRIBUTE_UNUSED
)
9299 const unsigned char * filename
;
9300 unsigned int filelen
;
9302 introduce (section
, FALSE
);
9304 /* The .gnu_debuglink section is formatted as:
9305 (c-string) Filename.
9306 (padding) If needed to reach a 4 byte boundary.
9307 (uint32_t) CRC32 value.
9309 The .gun_debugaltlink section is formatted as:
9310 (c-string) Filename.
9311 (binary) Build-ID. */
9313 filename
= section
->start
;
9314 filelen
= strnlen ((const char *) filename
, section
->size
);
9315 if (filelen
== section
->size
)
9317 warn (_("The debuglink filename is corrupt/missing\n"));
9321 printf (_(" Separate debug info file: %s\n"), filename
);
9323 if (const_strneq (section
->name
, ".gnu_debuglink"))
9326 unsigned int crc_offset
;
9328 crc_offset
= filelen
+ 1;
9329 crc_offset
= (crc_offset
+ 3) & ~3;
9330 if (crc_offset
+ 4 > section
->size
)
9332 warn (_("CRC offset missing/truncated\n"));
9336 crc32
= byte_get (filename
+ crc_offset
, 4);
9338 printf (_(" CRC value: %#x\n"), crc32
);
9340 if (crc_offset
+ 4 < section
->size
)
9342 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9343 (long)(section
->size
- (crc_offset
+ 4)));
9347 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9349 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9350 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9351 bfd_size_type printed
;
9353 /* FIXME: Should we support smaller build-id notes ? */
9354 if (build_id_len
< 0x14)
9356 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9360 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9361 display_data (printed
, build_id
, build_id_len
);
9370 display_gdb_index (struct dwarf_section
*section
,
9371 void *file ATTRIBUTE_UNUSED
)
9373 unsigned char *start
= section
->start
;
9375 uint32_t cu_list_offset
, tu_list_offset
;
9376 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9377 unsigned int cu_list_elements
, tu_list_elements
;
9378 unsigned int address_table_size
, symbol_table_slots
;
9379 unsigned char *cu_list
, *tu_list
;
9380 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9383 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9385 introduce (section
, FALSE
);
9387 if (section
->size
< 6 * sizeof (uint32_t))
9389 warn (_("Truncated header in the %s section.\n"), section
->name
);
9393 version
= byte_get_little_endian (start
, 4);
9394 printf (_("Version %ld\n"), (long) version
);
9396 /* Prior versions are obsolete, and future versions may not be
9397 backwards compatible. */
9398 if (version
< 3 || version
> 8)
9400 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9404 warn (_("The address table data in version 3 may be wrong.\n"));
9406 warn (_("Version 4 does not support case insensitive lookups.\n"));
9408 warn (_("Version 5 does not include inlined functions.\n"));
9410 warn (_("Version 6 does not include symbol attributes.\n"));
9411 /* Version 7 indices generated by Gold have bad type unit references,
9412 PR binutils/15021. But we don't know if the index was generated by
9413 Gold or not, so to avoid worrying users with gdb-generated indices
9414 we say nothing for version 7 here. */
9416 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9417 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9418 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9419 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9420 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9422 if (cu_list_offset
> section
->size
9423 || tu_list_offset
> section
->size
9424 || address_table_offset
> section
->size
9425 || symbol_table_offset
> section
->size
9426 || constant_pool_offset
> section
->size
)
9428 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9432 /* PR 17531: file: 418d0a8a. */
9433 if (tu_list_offset
< cu_list_offset
)
9435 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9436 tu_list_offset
, cu_list_offset
);
9440 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9442 if (address_table_offset
< tu_list_offset
)
9444 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9445 address_table_offset
, tu_list_offset
);
9449 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9451 /* PR 17531: file: 18a47d3d. */
9452 if (symbol_table_offset
< address_table_offset
)
9454 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9455 symbol_table_offset
, address_table_offset
);
9459 address_table_size
= symbol_table_offset
- address_table_offset
;
9461 if (constant_pool_offset
< symbol_table_offset
)
9463 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9464 constant_pool_offset
, symbol_table_offset
);
9468 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9470 cu_list
= start
+ cu_list_offset
;
9471 tu_list
= start
+ tu_list_offset
;
9472 address_table
= start
+ address_table_offset
;
9473 symbol_table
= start
+ symbol_table_offset
;
9474 constant_pool
= start
+ constant_pool_offset
;
9476 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9478 warn (_("Address table extends beyond end of section.\n"));
9482 printf (_("\nCU table:\n"));
9483 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9485 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9486 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9488 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9489 (unsigned long) cu_offset
,
9490 (unsigned long) (cu_offset
+ cu_length
- 1));
9493 printf (_("\nTU table:\n"));
9494 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9496 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9497 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9498 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9500 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9501 (unsigned long) tu_offset
,
9502 (unsigned long) type_offset
);
9503 print_dwarf_vma (signature
, 8);
9507 printf (_("\nAddress table:\n"));
9508 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9511 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9512 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9513 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9515 print_dwarf_vma (low
, 8);
9516 print_dwarf_vma (high
, 8);
9517 printf (_("%lu\n"), (unsigned long) cu_index
);
9520 printf (_("\nSymbol table:\n"));
9521 for (i
= 0; i
< symbol_table_slots
; ++i
)
9523 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9524 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9525 uint32_t num_cus
, cu
;
9527 if (name_offset
!= 0
9528 || cu_vector_offset
!= 0)
9531 unsigned char * adr
;
9533 adr
= constant_pool
+ name_offset
;
9534 /* PR 17531: file: 5b7b07ad. */
9535 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9537 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9538 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9542 printf ("[%3u] %.*s:", i
,
9543 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9544 constant_pool
+ name_offset
);
9546 adr
= constant_pool
+ cu_vector_offset
;
9547 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9549 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9550 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9551 cu_vector_offset
, i
);
9555 num_cus
= byte_get_little_endian (adr
, 4);
9557 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9558 if (num_cus
* 4 < num_cus
9559 || adr
>= section
->start
+ section
->size
9560 || adr
< constant_pool
)
9562 printf ("<invalid number of CUs: %d>\n", num_cus
);
9563 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9571 for (j
= 0; j
< num_cus
; ++j
)
9574 gdb_index_symbol_kind kind
;
9576 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9577 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9578 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9579 cu
= GDB_INDEX_CU_VALUE (cu
);
9580 /* Convert to TU number if it's for a type unit. */
9581 if (cu
>= cu_list_elements
/ 2)
9582 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9583 (unsigned long) (cu
- cu_list_elements
/ 2));
9585 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9587 printf (" [%s, %s]",
9588 is_static
? _("static") : _("global"),
9589 get_gdb_index_symbol_kind_name (kind
));
9601 /* Pre-allocate enough space for the CU/TU sets needed. */
9604 prealloc_cu_tu_list (unsigned int nshndx
)
9606 if (shndx_pool
== NULL
)
9608 shndx_pool_size
= nshndx
;
9609 shndx_pool_used
= 0;
9610 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9611 sizeof (unsigned int));
9615 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9616 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9617 sizeof (unsigned int));
9622 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9624 if (shndx_pool_used
>= shndx_pool_size
)
9626 error (_("Internal error: out of space in the shndx pool.\n"));
9629 shndx_pool
[shndx_pool_used
++] = shndx
;
9633 end_cu_tu_entry (void)
9635 if (shndx_pool_used
>= shndx_pool_size
)
9637 error (_("Internal error: out of space in the shndx pool.\n"));
9640 shndx_pool
[shndx_pool_used
++] = 0;
9643 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9646 get_DW_SECT_short_name (unsigned int dw_sect
)
9648 static char buf
[16];
9656 case DW_SECT_ABBREV
:
9662 case DW_SECT_STR_OFFSETS
:
9664 case DW_SECT_MACINFO
:
9672 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9676 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9677 These sections are extensions for Fission.
9678 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9681 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9683 unsigned char *phdr
= section
->start
;
9684 unsigned char *limit
= phdr
+ section
->size
;
9685 unsigned char *phash
;
9686 unsigned char *pindex
;
9687 unsigned char *ppool
;
9688 unsigned int version
;
9689 unsigned int ncols
= 0;
9691 unsigned int nslots
;
9694 dwarf_vma signature_high
;
9695 dwarf_vma signature_low
;
9698 /* PR 17512: file: 002-168123-0.004. */
9701 warn (_("Section %s is empty\n"), section
->name
);
9704 /* PR 17512: file: 002-376-0.004. */
9705 if (section
->size
< 24)
9707 warn (_("Section %s is too small to contain a CU/TU header\n"),
9712 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9714 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9715 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9716 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9719 pindex
= phash
+ (size_t) nslots
* 8;
9720 ppool
= pindex
+ (size_t) nslots
* 4;
9724 introduce (section
, FALSE
);
9726 printf (_(" Version: %u\n"), version
);
9728 printf (_(" Number of columns: %u\n"), ncols
);
9729 printf (_(" Number of used entries: %u\n"), nused
);
9730 printf (_(" Number of slots: %u\n\n"), nslots
);
9733 /* PR 17531: file: 45d69832. */
9734 if ((size_t) nslots
* 8 / 8 != nslots
9735 || phash
< phdr
|| phash
> limit
9736 || pindex
< phash
|| pindex
> limit
9737 || ppool
< pindex
|| ppool
> limit
)
9739 warn (ngettext ("Section %s is too small for %u slot\n",
9740 "Section %s is too small for %u slots\n",
9742 section
->name
, nslots
);
9749 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9750 for (i
= 0; i
< nslots
; i
++)
9752 unsigned char *shndx_list
;
9755 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9756 if (signature_high
!= 0 || signature_low
!= 0)
9758 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9759 shndx_list
= ppool
+ j
* 4;
9760 /* PR 17531: file: 705e010d. */
9761 if (shndx_list
< ppool
)
9763 warn (_("Section index pool located before start of section\n"));
9768 printf (_(" [%3d] Signature: 0x%s Sections: "),
9769 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9770 buf
, sizeof (buf
)));
9773 if (shndx_list
>= limit
)
9775 warn (_("Section %s too small for shndx pool\n"),
9779 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9783 printf (" %d", shndx
);
9785 add_shndx_to_cu_tu_entry (shndx
);
9797 else if (version
== 2)
9800 unsigned int dw_sect
;
9801 unsigned char *ph
= phash
;
9802 unsigned char *pi
= pindex
;
9803 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9804 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9805 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9806 bfd_boolean is_tu_index
;
9807 struct cu_tu_set
*this_set
= NULL
;
9809 unsigned char *prow
;
9811 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9813 /* PR 17531: file: 0dd159bf.
9814 Check for integer overflow (can occur when size_t is 32-bit)
9815 with overlarge ncols or nused values. */
9817 && ((size_t) ncols
* 4 / 4 != ncols
9818 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9819 || poffsets
< ppool
|| poffsets
> limit
9820 || psizes
< poffsets
|| psizes
> limit
9821 || pend
< psizes
|| pend
> limit
))
9823 warn (_("Section %s too small for offset and size tables\n"),
9830 printf (_(" Offset table\n"));
9831 printf (" slot %-16s ",
9832 is_tu_index
? _("signature") : _("dwo_id"));
9839 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9845 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9852 for (j
= 0; j
< ncols
; j
++)
9854 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9855 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9860 for (i
= 0; i
< nslots
; i
++)
9862 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9864 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9867 /* PR 17531: file: a05f6ab3. */
9870 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9877 size_t num_copy
= sizeof (uint64_t);
9879 /* PR 23064: Beware of buffer overflow. */
9880 if (ph
+ num_copy
< limit
)
9881 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9884 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9889 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9890 /* PR 17531: file: b8ce60a8. */
9891 if (prow
< poffsets
|| prow
> limit
)
9893 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9899 printf (_(" [%3d] 0x%s"),
9900 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9901 buf
, sizeof (buf
)));
9902 for (j
= 0; j
< ncols
; j
++)
9904 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9906 printf (" %8d", val
);
9909 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9911 /* PR 17531: file: 10796eb3. */
9912 if (dw_sect
>= DW_SECT_MAX
)
9913 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9915 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9931 printf (_(" Size table\n"));
9932 printf (" slot %-16s ",
9933 is_tu_index
? _("signature") : _("dwo_id"));
9936 for (j
= 0; j
< ncols
; j
++)
9938 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9940 printf (" %8s", get_DW_SECT_short_name (val
));
9946 for (i
= 0; i
< nslots
; i
++)
9948 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9950 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9953 prow
= psizes
+ (row
- 1) * ncols
* 4;
9956 printf (_(" [%3d] 0x%s"),
9957 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9958 buf
, sizeof (buf
)));
9960 for (j
= 0; j
< ncols
; j
++)
9962 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9964 printf (" %8d", val
);
9967 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9968 if (dw_sect
>= DW_SECT_MAX
)
9969 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9971 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9983 else if (do_display
)
9984 printf (_(" Unsupported version (%d)\n"), version
);
9992 /* Load the CU and TU indexes if present. This will build a list of
9993 section sets that we can use to associate a .debug_info.dwo section
9994 with its associated .debug_abbrev.dwo section in a .dwp file. */
9997 load_cu_tu_indexes (void *file
)
9999 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10001 /* If we have already loaded (or tried to load) the CU and TU indexes
10002 then do not bother to repeat the task. */
10003 if (cu_tu_indexes_read
== -1)
10005 cu_tu_indexes_read
= TRUE
;
10007 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10008 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10009 cu_tu_indexes_read
= FALSE
;
10011 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10012 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10013 cu_tu_indexes_read
= FALSE
;
10016 return (bfd_boolean
) cu_tu_indexes_read
;
10019 /* Find the set of sections that includes section SHNDX. */
10022 find_cu_tu_set (void *file
, unsigned int shndx
)
10026 if (! load_cu_tu_indexes (file
))
10029 /* Find SHNDX in the shndx pool. */
10030 for (i
= 0; i
< shndx_pool_used
; i
++)
10031 if (shndx_pool
[i
] == shndx
)
10034 if (i
>= shndx_pool_used
)
10037 /* Now backup to find the first entry in the set. */
10038 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10041 return shndx_pool
+ i
;
10044 /* Display a .debug_cu_index or .debug_tu_index section. */
10047 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10049 return process_cu_tu_index (section
, 1);
10053 display_debug_not_supported (struct dwarf_section
*section
,
10054 void *file ATTRIBUTE_UNUSED
)
10056 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10062 /* Like malloc, but takes two parameters like calloc.
10063 Verifies that the first parameter is not too large.
10064 Note: does *not* initialise the allocated memory to zero. */
10067 cmalloc (size_t nmemb
, size_t size
)
10069 /* Check for overflow. */
10070 if (nmemb
>= ~(size_t) 0 / size
)
10073 return xmalloc (nmemb
* size
);
10076 /* Like xmalloc, but takes two parameters like calloc.
10077 Verifies that the first parameter is not too large.
10078 Note: does *not* initialise the allocated memory to zero. */
10081 xcmalloc (size_t nmemb
, size_t size
)
10083 /* Check for overflow. */
10084 if (nmemb
>= ~(size_t) 0 / size
)
10087 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10092 return xmalloc (nmemb
* size
);
10095 /* Like xrealloc, but takes three parameters.
10096 Verifies that the second parameter is not too large.
10097 Note: does *not* initialise any new memory to zero. */
10100 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10102 /* Check for overflow. */
10103 if (nmemb
>= ~(size_t) 0 / size
)
10105 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10110 return xrealloc (ptr
, nmemb
* size
);
10113 /* Like xcalloc, but verifies that the first parameter is not too large. */
10116 xcalloc2 (size_t nmemb
, size_t size
)
10118 /* Check for overflow. */
10119 if (nmemb
>= ~(size_t) 0 / size
)
10121 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10126 return xcalloc (nmemb
, size
);
10129 static unsigned long
10130 calc_gnu_debuglink_crc32 (unsigned long crc
,
10131 const unsigned char * buf
,
10134 static const unsigned long crc32_table
[256] =
10136 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10137 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10138 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10139 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10140 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10141 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10142 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10143 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10144 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10145 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10146 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10147 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10148 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10149 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10150 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10151 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10152 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10153 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10154 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10155 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10156 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10157 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10158 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10159 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10160 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10161 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10162 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10163 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10164 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10165 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10166 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10167 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10168 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10169 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10170 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10171 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10172 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10173 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10174 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10175 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10176 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10177 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10178 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10179 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10180 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10181 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10182 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10183 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10184 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10185 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10186 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10189 const unsigned char *end
;
10191 crc
= ~crc
& 0xffffffff;
10192 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10193 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10194 return ~crc
& 0xffffffff;
10197 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10198 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10201 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10203 static unsigned char buffer
[8 * 1024];
10205 bfd_size_type count
;
10206 unsigned long crc
= 0;
10209 sep_data
= open_debug_file (pathname
);
10210 if (sep_data
== NULL
)
10213 /* Yes - we are opening the file twice... */
10214 f
= fopen (pathname
, "rb");
10217 /* Paranoia: This should never happen. */
10218 close_debug_file (sep_data
);
10219 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10223 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10224 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10228 if (crc
!= * (unsigned long *) crc_pointer
)
10230 close_debug_file (sep_data
);
10231 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10239 static const char *
10240 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10243 unsigned int crc_offset
;
10244 unsigned long * crc32
= (unsigned long *) data
;
10246 /* The name is first.
10247 The CRC value is stored after the filename, aligned up to 4 bytes. */
10248 name
= (const char *) section
->start
;
10251 crc_offset
= strnlen (name
, section
->size
) + 1;
10252 crc_offset
= (crc_offset
+ 3) & ~3;
10253 if (crc_offset
+ 4 > section
->size
)
10256 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10261 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10263 void * sep_data
= open_debug_file (filename
);
10265 if (sep_data
== NULL
)
10268 /* FIXME: We should now extract the build-id in the separate file
10274 typedef struct build_id_data
10277 const unsigned char * data
;
10280 static const char *
10281 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10284 bfd_size_type namelen
;
10285 bfd_size_type id_len
;
10286 Build_id_data
* build_id_data
;
10288 /* The name is first.
10289 The build-id follows immediately, with no padding, up to the section's end. */
10291 name
= (const char *) section
->start
;
10292 namelen
= strnlen (name
, section
->size
) + 1;
10293 if (namelen
>= section
->size
)
10296 id_len
= section
->size
- namelen
;
10300 build_id_data
= calloc (1, sizeof * build_id_data
);
10301 if (build_id_data
== NULL
)
10304 build_id_data
->len
= id_len
;
10305 build_id_data
->data
= section
->start
+ namelen
;
10307 * (Build_id_data
**) data
= build_id_data
;
10313 add_separate_debug_file (const char * filename
, void * handle
)
10315 separate_info
* i
= xmalloc (sizeof * i
);
10317 i
->filename
= filename
;
10318 i
->handle
= handle
;
10319 i
->next
= first_separate_info
;
10320 first_separate_info
= i
;
10323 #if HAVE_LIBDEBUGINFOD
10324 /* Query debuginfod servers for the target debuglink or debugaltlink
10325 file. If successful, store the path of the file in filename and
10326 return TRUE, otherwise return FALSE. */
10329 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10333 size_t build_id_len
;
10334 unsigned char * build_id
;
10336 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10338 /* Get the build-id of file. */
10339 build_id
= get_build_id (file
);
10342 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10344 /* Get the build-id of the debugaltlink file. */
10345 unsigned int filelen
;
10347 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10348 if (filelen
== section
->size
)
10349 /* Corrupt debugaltlink. */
10352 build_id
= section
->start
+ filelen
+ 1;
10353 build_id_len
= section
->size
- (filelen
+ 1);
10355 if (build_id_len
== 0)
10364 debuginfod_client
* client
;
10366 client
= debuginfod_begin ();
10367 if (client
== NULL
)
10370 /* Query debuginfod servers for the target file. If found its path
10371 will be stored in filename. */
10372 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10373 debuginfod_end (client
);
10375 /* Only free build_id if we allocated space for a hex string
10376 in get_build_id (). */
10377 if (build_id_len
== 0)
10382 /* File successfully retrieved. Close fd since we want to
10383 use open_debug_file () on filename instead. */
10394 load_separate_debug_info (const char * main_filename
,
10395 struct dwarf_section
* xlink
,
10396 parse_func_type parse_func
,
10397 check_func_type check_func
,
10399 void * file ATTRIBUTE_UNUSED
)
10401 const char * separate_filename
;
10402 char * debug_filename
;
10404 size_t canon_dirlen
;
10407 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10409 warn (_("Corrupt debuglink section: %s\n"),
10410 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10414 /* Attempt to locate the separate file.
10415 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10417 canon_dir
= lrealpath (main_filename
);
10419 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10420 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10422 canon_dir
[canon_dirlen
] = '\0';
10425 #define DEBUGDIR "/lib/debug"
10427 #ifndef EXTRA_DEBUG_ROOT1
10428 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10430 #ifndef EXTRA_DEBUG_ROOT2
10431 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10434 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10436 + strlen (".debug/")
10437 #ifdef EXTRA_DEBUG_ROOT1
10438 + strlen (EXTRA_DEBUG_ROOT1
)
10440 #ifdef EXTRA_DEBUG_ROOT2
10441 + strlen (EXTRA_DEBUG_ROOT2
)
10443 + strlen (separate_filename
)
10445 if (debug_filename
== NULL
)
10447 warn (_("Out of memory"));
10452 /* First try in the current directory. */
10453 sprintf (debug_filename
, "%s", separate_filename
);
10454 if (check_func (debug_filename
, func_data
))
10457 /* Then try in a subdirectory called .debug. */
10458 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10459 if (check_func (debug_filename
, func_data
))
10462 /* Then try in the same directory as the original file. */
10463 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10464 if (check_func (debug_filename
, func_data
))
10467 /* And the .debug subdirectory of that directory. */
10468 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10469 if (check_func (debug_filename
, func_data
))
10472 #ifdef EXTRA_DEBUG_ROOT1
10473 /* Try the first extra debug file root. */
10474 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10475 if (check_func (debug_filename
, func_data
))
10478 /* Try the first extra debug file root. */
10479 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10480 if (check_func (debug_filename
, func_data
))
10484 #ifdef EXTRA_DEBUG_ROOT2
10485 /* Try the second extra debug file root. */
10486 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10487 if (check_func (debug_filename
, func_data
))
10491 /* Then try in the global debug_filename directory. */
10492 strcpy (debug_filename
, DEBUGDIR
);
10493 dirlen
= strlen (DEBUGDIR
) - 1;
10494 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10495 strcat (debug_filename
, "/");
10496 strcat (debug_filename
, (const char *) separate_filename
);
10498 if (check_func (debug_filename
, func_data
))
10501 #if HAVE_LIBDEBUGINFOD
10503 char * tmp_filename
;
10505 if (debuginfod_fetch_separate_debug_info (xlink
,
10509 /* File successfully downloaded from server, replace
10510 debug_filename with the file's path. */
10511 free (debug_filename
);
10512 debug_filename
= tmp_filename
;
10518 /* Failed to find the file. */
10519 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10520 warn (_("tried: %s\n"), debug_filename
);
10522 #ifdef EXTRA_DEBUG_ROOT2
10523 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10524 warn (_("tried: %s\n"), debug_filename
);
10527 #ifdef EXTRA_DEBUG_ROOT1
10528 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10529 warn (_("tried: %s\n"), debug_filename
);
10531 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10532 warn (_("tried: %s\n"), debug_filename
);
10535 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10536 warn (_("tried: %s\n"), debug_filename
);
10538 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10539 warn (_("tried: %s\n"), debug_filename
);
10541 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10542 warn (_("tried: %s\n"), debug_filename
);
10544 sprintf (debug_filename
, "%s", separate_filename
);
10545 warn (_("tried: %s\n"), debug_filename
);
10547 #if HAVE_LIBDEBUGINFOD
10549 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10553 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10558 free (debug_filename
);
10564 void * debug_handle
;
10566 /* Now open the file.... */
10567 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10569 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10570 free (debug_filename
);
10574 /* FIXME: We do not check to see if there are any other separate debug info
10575 files that would also match. */
10577 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10578 add_separate_debug_file (debug_filename
, debug_handle
);
10580 /* Do not free debug_filename - it might be referenced inside
10581 the structure returned by open_debug_file(). */
10582 return debug_handle
;
10585 /* Attempt to load a separate dwarf object file. */
10588 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10590 char * separate_filename
;
10591 void * separate_handle
;
10593 /* FIXME: Skip adding / if dwo_dir ends in /. */
10594 separate_filename
= concat (dir
, "/", name
, NULL
);
10595 if (separate_filename
== NULL
)
10597 warn (_("Out of memory allocating dwo filename\n"));
10601 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10603 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10604 free (separate_filename
);
10608 /* FIXME: We should check the dwo_id. */
10610 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10611 add_separate_debug_file (separate_filename
, separate_handle
);
10612 /* Note - separate_filename will be freed in free_debug_memory(). */
10613 return separate_handle
;
10616 /* Load the separate debug info file(s) attached to FILE, if any exist.
10617 Returns TRUE if any were found, FALSE otherwise.
10618 If TRUE is returned then the linked list starting at first_separate_info
10619 will be populated with open file handles. */
10622 load_separate_debug_files (void * file
, const char * filename
)
10624 /* Skip this operation if we are not interested in debug links. */
10625 if (! do_follow_links
&& ! do_debug_links
)
10628 /* See if there are any dwo links. */
10629 if (load_debug_section (str
, file
)
10630 && load_debug_section (abbrev
, file
)
10631 && load_debug_section (info
, file
))
10635 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10637 bfd_boolean introduced
= FALSE
;
10639 const char * dir
= NULL
;
10640 const char * id
= NULL
;
10642 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10644 switch (dwinfo
->type
)
10647 if (do_debug_links
)
10651 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10652 debug_displays
[info
].section
.uncompressed_name
);
10656 printf (_(" Name: %s\n"), dwinfo
->value
);
10657 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10659 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10661 printf (_(" ID: <unknown>\n"));
10665 if (do_follow_links
)
10666 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10670 dir
= dwinfo
->value
;
10674 id
= dwinfo
->value
;
10678 error (_("Unexpected DWO INFO type"));
10685 if (! do_follow_links
)
10686 /* The other debug links will be displayed by display_debug_links()
10687 so we do not need to do any further processing here. */
10690 /* FIXME: We do not check for the presence of both link sections in the same file. */
10691 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10692 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10693 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10695 if (load_debug_section (gnu_debugaltlink
, file
))
10697 Build_id_data
* build_id_data
;
10699 load_separate_debug_info (filename
,
10700 & debug_displays
[gnu_debugaltlink
].section
,
10701 parse_gnu_debugaltlink
,
10702 check_gnu_debugaltlink
,
10707 if (load_debug_section (gnu_debuglink
, file
))
10709 unsigned long crc32
;
10711 load_separate_debug_info (filename
,
10712 & debug_displays
[gnu_debuglink
].section
,
10713 parse_gnu_debuglink
,
10714 check_gnu_debuglink
,
10719 if (first_separate_info
!= NULL
)
10722 do_follow_links
= 0;
10727 free_debug_memory (void)
10733 for (i
= 0; i
< max
; i
++)
10734 free_debug_section ((enum dwarf_section_display_enum
) i
);
10736 if (debug_information
!= NULL
)
10738 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10740 for (i
= 0; i
< num_debug_info_entries
; i
++)
10742 if (!debug_information
[i
].max_loc_offsets
)
10744 free (debug_information
[i
].loc_offsets
);
10745 free (debug_information
[i
].have_frame_base
);
10747 if (!debug_information
[i
].max_range_lists
)
10748 free (debug_information
[i
].range_lists
);
10751 free (debug_information
);
10752 debug_information
= NULL
;
10753 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10757 separate_info
* next
;
10759 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10761 close_debug_file (d
->handle
);
10762 free ((void *) d
->filename
);
10766 first_separate_info
= NULL
;
10772 dwarf_select_sections_by_names (const char *names
)
10776 const char * option
;
10780 debug_dump_long_opts
;
10782 static const debug_dump_long_opts opts_table
[] =
10784 /* Please keep this table alpha- sorted. */
10785 { "Ranges", & do_debug_ranges
, 1 },
10786 { "abbrev", & do_debug_abbrevs
, 1 },
10787 { "addr", & do_debug_addr
, 1 },
10788 { "aranges", & do_debug_aranges
, 1 },
10789 { "cu_index", & do_debug_cu_index
, 1 },
10790 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10791 { "follow-links", & do_follow_links
, 1 },
10792 { "frames", & do_debug_frames
, 1 },
10793 { "frames-interp", & do_debug_frames_interp
, 1 },
10794 /* The special .gdb_index section. */
10795 { "gdb_index", & do_gdb_index
, 1 },
10796 { "info", & do_debug_info
, 1 },
10797 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10798 { "links", & do_debug_links
, 1 },
10799 { "loc", & do_debug_loc
, 1 },
10800 { "macro", & do_debug_macinfo
, 1 },
10801 { "pubnames", & do_debug_pubnames
, 1 },
10802 { "pubtypes", & do_debug_pubtypes
, 1 },
10803 /* This entry is for compatibility
10804 with earlier versions of readelf. */
10805 { "ranges", & do_debug_aranges
, 1 },
10806 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10807 { "str", & do_debug_str
, 1 },
10808 { "str-offsets", & do_debug_str_offsets
, 1 },
10809 /* These trace_* sections are used by Itanium VMS. */
10810 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10811 { "trace_aranges", & do_trace_aranges
, 1 },
10812 { "trace_info", & do_trace_info
, 1 },
10821 const debug_dump_long_opts
* entry
;
10823 for (entry
= opts_table
; entry
->option
; entry
++)
10825 size_t len
= strlen (entry
->option
);
10827 if (strncmp (p
, entry
->option
, len
) == 0
10828 && (p
[len
] == ',' || p
[len
] == '\0'))
10830 * entry
->variable
|= entry
->val
;
10832 /* The --debug-dump=frames-interp option also
10833 enables the --debug-dump=frames option. */
10834 if (do_debug_frames_interp
)
10835 do_debug_frames
= 1;
10842 if (entry
->option
== NULL
)
10844 warn (_("Unrecognized debug option '%s'\n"), p
);
10845 p
= strchr (p
, ',');
10856 dwarf_select_sections_by_letters (const char *letters
)
10858 unsigned int lindex
= 0;
10860 while (letters
[lindex
])
10861 switch (letters
[lindex
++])
10863 case 'A': do_debug_addr
= 1; break;
10864 case 'a': do_debug_abbrevs
= 1; break;
10865 case 'c': do_debug_cu_index
= 1; break;
10866 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10867 case 'f': do_debug_frames
= 1; break;
10868 case 'g': do_gdb_index
= 1; break;
10869 case 'i': do_debug_info
= 1; break;
10870 case 'K': do_follow_links
= 1; break;
10871 case 'k': do_debug_links
= 1; break;
10872 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10873 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10874 case 'm': do_debug_macinfo
= 1; break;
10875 case 'O': do_debug_str_offsets
= 1; break;
10876 case 'o': do_debug_loc
= 1; break;
10877 case 'p': do_debug_pubnames
= 1; break;
10878 case 'R': do_debug_ranges
= 1; break;
10879 case 'r': do_debug_aranges
= 1; break;
10880 case 's': do_debug_str
= 1; break;
10881 case 'T': do_trace_aranges
= 1; break;
10882 case 't': do_debug_pubtypes
= 1; break;
10883 case 'U': do_trace_info
= 1; break;
10884 case 'u': do_trace_abbrevs
= 1; break;
10887 warn (_("Unrecognized debug option '%s'\n"), letters
);
10893 dwarf_select_sections_all (void)
10896 do_debug_abbrevs
= 1;
10897 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10898 do_debug_pubnames
= 1;
10899 do_debug_pubtypes
= 1;
10900 do_debug_aranges
= 1;
10901 do_debug_ranges
= 1;
10902 do_debug_frames
= 1;
10903 do_debug_macinfo
= 1;
10908 do_trace_abbrevs
= 1;
10909 do_trace_aranges
= 1;
10911 do_debug_cu_index
= 1;
10912 do_follow_links
= 1;
10913 do_debug_links
= 1;
10914 do_debug_str_offsets
= 1;
10917 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10918 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10920 /* N.B. The order here must match the order in section_display_enum. */
10922 struct dwarf_section_display debug_displays
[] =
10924 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10925 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10926 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10927 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10928 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10929 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10930 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10931 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10932 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10933 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10934 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10935 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10936 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10937 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10938 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10939 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10940 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10941 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10942 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10943 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10944 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10945 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10946 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10947 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10948 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10949 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10950 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10951 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10952 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10953 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10954 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10955 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10956 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10957 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10958 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10959 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10960 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10961 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10962 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10963 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10964 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10965 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10966 /* Separate debug info files can containt their own .debug_str section,
10967 and this might be in *addition* to a .debug_str section already present
10968 in the main file. Hence we need to have two entries for .debug_str. */
10969 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10972 /* A static assertion. */
10973 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];