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_strp_alt
:
2578 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
));
2580 case DW_FORM_GNU_str_index
:
2581 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2583 case DW_FORM_string
:
2584 add_dwo_name ((const char *) orig_data
);
2587 warn (_("Unsupported form (%s) for attribute %s\n"),
2588 get_FORM_name (form
), get_AT_name (attribute
));
2593 case DW_AT_comp_dir
:
2594 /* FIXME: Also extract a build-id in a CU/TU. */
2599 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2601 case DW_FORM_GNU_strp_alt
:
2602 add_dwo_dir (fetch_alt_indirect_string (uvalue
));
2604 case DW_FORM_line_strp
:
2605 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2607 case DW_FORM_GNU_str_index
:
2608 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2610 case DW_FORM_string
:
2611 add_dwo_dir ((const char *) orig_data
);
2614 warn (_("Unsupported form (%s) for attribute %s\n"),
2615 get_FORM_name (form
), get_AT_name (attribute
));
2620 case DW_AT_GNU_dwo_id
:
2625 /* FIXME: Record the length of the ID as well ? */
2626 add_dwo_id ((const char *) (data
- 8));
2629 warn (_("Unsupported form (%s) for attribute %s\n"),
2630 get_FORM_name (form
), get_AT_name (attribute
));
2640 if (do_loc
|| attribute
== 0)
2643 /* For some attributes we can display further information. */
2647 if (level
>= 0 && level
< MAX_CU_NESTING
2648 && uvalue
< (size_t) (end
- start
))
2650 bfd_boolean is_signed
= FALSE
;
2652 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2653 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2654 level_type_signed
[level
] = is_signed
;
2662 case DW_INL_not_inlined
:
2663 printf (_("(not inlined)"));
2665 case DW_INL_inlined
:
2666 printf (_("(inlined)"));
2668 case DW_INL_declared_not_inlined
:
2669 printf (_("(declared as inline but ignored)"));
2671 case DW_INL_declared_inlined
:
2672 printf (_("(declared as inline and inlined)"));
2675 printf (_(" (Unknown inline attribute value: %s)"),
2676 dwarf_vmatoa ("x", uvalue
));
2681 case DW_AT_language
:
2685 /* Ordered by the numeric value of these constants. */
2686 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2687 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2688 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2689 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2690 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2691 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2692 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2693 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2694 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2695 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2696 /* DWARF 2.1 values. */
2697 case DW_LANG_Java
: printf ("(Java)"); break;
2698 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2699 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2700 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2701 /* DWARF 3 values. */
2702 case DW_LANG_PLI
: printf ("(PLI)"); break;
2703 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2704 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2705 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2706 case DW_LANG_D
: printf ("(D)"); break;
2707 /* DWARF 4 values. */
2708 case DW_LANG_Python
: printf ("(Python)"); break;
2709 /* DWARF 5 values. */
2710 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2711 case DW_LANG_Go
: printf ("(Go)"); break;
2712 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2713 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2714 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2715 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2716 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2717 case DW_LANG_Rust
: printf ("(Rust)"); break;
2718 case DW_LANG_C11
: printf ("(C11)"); break;
2719 case DW_LANG_Swift
: printf ("(Swift)"); break;
2720 case DW_LANG_Julia
: printf ("(Julia)"); break;
2721 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2722 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2723 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2724 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2725 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2726 /* MIPS extension. */
2727 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2728 /* UPC extension. */
2729 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2731 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2732 printf (_("(implementation defined: %s)"),
2733 dwarf_vmatoa ("x", uvalue
));
2735 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2740 case DW_AT_encoding
:
2744 case DW_ATE_void
: printf ("(void)"); break;
2745 case DW_ATE_address
: printf ("(machine address)"); break;
2746 case DW_ATE_boolean
: printf ("(boolean)"); break;
2747 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2748 case DW_ATE_float
: printf ("(float)"); break;
2749 case DW_ATE_signed
: printf ("(signed)"); break;
2750 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2751 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2752 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2753 /* DWARF 2.1 values: */
2754 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2755 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2756 /* DWARF 3 values: */
2757 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2758 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2759 case DW_ATE_edited
: printf ("(edited)"); break;
2760 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2761 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2762 /* DWARF 4 values: */
2763 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2764 /* DWARF 5 values: */
2765 case DW_ATE_UCS
: printf ("(UCS)"); break;
2766 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2768 /* HP extensions: */
2769 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2770 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2771 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2772 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2773 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2774 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2775 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2778 if (uvalue
>= DW_ATE_lo_user
2779 && uvalue
<= DW_ATE_hi_user
)
2780 printf (_("(user defined type)"));
2782 printf (_("(unknown type)"));
2787 case DW_AT_accessibility
:
2791 case DW_ACCESS_public
: printf ("(public)"); break;
2792 case DW_ACCESS_protected
: printf ("(protected)"); break;
2793 case DW_ACCESS_private
: printf ("(private)"); break;
2795 printf (_("(unknown accessibility)"));
2800 case DW_AT_visibility
:
2804 case DW_VIS_local
: printf ("(local)"); break;
2805 case DW_VIS_exported
: printf ("(exported)"); break;
2806 case DW_VIS_qualified
: printf ("(qualified)"); break;
2807 default: printf (_("(unknown visibility)")); break;
2811 case DW_AT_endianity
:
2815 case DW_END_default
: printf ("(default)"); break;
2816 case DW_END_big
: printf ("(big)"); break;
2817 case DW_END_little
: printf ("(little)"); break;
2819 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2820 printf (_("(user specified)"));
2822 printf (_("(unknown endianity)"));
2827 case DW_AT_virtuality
:
2831 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2832 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2833 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2834 default: printf (_("(unknown virtuality)")); break;
2838 case DW_AT_identifier_case
:
2842 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2843 case DW_ID_up_case
: printf ("(up_case)"); break;
2844 case DW_ID_down_case
: printf ("(down_case)"); break;
2845 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2846 default: printf (_("(unknown case)")); break;
2850 case DW_AT_calling_convention
:
2854 case DW_CC_normal
: printf ("(normal)"); break;
2855 case DW_CC_program
: printf ("(program)"); break;
2856 case DW_CC_nocall
: printf ("(nocall)"); break;
2857 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2858 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2859 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2860 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2862 if (uvalue
>= DW_CC_lo_user
2863 && uvalue
<= DW_CC_hi_user
)
2864 printf (_("(user defined)"));
2866 printf (_("(unknown convention)"));
2870 case DW_AT_ordering
:
2875 case -1: printf (_("(undefined)")); break;
2876 case 0: printf ("(row major)"); break;
2877 case 1: printf ("(column major)"); break;
2881 case DW_AT_decimal_sign
:
2885 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2886 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2887 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2888 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2889 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2890 default: printf (_("(unrecognised)")); break;
2894 case DW_AT_defaulted
:
2898 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2899 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2900 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2901 default: printf (_("(unrecognised)")); break;
2905 case DW_AT_discr_list
:
2907 display_discr_list (form
, uvalue
, data
, end
, level
);
2910 case DW_AT_frame_base
:
2911 have_frame_base
= 1;
2913 case DW_AT_location
:
2914 case DW_AT_string_length
:
2915 case DW_AT_return_addr
:
2916 case DW_AT_data_member_location
:
2917 case DW_AT_vtable_elem_location
:
2919 case DW_AT_static_link
:
2920 case DW_AT_use_location
:
2921 case DW_AT_call_value
:
2922 case DW_AT_GNU_call_site_value
:
2923 case DW_AT_call_data_value
:
2924 case DW_AT_GNU_call_site_data_value
:
2925 case DW_AT_call_target
:
2926 case DW_AT_GNU_call_site_target
:
2927 case DW_AT_call_target_clobbered
:
2928 case DW_AT_GNU_call_site_target_clobbered
:
2929 if ((dwarf_version
< 4
2930 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2931 || form
== DW_FORM_sec_offset
)
2932 printf (_(" (location list)"));
2934 case DW_AT_allocated
:
2935 case DW_AT_associated
:
2936 case DW_AT_data_location
:
2938 case DW_AT_upper_bound
:
2939 case DW_AT_lower_bound
:
2942 int need_frame_base
;
2945 need_frame_base
= decode_location_expression (block_start
,
2950 cu_offset
, section
);
2952 if (need_frame_base
&& !have_frame_base
)
2953 printf (_(" [without DW_AT_frame_base]"));
2957 case DW_AT_data_bit_offset
:
2958 case DW_AT_byte_size
:
2959 case DW_AT_bit_size
:
2960 case DW_AT_string_length_byte_size
:
2961 case DW_AT_string_length_bit_size
:
2962 case DW_AT_bit_stride
:
2963 if (form
== DW_FORM_exprloc
)
2966 (void) decode_location_expression (block_start
, pointer_size
,
2967 offset_size
, dwarf_version
,
2968 uvalue
, cu_offset
, section
);
2975 if (form
== DW_FORM_ref_sig8
2976 || form
== DW_FORM_GNU_ref_alt
)
2979 if (form
== DW_FORM_ref1
2980 || form
== DW_FORM_ref2
2981 || form
== DW_FORM_ref4
2982 || form
== DW_FORM_ref_udata
)
2983 uvalue
+= cu_offset
;
2985 if (uvalue
>= section
->size
)
2986 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2987 dwarf_vmatoa ("x", uvalue
),
2988 (unsigned long) (orig_data
- section
->start
));
2991 unsigned long abbrev_number
;
2992 abbrev_entry
*entry
;
2993 unsigned char *p
= section
->start
+ uvalue
;
2995 READ_ULEB (abbrev_number
, p
, end
);
2997 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2998 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2999 use different abbrev table, and we don't track .debug_info chunks
3001 if (form
!= DW_FORM_ref_addr
)
3003 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3004 if (entry
->entry
== abbrev_number
)
3007 printf (" (%s)", get_TAG_name (entry
->tag
));
3021 static unsigned char *
3022 read_and_display_attr (unsigned long attribute
,
3024 dwarf_signed_vma implicit_const
,
3025 unsigned char * start
,
3026 unsigned char * data
,
3027 unsigned char * end
,
3028 dwarf_vma cu_offset
,
3029 dwarf_vma pointer_size
,
3030 dwarf_vma offset_size
,
3032 debug_info
* debug_info_p
,
3034 struct dwarf_section
* section
,
3035 struct cu_tu_set
* this_set
,
3039 printf (" %-18s:", get_AT_name (attribute
));
3040 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3042 cu_offset
, pointer_size
, offset_size
,
3043 dwarf_version
, debug_info_p
,
3044 do_loc
, section
, this_set
, ' ', level
);
3050 /* Like load_debug_section, but if the ordinary call fails, and we are
3051 following debug links, then attempt to load the requested section
3052 from one of the separate debug info files. */
3055 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3058 if (load_debug_section (sec_enum
, handle
))
3060 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3062 /* See if we can associate a filename with this section. */
3065 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3066 if (i
->handle
== handle
)
3068 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3076 if (do_follow_links
)
3080 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3082 if (load_debug_section (sec_enum
, i
->handle
))
3084 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3086 /* FIXME: We should check to see if any of the remaining debug info
3087 files also contain this section, and, umm, do something about it. */
3097 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3101 if (do_follow_links
&& section
->filename
)
3102 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3103 section
->name
, section
->filename
);
3105 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3109 if (do_follow_links
&& section
->filename
)
3110 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3111 section
->name
, section
->filename
);
3113 printf (_("Contents of the %s section:\n\n"), section
->name
);
3117 /* Process the contents of a .debug_info section.
3118 If do_loc is TRUE then we are scanning for location lists and dwo tags
3119 and we do not want to display anything to the user.
3120 If do_types is TRUE, we are processing a .debug_types section instead of
3121 a .debug_info section.
3122 The information displayed is restricted by the values in DWARF_START_DIE
3123 and DWARF_CUTOFF_LEVEL.
3124 Returns TRUE upon success. Otherwise an error or warning message is
3125 printed and FALSE is returned. */
3128 process_debug_info (struct dwarf_section
* section
,
3130 enum dwarf_section_display_enum abbrev_sec
,
3132 bfd_boolean do_types
)
3134 unsigned char *start
= section
->start
;
3135 unsigned char *end
= start
+ section
->size
;
3136 unsigned char *section_begin
;
3138 unsigned int num_units
= 0;
3140 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3141 && num_debug_info_entries
== 0
3146 /* First scan the section to get the number of comp units. */
3147 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3150 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3151 will be the length. For a 64-bit DWARF section, it'll be
3152 the escape code 0xffffffff followed by an 8 byte length. */
3153 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3155 if (length
== 0xffffffff)
3157 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3158 section_begin
+= length
+ 12;
3160 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3162 warn (_("Reserved length value (0x%s) found in section %s\n"),
3163 dwarf_vmatoa ("x", length
), section
->name
);
3167 section_begin
+= length
+ 4;
3169 /* Negative values are illegal, they may even cause infinite
3170 looping. This can happen if we can't accurately apply
3171 relocations to an object file, or if the file is corrupt. */
3172 if ((signed long) length
<= 0 || section_begin
< start
)
3174 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3175 dwarf_vmatoa ("x", length
), section
->name
);
3182 error (_("No comp units in %s section ?\n"), section
->name
);
3186 /* Then allocate an array to hold the information. */
3187 debug_information
= (debug_info
*) cmalloc (num_units
,
3188 sizeof (* debug_information
));
3189 if (debug_information
== NULL
)
3191 error (_("Not enough memory for a debug info array of %u entries\n"),
3193 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3197 /* PR 17531: file: 92ca3797.
3198 We cannot rely upon the debug_information array being initialised
3199 before it is used. A corrupt file could easily contain references
3200 to a unit for which information has not been made available. So
3201 we ensure that the array is zeroed here. */
3202 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3204 alloc_num_debug_info_entries
= num_units
;
3209 load_debug_section_with_follow (str
, file
);
3210 load_debug_section_with_follow (line_str
, file
);
3211 load_debug_section_with_follow (str_dwo
, file
);
3212 load_debug_section_with_follow (str_index
, file
);
3213 load_debug_section_with_follow (str_index_dwo
, file
);
3214 load_debug_section_with_follow (debug_addr
, file
);
3217 load_debug_section_with_follow (abbrev_sec
, file
);
3218 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3220 warn (_("Unable to locate %s section!\n"),
3221 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3225 if (!do_loc
&& dwarf_start_die
== 0)
3226 introduce (section
, FALSE
);
3228 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3230 DWARF2_Internal_CompUnit compunit
;
3231 unsigned char *hdrptr
;
3232 unsigned char *tags
;
3233 int level
, last_level
, saved_level
;
3234 dwarf_vma cu_offset
;
3235 unsigned long sec_off
;
3236 unsigned int offset_size
;
3237 unsigned int initial_length_size
;
3238 dwarf_vma signature_high
= 0;
3239 dwarf_vma signature_low
= 0;
3240 dwarf_vma type_offset
= 0;
3241 struct cu_tu_set
*this_set
;
3242 dwarf_vma abbrev_base
;
3247 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3249 if (compunit
.cu_length
== 0xffffffff)
3251 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3253 initial_length_size
= 12;
3258 initial_length_size
= 4;
3261 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3263 cu_offset
= start
- section_begin
;
3265 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3267 if (compunit
.cu_version
< 5)
3269 compunit
.cu_unit_type
= DW_UT_compile
;
3270 /* Initialize it due to a false compiler warning. */
3271 compunit
.cu_pointer_size
= -1;
3275 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3276 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3278 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3281 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3283 if (this_set
== NULL
)
3286 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3290 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3291 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3294 if (compunit
.cu_version
< 5)
3295 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3297 /* PR 17512: file: 001-108546-0.001:0.1. */
3298 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3300 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3301 compunit
.cu_pointer_size
, offset_size
);
3302 compunit
.cu_pointer_size
= offset_size
;
3307 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3309 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3312 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3313 + initial_length_size
))
3315 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3316 + initial_length_size
;
3320 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3321 && num_debug_info_entries
== 0
3322 && alloc_num_debug_info_entries
> unit
3325 debug_information
[unit
].cu_offset
= cu_offset
;
3326 debug_information
[unit
].pointer_size
3327 = compunit
.cu_pointer_size
;
3328 debug_information
[unit
].offset_size
= offset_size
;
3329 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3330 debug_information
[unit
].base_address
= 0;
3331 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3332 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3333 debug_information
[unit
].loc_offsets
= NULL
;
3334 debug_information
[unit
].have_frame_base
= NULL
;
3335 debug_information
[unit
].max_loc_offsets
= 0;
3336 debug_information
[unit
].num_loc_offsets
= 0;
3337 debug_information
[unit
].range_lists
= NULL
;
3338 debug_information
[unit
].max_range_lists
= 0;
3339 debug_information
[unit
].num_range_lists
= 0;
3342 if (!do_loc
&& dwarf_start_die
== 0)
3344 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3345 dwarf_vmatoa ("x", cu_offset
));
3346 printf (_(" Length: 0x%s (%s)\n"),
3347 dwarf_vmatoa ("x", compunit
.cu_length
),
3348 offset_size
== 8 ? "64-bit" : "32-bit");
3349 printf (_(" Version: %d\n"), compunit
.cu_version
);
3350 printf (_(" Abbrev Offset: 0x%s\n"),
3351 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3352 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3357 printf (_(" Signature: 0x%s\n"),
3358 dwarf_vmatoa64 (signature_high
, signature_low
,
3359 buf
, sizeof (buf
)));
3360 printf (_(" Type Offset: 0x%s\n"),
3361 dwarf_vmatoa ("x", type_offset
));
3363 if (this_set
!= NULL
)
3365 dwarf_vma
*offsets
= this_set
->section_offsets
;
3366 size_t *sizes
= this_set
->section_sizes
;
3368 printf (_(" Section contributions:\n"));
3369 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3370 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3371 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3372 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3373 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3374 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3375 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3376 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3377 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3378 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3379 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3380 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3384 sec_off
= cu_offset
+ initial_length_size
;
3385 if (sec_off
+ compunit
.cu_length
< sec_off
3386 || sec_off
+ compunit
.cu_length
> section
->size
)
3388 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3390 (unsigned long) cu_offset
,
3391 dwarf_vmatoa ("x", compunit
.cu_length
));
3397 start
+= compunit
.cu_length
+ initial_length_size
;
3399 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3401 warn (_("CU at offset %s contains corrupt or "
3402 "unsupported version number: %d.\n"),
3403 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3407 if (compunit
.cu_unit_type
!= DW_UT_compile
3408 && compunit
.cu_unit_type
!= DW_UT_type
)
3410 warn (_("CU at offset %s contains corrupt or "
3411 "unsupported unit type: %d.\n"),
3412 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3418 /* Process the abbrevs used by this compilation unit. */
3419 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3420 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3421 (unsigned long) compunit
.cu_abbrev_offset
,
3422 (unsigned long) abbrev_size
);
3423 /* PR 17531: file:4bcd9ce9. */
3424 else if ((abbrev_base
+ abbrev_size
)
3425 > debug_displays
[abbrev_sec
].section
.size
)
3426 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3427 (unsigned long) abbrev_base
+ abbrev_size
,
3428 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3430 process_abbrev_section
3431 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3432 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3433 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3434 + abbrev_base
+ abbrev_size
));
3439 while (tags
< start
)
3441 unsigned long abbrev_number
;
3442 unsigned long die_offset
;
3443 abbrev_entry
*entry
;
3445 int do_printing
= 1;
3447 die_offset
= tags
- section_begin
;
3449 READ_ULEB (abbrev_number
, tags
, start
);
3451 /* A null DIE marks the end of a list of siblings or it may also be
3452 a section padding. */
3453 if (abbrev_number
== 0)
3455 /* Check if it can be a section padding for the last CU. */
3456 if (level
== 0 && start
== end
)
3460 for (chk
= tags
; chk
< start
; chk
++)
3467 if (!do_loc
&& die_offset
>= dwarf_start_die
3468 && (dwarf_cutoff_level
== -1
3469 || level
< dwarf_cutoff_level
))
3470 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3476 static unsigned num_bogus_warns
= 0;
3478 if (num_bogus_warns
< 3)
3480 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3481 die_offset
, section
->name
);
3483 if (num_bogus_warns
== 3)
3484 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3487 if (dwarf_start_die
!= 0 && level
< saved_level
)
3494 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3498 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3499 saved_level
= level
;
3500 do_printing
= (dwarf_cutoff_level
== -1
3501 || level
< dwarf_cutoff_level
);
3503 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3504 level
, die_offset
, abbrev_number
);
3505 else if (dwarf_cutoff_level
== -1
3506 || last_level
< dwarf_cutoff_level
)
3507 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3512 /* Scan through the abbreviation list until we reach the
3514 for (entry
= first_abbrev
;
3515 entry
&& entry
->entry
!= abbrev_number
;
3516 entry
= entry
->next
)
3521 if (!do_loc
&& do_printing
)
3526 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3527 die_offset
, abbrev_number
);
3531 if (!do_loc
&& do_printing
)
3532 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3537 need_base_address
= 0;
3539 case DW_TAG_compile_unit
:
3540 need_base_address
= 1;
3541 need_dwo_info
= do_loc
;
3543 case DW_TAG_entry_point
:
3544 case DW_TAG_subprogram
:
3545 need_base_address
= 0;
3546 /* Assuming that there is no DW_AT_frame_base. */
3547 have_frame_base
= 0;
3551 debug_info
*debug_info_p
=
3552 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3553 ? debug_information
+ unit
: NULL
;
3555 assert (!debug_info_p
3556 || (debug_info_p
->num_loc_offsets
3557 == debug_info_p
->num_loc_views
));
3559 for (attr
= entry
->first_attr
;
3560 attr
&& attr
->attribute
;
3563 if (! do_loc
&& do_printing
)
3564 /* Show the offset from where the tag was extracted. */
3565 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3566 tags
= read_and_display_attr (attr
->attribute
,
3568 attr
->implicit_const
,
3573 compunit
.cu_pointer_size
,
3575 compunit
.cu_version
,
3577 do_loc
|| ! do_printing
,
3583 /* If a locview attribute appears before a location one,
3584 make sure we don't associate it with an earlier
3587 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3590 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3591 debug_info_p
->num_loc_views
++;
3592 assert (debug_info_p
->num_loc_views
3593 == debug_info_p
->num_loc_offsets
);
3600 warn(_("DIE has locviews without loclist\n"));
3601 debug_info_p
->num_loc_views
--;
3608 if (entry
->children
)
3613 /* Set num_debug_info_entries here so that it can be used to check if
3614 we need to process .debug_loc and .debug_ranges sections. */
3615 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3616 && num_debug_info_entries
== 0
3619 if (num_units
> alloc_num_debug_info_entries
)
3620 num_debug_info_entries
= alloc_num_debug_info_entries
;
3622 num_debug_info_entries
= num_units
;
3631 /* Locate and scan the .debug_info section in the file and record the pointer
3632 sizes and offsets for the compilation units in it. Usually an executable
3633 will have just one pointer size, but this is not guaranteed, and so we try
3634 not to make any assumptions. Returns zero upon failure, or the number of
3635 compilation units upon success. */
3638 load_debug_info (void * file
)
3640 /* If we have already tried and failed to load the .debug_info
3641 section then do not bother to repeat the task. */
3642 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3645 /* If we already have the information there is nothing else to do. */
3646 if (num_debug_info_entries
> 0)
3647 return num_debug_info_entries
;
3649 /* If this is a DWARF package file, load the CU and TU indexes. */
3650 (void) load_cu_tu_indexes (file
);
3652 if (load_debug_section_with_follow (info
, file
)
3653 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3654 return num_debug_info_entries
;
3656 if (load_debug_section_with_follow (info_dwo
, file
)
3657 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3658 abbrev_dwo
, TRUE
, FALSE
))
3659 return num_debug_info_entries
;
3661 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3665 /* Read a DWARF .debug_line section header starting at DATA.
3666 Upon success returns an updated DATA pointer and the LINFO
3667 structure and the END_OF_SEQUENCE pointer will be filled in.
3668 Otherwise returns NULL. */
3670 static unsigned char *
3671 read_debug_line_header (struct dwarf_section
* section
,
3672 unsigned char * data
,
3673 unsigned char * end
,
3674 DWARF2_Internal_LineInfo
* linfo
,
3675 unsigned char ** end_of_sequence
)
3677 unsigned char *hdrptr
;
3678 unsigned int initial_length_size
;
3680 /* Extract information from the Line Number Program Header.
3681 (section 6.2.4 in the Dwarf3 doc). */
3684 /* Get and check the length of the block. */
3685 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3687 if (linfo
->li_length
== 0xffffffff)
3689 /* This section is 64-bit DWARF 3. */
3690 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3691 linfo
->li_offset_size
= 8;
3692 initial_length_size
= 12;
3696 linfo
->li_offset_size
= 4;
3697 initial_length_size
= 4;
3700 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3702 /* If the length field has a relocation against it, then we should
3703 not complain if it is inaccurate (and probably negative). This
3704 happens in object files when the .debug_line section is actually
3705 comprised of several different .debug_line.* sections, (some of
3706 which may be removed by linker garbage collection), and a relocation
3707 is used to compute the correct length once that is done. */
3708 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3710 linfo
->li_length
= (end
- data
) - initial_length_size
;
3714 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3715 (long) linfo
->li_length
);
3720 /* Get and check the version number. */
3721 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3723 if (linfo
->li_version
!= 2
3724 && linfo
->li_version
!= 3
3725 && linfo
->li_version
!= 4
3726 && linfo
->li_version
!= 5)
3728 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3729 "is currently supported.\n"));
3733 if (linfo
->li_version
>= 5)
3735 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
3737 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
3738 if (linfo
->li_segment_size
!= 0)
3740 warn (_("The %s section contains "
3741 "unsupported segment selector size: %d.\n"),
3742 section
->name
, linfo
->li_segment_size
);
3747 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3748 linfo
->li_offset_size
, end
);
3749 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3751 if (linfo
->li_version
>= 4)
3753 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3755 if (linfo
->li_max_ops_per_insn
== 0)
3757 warn (_("Invalid maximum operations per insn.\n"));
3762 linfo
->li_max_ops_per_insn
= 1;
3764 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3765 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3766 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3767 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3769 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3770 /* PR 17512: file:002-117414-0.004. */
3771 if (* end_of_sequence
> end
)
3773 warn (_("Line length %s extends beyond end of section\n"),
3774 dwarf_vmatoa ("u", linfo
->li_length
));
3775 * end_of_sequence
= end
;
3782 static unsigned char *
3783 display_formatted_table (unsigned char * data
,
3784 unsigned char * start
,
3785 unsigned char * end
,
3786 const DWARF2_Internal_LineInfo
* linfo
,
3787 struct dwarf_section
* section
,
3790 unsigned char *format_start
, format_count
, *format
, formati
;
3791 dwarf_vma data_count
, datai
;
3792 unsigned int namepass
, last_entry
= 0;
3793 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
3795 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3796 if (do_checks
&& format_count
> 5)
3797 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
3798 table_name
, format_count
);
3800 format_start
= data
;
3801 for (formati
= 0; formati
< format_count
; formati
++)
3803 SKIP_ULEB (data
, end
);
3804 SKIP_ULEB (data
, end
);
3807 warn (_("%s: Corrupt format description entry\n"), table_name
);
3812 READ_ULEB (data_count
, data
, end
);
3813 if (data_count
== 0)
3815 printf (_("\n The %s is empty.\n"), table_name
);
3818 else if (data
== end
)
3820 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
3821 table_name
, dwarf_vmatoa ("x", data_count
));
3825 else if (format_count
== 0)
3827 warn (_("%s: format count is zero, but the table is not empty\n"),
3832 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
3833 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
3836 printf (_(" Entry"));
3837 /* Delay displaying name as the last entry for better screen layout. */
3838 for (namepass
= 0; namepass
< 2; namepass
++)
3840 format
= format_start
;
3841 for (formati
= 0; formati
< format_count
; formati
++)
3843 dwarf_vma content_type
;
3845 READ_ULEB (content_type
, format
, end
);
3846 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3847 switch (content_type
)
3850 printf (_("\tName"));
3852 case DW_LNCT_directory_index
:
3853 printf (_("\tDir"));
3855 case DW_LNCT_timestamp
:
3856 printf (_("\tTime"));
3859 printf (_("\tSize"));
3862 printf (_("\tMD5\t\t\t"));
3865 printf (_("\t(Unknown format content type %s)"),
3866 dwarf_vmatoa ("u", content_type
));
3868 SKIP_ULEB (format
, end
);
3873 for (datai
= 0; datai
< data_count
; datai
++)
3875 unsigned char *datapass
= data
;
3877 printf (" %d", last_entry
++);
3878 /* Delay displaying name as the last entry for better screen layout. */
3879 for (namepass
= 0; namepass
< 2; namepass
++)
3881 format
= format_start
;
3883 for (formati
= 0; formati
< format_count
; formati
++)
3885 dwarf_vma content_type
, form
;
3887 READ_ULEB (content_type
, format
, end
);
3888 READ_ULEB (form
, format
, end
);
3889 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
3890 0, 0, linfo
->li_offset_size
,
3891 linfo
->li_version
, NULL
,
3892 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3893 section
, NULL
, '\t', -1);
3897 if (data
== end
&& (datai
< data_count
- 1))
3899 warn (_("\n%s: Corrupt entries list\n"), table_name
);
3908 display_debug_lines_raw (struct dwarf_section
* section
,
3909 unsigned char * data
,
3910 unsigned char * end
,
3913 unsigned char *start
= section
->start
;
3914 int verbose_view
= 0;
3916 introduce (section
, TRUE
);
3920 static DWARF2_Internal_LineInfo saved_linfo
;
3921 DWARF2_Internal_LineInfo linfo
;
3922 unsigned char *standard_opcodes
;
3923 unsigned char *end_of_sequence
;
3926 if (const_strneq (section
->name
, ".debug_line.")
3927 /* Note: the following does not apply to .debug_line.dwo sections.
3928 These are full debug_line sections. */
3929 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3931 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3932 section containing just the Line Number Statements. They are
3933 created by the assembler and intended to be used alongside gcc's
3934 -ffunction-sections command line option. When the linker's
3935 garbage collection decides to discard a .text.<foo> section it
3936 can then also discard the line number information in .debug_line.<foo>.
3938 Since the section is a fragment it does not have the details
3939 needed to fill out a LineInfo structure, so instead we use the
3940 details from the last full debug_line section that we processed. */
3941 end_of_sequence
= end
;
3942 standard_opcodes
= NULL
;
3943 linfo
= saved_linfo
;
3944 /* PR 17531: file: 0522b371. */
3945 if (linfo
.li_line_range
== 0)
3947 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3950 reset_state_machine (linfo
.li_default_is_stmt
);
3954 unsigned char * hdrptr
;
3956 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3957 & end_of_sequence
)) == NULL
)
3960 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3961 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3962 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3963 if (linfo
.li_version
>= 5)
3965 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
3966 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
3968 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3969 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3970 if (linfo
.li_version
>= 4)
3971 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3972 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3973 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3974 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3975 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3977 /* PR 17512: file: 1665-6428-0.004. */
3978 if (linfo
.li_line_range
== 0)
3980 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3981 linfo
.li_line_range
= 1;
3984 reset_state_machine (linfo
.li_default_is_stmt
);
3986 /* Display the contents of the Opcodes table. */
3987 standard_opcodes
= hdrptr
;
3989 /* PR 17512: file: 002-417945-0.004. */
3990 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3992 warn (_("Line Base extends beyond end of section\n"));
3996 printf (_("\n Opcodes:\n"));
3998 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3999 printf (ngettext (" Opcode %d has %d arg\n",
4000 " Opcode %d has %d args\n",
4001 standard_opcodes
[i
- 1]),
4002 i
, standard_opcodes
[i
- 1]);
4004 /* Display the contents of the Directory table. */
4005 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4007 if (linfo
.li_version
>= 5)
4009 load_debug_section_with_follow (line_str
, file
);
4011 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4013 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4019 printf (_("\n The Directory Table is empty.\n"));
4022 unsigned int last_dir_entry
= 0;
4024 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4025 (long)(data
- start
));
4027 while (data
< end
&& *data
!= 0)
4029 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4031 data
+= strnlen ((char *) data
, end
- data
) + 1;
4034 /* PR 17512: file: 002-132094-0.004. */
4035 if (data
>= end
- 1)
4039 /* Skip the NUL at the end of the table. */
4042 /* Display the contents of the File Name table. */
4044 printf (_("\n The File Name Table is empty.\n"));
4047 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4048 (long)(data
- start
));
4049 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4051 while (data
< end
&& *data
!= 0)
4053 unsigned char *name
;
4056 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4058 data
+= strnlen ((char *) data
, end
- data
) + 1;
4060 READ_ULEB (val
, data
, end
);
4061 printf ("%s\t", dwarf_vmatoa ("u", val
));
4062 READ_ULEB (val
, data
, end
);
4063 printf ("%s\t", dwarf_vmatoa ("u", val
));
4064 READ_ULEB (val
, data
, end
);
4065 printf ("%s\t", dwarf_vmatoa ("u", val
));
4066 printf ("%.*s\n", (int)(end
- name
), name
);
4070 warn (_("Corrupt file name table entry\n"));
4076 /* Skip the NUL at the end of the table. */
4081 saved_linfo
= linfo
;
4084 /* Now display the statements. */
4085 if (data
>= end_of_sequence
)
4086 printf (_(" No Line Number Statements.\n"));
4089 printf (_(" Line Number Statements:\n"));
4091 while (data
< end_of_sequence
)
4093 unsigned char op_code
;
4094 dwarf_signed_vma adv
;
4097 printf (" [0x%08lx]", (long)(data
- start
));
4101 if (op_code
>= linfo
.li_opcode_base
)
4103 op_code
-= linfo
.li_opcode_base
;
4104 uladv
= (op_code
/ linfo
.li_line_range
);
4105 if (linfo
.li_max_ops_per_insn
== 1)
4107 uladv
*= linfo
.li_min_insn_length
;
4108 state_machine_regs
.address
+= uladv
;
4110 state_machine_regs
.view
= 0;
4111 printf (_(" Special opcode %d: "
4112 "advance Address by %s to 0x%s%s"),
4113 op_code
, dwarf_vmatoa ("u", uladv
),
4114 dwarf_vmatoa ("x", state_machine_regs
.address
),
4115 verbose_view
&& uladv
4116 ? _(" (reset view)") : "");
4121 = ((state_machine_regs
.op_index
+ uladv
)
4122 / linfo
.li_max_ops_per_insn
)
4123 * linfo
.li_min_insn_length
;
4125 state_machine_regs
.address
+= addrdelta
;
4126 state_machine_regs
.op_index
4127 = (state_machine_regs
.op_index
+ uladv
)
4128 % linfo
.li_max_ops_per_insn
;
4130 state_machine_regs
.view
= 0;
4131 printf (_(" Special opcode %d: "
4132 "advance Address by %s to 0x%s[%d]%s"),
4133 op_code
, dwarf_vmatoa ("u", uladv
),
4134 dwarf_vmatoa ("x", state_machine_regs
.address
),
4135 state_machine_regs
.op_index
,
4136 verbose_view
&& addrdelta
4137 ? _(" (reset view)") : "");
4139 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4140 state_machine_regs
.line
+= adv
;
4141 printf (_(" and Line by %s to %d"),
4142 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4143 if (verbose_view
|| state_machine_regs
.view
)
4144 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4147 state_machine_regs
.view
++;
4152 case DW_LNS_extended_op
:
4153 data
+= process_extended_line_op (data
,
4154 linfo
.li_default_is_stmt
,
4159 printf (_(" Copy"));
4160 if (verbose_view
|| state_machine_regs
.view
)
4161 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4164 state_machine_regs
.view
++;
4167 case DW_LNS_advance_pc
:
4168 READ_ULEB (uladv
, data
, end
);
4169 if (linfo
.li_max_ops_per_insn
== 1)
4171 uladv
*= linfo
.li_min_insn_length
;
4172 state_machine_regs
.address
+= uladv
;
4174 state_machine_regs
.view
= 0;
4175 printf (_(" Advance PC by %s to 0x%s%s\n"),
4176 dwarf_vmatoa ("u", uladv
),
4177 dwarf_vmatoa ("x", state_machine_regs
.address
),
4178 verbose_view
&& uladv
4179 ? _(" (reset view)") : "");
4184 = ((state_machine_regs
.op_index
+ uladv
)
4185 / linfo
.li_max_ops_per_insn
)
4186 * linfo
.li_min_insn_length
;
4187 state_machine_regs
.address
4189 state_machine_regs
.op_index
4190 = (state_machine_regs
.op_index
+ uladv
)
4191 % linfo
.li_max_ops_per_insn
;
4193 state_machine_regs
.view
= 0;
4194 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4195 dwarf_vmatoa ("u", uladv
),
4196 dwarf_vmatoa ("x", state_machine_regs
.address
),
4197 state_machine_regs
.op_index
,
4198 verbose_view
&& addrdelta
4199 ? _(" (reset view)") : "");
4203 case DW_LNS_advance_line
:
4204 READ_SLEB (adv
, data
, end
);
4205 state_machine_regs
.line
+= adv
;
4206 printf (_(" Advance Line by %s to %d\n"),
4207 dwarf_vmatoa ("d", adv
),
4208 state_machine_regs
.line
);
4211 case DW_LNS_set_file
:
4212 READ_ULEB (uladv
, data
, end
);
4213 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4214 dwarf_vmatoa ("u", uladv
));
4215 state_machine_regs
.file
= uladv
;
4218 case DW_LNS_set_column
:
4219 READ_ULEB (uladv
, data
, end
);
4220 printf (_(" Set column to %s\n"),
4221 dwarf_vmatoa ("u", uladv
));
4222 state_machine_regs
.column
= uladv
;
4225 case DW_LNS_negate_stmt
:
4226 adv
= state_machine_regs
.is_stmt
;
4228 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4229 state_machine_regs
.is_stmt
= adv
;
4232 case DW_LNS_set_basic_block
:
4233 printf (_(" Set basic block\n"));
4234 state_machine_regs
.basic_block
= 1;
4237 case DW_LNS_const_add_pc
:
4238 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4239 if (linfo
.li_max_ops_per_insn
)
4241 uladv
*= linfo
.li_min_insn_length
;
4242 state_machine_regs
.address
+= uladv
;
4244 state_machine_regs
.view
= 0;
4245 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4246 dwarf_vmatoa ("u", uladv
),
4247 dwarf_vmatoa ("x", state_machine_regs
.address
),
4248 verbose_view
&& uladv
4249 ? _(" (reset view)") : "");
4254 = ((state_machine_regs
.op_index
+ uladv
)
4255 / linfo
.li_max_ops_per_insn
)
4256 * linfo
.li_min_insn_length
;
4257 state_machine_regs
.address
4259 state_machine_regs
.op_index
4260 = (state_machine_regs
.op_index
+ uladv
)
4261 % linfo
.li_max_ops_per_insn
;
4263 state_machine_regs
.view
= 0;
4264 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4265 dwarf_vmatoa ("u", uladv
),
4266 dwarf_vmatoa ("x", state_machine_regs
.address
),
4267 state_machine_regs
.op_index
,
4268 verbose_view
&& addrdelta
4269 ? _(" (reset view)") : "");
4273 case DW_LNS_fixed_advance_pc
:
4274 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4275 state_machine_regs
.address
+= uladv
;
4276 state_machine_regs
.op_index
= 0;
4277 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4278 dwarf_vmatoa ("u", uladv
),
4279 dwarf_vmatoa ("x", state_machine_regs
.address
));
4280 /* Do NOT reset view. */
4283 case DW_LNS_set_prologue_end
:
4284 printf (_(" Set prologue_end to true\n"));
4287 case DW_LNS_set_epilogue_begin
:
4288 printf (_(" Set epilogue_begin to true\n"));
4291 case DW_LNS_set_isa
:
4292 READ_ULEB (uladv
, data
, end
);
4293 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4297 printf (_(" Unknown opcode %d with operands: "), op_code
);
4299 if (standard_opcodes
!= NULL
)
4300 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4302 READ_ULEB (uladv
, data
, end
);
4303 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4304 i
== 1 ? "" : ", ");
4319 unsigned char *name
;
4320 unsigned int directory_index
;
4321 unsigned int modification_date
;
4322 unsigned int length
;
4325 /* Output a decoded representation of the .debug_line section. */
4328 display_debug_lines_decoded (struct dwarf_section
* section
,
4329 unsigned char * start
,
4330 unsigned char * data
,
4331 unsigned char * end
,
4334 static DWARF2_Internal_LineInfo saved_linfo
;
4336 introduce (section
, FALSE
);
4340 /* This loop amounts to one iteration per compilation unit. */
4341 DWARF2_Internal_LineInfo linfo
;
4342 unsigned char *standard_opcodes
;
4343 unsigned char *end_of_sequence
;
4345 File_Entry
*file_table
= NULL
;
4346 unsigned int n_files
= 0;
4347 unsigned char **directory_table
= NULL
;
4348 dwarf_vma n_directories
= 0;
4350 if (const_strneq (section
->name
, ".debug_line.")
4351 /* Note: the following does not apply to .debug_line.dwo sections.
4352 These are full debug_line sections. */
4353 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4355 /* See comment in display_debug_lines_raw(). */
4356 end_of_sequence
= end
;
4357 standard_opcodes
= NULL
;
4358 linfo
= saved_linfo
;
4359 /* PR 17531: file: 0522b371. */
4360 if (linfo
.li_line_range
== 0)
4362 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4365 reset_state_machine (linfo
.li_default_is_stmt
);
4369 unsigned char *hdrptr
;
4371 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4372 & end_of_sequence
)) == NULL
)
4375 /* PR 17531: file: 0522b371. */
4376 if (linfo
.li_line_range
== 0)
4378 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4379 linfo
.li_line_range
= 1;
4381 reset_state_machine (linfo
.li_default_is_stmt
);
4383 /* Save a pointer to the contents of the Opcodes table. */
4384 standard_opcodes
= hdrptr
;
4386 /* Traverse the Directory table just to count entries. */
4387 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4391 warn (_("opcode base of %d extends beyond end of section\n"),
4392 linfo
.li_opcode_base
);
4396 if (linfo
.li_version
>= 5)
4398 unsigned char *format_start
, format_count
, *format
;
4399 dwarf_vma formati
, entryi
;
4401 load_debug_section_with_follow (line_str
, fileptr
);
4403 /* Skip directories format. */
4404 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4405 if (do_checks
&& format_count
> 1)
4406 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4408 format_start
= data
;
4409 for (formati
= 0; formati
< format_count
; formati
++)
4411 SKIP_ULEB (data
, end
);
4412 SKIP_ULEB (data
, end
);
4415 READ_ULEB (n_directories
, data
, end
);
4418 warn (_("Corrupt directories list\n"));
4422 if (n_directories
== 0)
4423 directory_table
= NULL
;
4425 directory_table
= (unsigned char **)
4426 xmalloc (n_directories
* sizeof (unsigned char *));
4428 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4430 unsigned char **pathp
= &directory_table
[entryi
];
4432 format
= format_start
;
4433 for (formati
= 0; formati
< format_count
; formati
++)
4435 dwarf_vma content_type
, form
;
4438 READ_ULEB (content_type
, format
, end
);
4439 READ_ULEB (form
, format
, end
);
4442 warn (_("Corrupt directories list\n"));
4445 switch (content_type
)
4450 case DW_FORM_string
:
4453 case DW_FORM_line_strp
:
4454 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4456 /* Remove const by the cast. */
4457 *pathp
= (unsigned char *)
4458 fetch_indirect_line_string (uvalue
);
4463 data
= read_and_display_attr_value (0, form
, 0, start
,
4465 linfo
.li_offset_size
,
4472 warn (_("Corrupt directories list\n"));
4477 /* Skip files format. */
4478 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4479 if (do_checks
&& format_count
> 5)
4480 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4482 format_start
= data
;
4483 for (formati
= 0; formati
< format_count
; formati
++)
4485 SKIP_ULEB (data
, end
);
4486 SKIP_ULEB (data
, end
);
4489 READ_ULEB (n_files
, data
, end
);
4490 if (data
== end
&& n_files
> 0)
4492 warn (_("Corrupt file name list\n"));
4499 file_table
= (File_Entry
*) xcalloc (1, n_files
4500 * sizeof (File_Entry
));
4502 for (entryi
= 0; entryi
< n_files
; entryi
++)
4504 File_Entry
*file
= &file_table
[entryi
];
4506 format
= format_start
;
4507 for (formati
= 0; formati
< format_count
; formati
++)
4509 dwarf_vma content_type
, form
;
4513 READ_ULEB (content_type
, format
, end
);
4514 READ_ULEB (form
, format
, end
);
4517 warn (_("Corrupt file name list\n"));
4520 switch (content_type
)
4525 case DW_FORM_string
:
4528 case DW_FORM_line_strp
:
4529 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4531 /* Remove const by the cast. */
4532 file
->name
= (unsigned char *)
4533 fetch_indirect_line_string (uvalue
);
4537 case DW_LNCT_directory_index
:
4541 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4545 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4550 READ_ULEB (file
->directory_index
, tmp
, end
);
4555 data
= read_and_display_attr_value (0, form
, 0, start
,
4557 linfo
.li_offset_size
,
4564 warn (_("Corrupt file name list\n"));
4573 unsigned char *ptr_directory_table
= data
;
4575 while (data
< end
&& *data
!= 0)
4577 data
+= strnlen ((char *) data
, end
- data
) + 1;
4584 warn (_("directory table ends unexpectedly\n"));
4589 /* Go through the directory table again to save the directories. */
4590 directory_table
= (unsigned char **)
4591 xmalloc (n_directories
* sizeof (unsigned char *));
4594 while (*ptr_directory_table
!= 0)
4596 directory_table
[i
] = ptr_directory_table
;
4597 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4598 ptr_directory_table
- end
) + 1;
4602 /* Skip the NUL at the end of the table. */
4605 /* Traverse the File Name table just to count the entries. */
4606 if (data
< end
&& *data
!= 0)
4608 unsigned char *ptr_file_name_table
= data
;
4610 while (data
< end
&& *data
!= 0)
4612 /* Skip Name, directory index, last modification
4613 time and length of file. */
4614 data
+= strnlen ((char *) data
, end
- data
) + 1;
4615 SKIP_ULEB (data
, end
);
4616 SKIP_ULEB (data
, end
);
4617 SKIP_ULEB (data
, end
);
4623 warn (_("file table ends unexpectedly\n"));
4628 /* Go through the file table again to save the strings. */
4629 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4632 while (*ptr_file_name_table
!= 0)
4634 file_table
[i
].name
= ptr_file_name_table
;
4635 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4636 end
- ptr_file_name_table
) + 1;
4638 /* We are not interested in directory, time or size. */
4639 READ_ULEB (file_table
[i
].directory_index
,
4640 ptr_file_name_table
, end
);
4641 READ_ULEB (file_table
[i
].modification_date
,
4642 ptr_file_name_table
, end
);
4643 READ_ULEB (file_table
[i
].length
,
4644 ptr_file_name_table
, end
);
4650 /* Skip the NUL at the end of the table. */
4654 /* Print the Compilation Unit's name and a header. */
4655 if (file_table
== NULL
)
4656 printf (_("CU: No directory table\n"));
4657 else if (directory_table
== NULL
)
4658 printf (_("CU: %s:\n"), file_table
[0].name
);
4661 unsigned int ix
= file_table
[0].directory_index
;
4662 const char *directory
;
4667 else if (n_directories
== 0)
4668 directory
= _("<unknown>");
4669 else if (ix
> n_directories
)
4671 warn (_("directory index %u > number of directories %s\n"),
4672 ix
, dwarf_vmatoa ("u", n_directories
));
4673 directory
= _("<corrupt>");
4676 directory
= (char *) directory_table
[ix
- 1];
4678 if (do_wide
|| strlen (directory
) < 76)
4679 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4681 printf ("%s:\n", file_table
[0].name
);
4685 printf (_("File name Line number Starting address View Stmt\n"));
4687 printf (_("CU: Empty file name table\n"));
4688 saved_linfo
= linfo
;
4691 /* This loop iterates through the Dwarf Line Number Program. */
4692 while (data
< end_of_sequence
)
4694 unsigned char op_code
;
4697 unsigned long int uladv
;
4698 int is_special_opcode
= 0;
4703 if (op_code
>= linfo
.li_opcode_base
)
4705 op_code
-= linfo
.li_opcode_base
;
4706 uladv
= (op_code
/ linfo
.li_line_range
);
4707 if (linfo
.li_max_ops_per_insn
== 1)
4709 uladv
*= linfo
.li_min_insn_length
;
4710 state_machine_regs
.address
+= uladv
;
4712 state_machine_regs
.view
= 0;
4717 = ((state_machine_regs
.op_index
+ uladv
)
4718 / linfo
.li_max_ops_per_insn
)
4719 * linfo
.li_min_insn_length
;
4720 state_machine_regs
.address
4722 state_machine_regs
.op_index
4723 = (state_machine_regs
.op_index
+ uladv
)
4724 % linfo
.li_max_ops_per_insn
;
4726 state_machine_regs
.view
= 0;
4729 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4730 state_machine_regs
.line
+= adv
;
4731 is_special_opcode
= 1;
4732 /* Increment view after printing this row. */
4737 case DW_LNS_extended_op
:
4739 unsigned int ext_op_code_len
;
4740 unsigned char ext_op_code
;
4741 unsigned char *op_code_end
;
4742 unsigned char *op_code_data
= data
;
4744 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
4745 op_code_end
= op_code_data
+ ext_op_code_len
;
4746 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
4748 warn (_("Badly formed extended line op encountered!\n"));
4751 ext_op_code
= *op_code_data
++;
4755 switch (ext_op_code
)
4757 case DW_LNE_end_sequence
:
4758 /* Reset stuff after printing this row. */
4760 case DW_LNE_set_address
:
4761 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4763 op_code_end
- op_code_data
,
4765 state_machine_regs
.op_index
= 0;
4766 state_machine_regs
.view
= 0;
4768 case DW_LNE_define_file
:
4769 file_table
= (File_Entry
*) xrealloc
4770 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4772 ++state_machine_regs
.last_file_entry
;
4773 /* Source file name. */
4774 file_table
[n_files
].name
= op_code_data
;
4775 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4776 /* Directory index. */
4777 READ_ULEB (file_table
[n_files
].directory_index
,
4778 op_code_data
, op_code_end
);
4779 /* Last modification time. */
4780 READ_ULEB (file_table
[n_files
].modification_date
,
4781 op_code_data
, op_code_end
);
4783 READ_ULEB (file_table
[n_files
].length
,
4784 op_code_data
, op_code_end
);
4788 case DW_LNE_set_discriminator
:
4789 case DW_LNE_HP_set_sequence
:
4790 /* Simply ignored. */
4794 printf (_("UNKNOWN (%u): length %ld\n"),
4795 ext_op_code
, (long int) (op_code_data
- data
));
4802 /* Increment view after printing this row. */
4805 case DW_LNS_advance_pc
:
4806 READ_ULEB (uladv
, data
, end
);
4807 if (linfo
.li_max_ops_per_insn
== 1)
4809 uladv
*= linfo
.li_min_insn_length
;
4810 state_machine_regs
.address
+= uladv
;
4812 state_machine_regs
.view
= 0;
4817 = ((state_machine_regs
.op_index
+ uladv
)
4818 / linfo
.li_max_ops_per_insn
)
4819 * linfo
.li_min_insn_length
;
4820 state_machine_regs
.address
4822 state_machine_regs
.op_index
4823 = (state_machine_regs
.op_index
+ uladv
)
4824 % linfo
.li_max_ops_per_insn
;
4826 state_machine_regs
.view
= 0;
4830 case DW_LNS_advance_line
:
4831 READ_SLEB (adv
, data
, end
);
4832 state_machine_regs
.line
+= adv
;
4835 case DW_LNS_set_file
:
4836 READ_ULEB (uladv
, data
, end
);
4837 state_machine_regs
.file
= uladv
;
4840 unsigned file
= state_machine_regs
.file
- 1;
4843 if (file_table
== NULL
|| n_files
== 0)
4844 printf (_("\n [Use file table entry %d]\n"), file
);
4846 else if (file
>= n_files
)
4848 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4849 printf (_("\n <over large file table index %u>"), file
);
4851 else if ((dir
= file_table
[file
].directory_index
) == 0)
4852 /* If directory index is 0, that means current directory. */
4853 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4854 else if (directory_table
== NULL
|| n_directories
== 0)
4855 printf (_("\n [Use file %s in directory table entry %d]\n"),
4856 file_table
[file
].name
, dir
);
4858 else if (dir
> n_directories
)
4860 warn (_("directory index %u > number of directories %s\n"),
4861 dir
, dwarf_vmatoa ("u", n_directories
));
4862 printf (_("\n <over large directory table entry %u>\n"), dir
);
4865 printf ("\n%s/%s:\n",
4866 /* The directory index starts counting at 1. */
4867 directory_table
[dir
- 1], file_table
[file
].name
);
4871 case DW_LNS_set_column
:
4872 READ_ULEB (uladv
, data
, end
);
4873 state_machine_regs
.column
= uladv
;
4876 case DW_LNS_negate_stmt
:
4877 adv
= state_machine_regs
.is_stmt
;
4879 state_machine_regs
.is_stmt
= adv
;
4882 case DW_LNS_set_basic_block
:
4883 state_machine_regs
.basic_block
= 1;
4886 case DW_LNS_const_add_pc
:
4887 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4888 if (linfo
.li_max_ops_per_insn
== 1)
4890 uladv
*= linfo
.li_min_insn_length
;
4891 state_machine_regs
.address
+= uladv
;
4893 state_machine_regs
.view
= 0;
4898 = ((state_machine_regs
.op_index
+ uladv
)
4899 / linfo
.li_max_ops_per_insn
)
4900 * linfo
.li_min_insn_length
;
4901 state_machine_regs
.address
4903 state_machine_regs
.op_index
4904 = (state_machine_regs
.op_index
+ uladv
)
4905 % linfo
.li_max_ops_per_insn
;
4907 state_machine_regs
.view
= 0;
4911 case DW_LNS_fixed_advance_pc
:
4912 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4913 state_machine_regs
.address
+= uladv
;
4914 state_machine_regs
.op_index
= 0;
4915 /* Do NOT reset view. */
4918 case DW_LNS_set_prologue_end
:
4921 case DW_LNS_set_epilogue_begin
:
4924 case DW_LNS_set_isa
:
4925 READ_ULEB (uladv
, data
, end
);
4926 printf (_(" Set ISA to %lu\n"), uladv
);
4930 printf (_(" Unknown opcode %d with operands: "), op_code
);
4932 if (standard_opcodes
!= NULL
)
4933 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4937 READ_ULEB (val
, data
, end
);
4938 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
4939 i
== 1 ? "" : ", ");
4945 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4946 to the DWARF address/line matrix. */
4947 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4948 || (xop
== DW_LNS_copy
))
4950 const unsigned int MAX_FILENAME_LENGTH
= 35;
4952 char *newFileName
= NULL
;
4953 size_t fileNameLength
;
4957 unsigned indx
= state_machine_regs
.file
- 1;
4959 if (indx
>= n_files
)
4961 warn (_("corrupt file index %u encountered\n"), indx
);
4962 fileName
= _("<corrupt>");
4965 fileName
= (char *) file_table
[indx
].name
;
4968 fileName
= _("<unknown>");
4970 fileNameLength
= strlen (fileName
);
4972 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4974 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4975 /* Truncate file name */
4976 strncpy (newFileName
,
4977 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4978 MAX_FILENAME_LENGTH
+ 1);
4979 /* FIXME: This is to pacify gcc-10 which can warn that the
4980 strncpy above might leave a non-NUL terminated string
4981 in newFileName. It won't, but gcc's analysis doesn't
4982 quite go far enough to discover this. */
4983 newFileName
[MAX_FILENAME_LENGTH
] = 0;
4987 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4988 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4991 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4993 if (linfo
.li_max_ops_per_insn
== 1)
4994 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4995 newFileName
, state_machine_regs
.line
,
4996 state_machine_regs
.address
);
4998 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4999 newFileName
, state_machine_regs
.line
,
5000 state_machine_regs
.address
,
5001 state_machine_regs
.op_index
);
5005 if (linfo
.li_max_ops_per_insn
== 1)
5006 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5007 newFileName
, state_machine_regs
.line
,
5008 state_machine_regs
.address
);
5010 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5011 newFileName
, state_machine_regs
.line
,
5012 state_machine_regs
.address
,
5013 state_machine_regs
.op_index
);
5016 if (state_machine_regs
.view
)
5017 printf (" %6u", state_machine_regs
.view
);
5021 if (state_machine_regs
.is_stmt
)
5025 state_machine_regs
.view
++;
5027 if (xop
== -DW_LNE_end_sequence
)
5029 reset_state_machine (linfo
.li_default_is_stmt
);
5044 if (directory_table
)
5046 free (directory_table
);
5047 directory_table
= NULL
;
5058 display_debug_lines (struct dwarf_section
*section
, void *file
)
5060 unsigned char *data
= section
->start
;
5061 unsigned char *end
= data
+ section
->size
;
5063 int retValDecoded
= 1;
5065 if (do_debug_lines
== 0)
5066 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5068 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5069 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5071 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5072 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5074 if (!retValRaw
|| !retValDecoded
)
5081 find_debug_info_for_offset (unsigned long offset
)
5085 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5088 for (i
= 0; i
< num_debug_info_entries
; i
++)
5089 if (debug_information
[i
].cu_offset
== offset
)
5090 return debug_information
+ i
;
5096 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5098 /* See gdb/gdb-index.h. */
5099 static const char * const kinds
[] =
5111 return _ (kinds
[kind
]);
5115 display_debug_pubnames_worker (struct dwarf_section
*section
,
5116 void *file ATTRIBUTE_UNUSED
,
5119 DWARF2_Internal_PubNames names
;
5120 unsigned char *start
= section
->start
;
5121 unsigned char *end
= start
+ section
->size
;
5123 /* It does not matter if this load fails,
5124 we test for that later on. */
5125 load_debug_info (file
);
5127 introduce (section
, FALSE
);
5131 unsigned char *data
;
5132 unsigned long sec_off
;
5133 unsigned int offset_size
, initial_length_size
;
5135 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5136 if (names
.pn_length
== 0xffffffff)
5138 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5140 initial_length_size
= 12;
5145 initial_length_size
= 4;
5148 sec_off
= start
- section
->start
;
5149 if (sec_off
+ names
.pn_length
< sec_off
5150 || sec_off
+ names
.pn_length
> section
->size
)
5152 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5154 sec_off
- initial_length_size
,
5155 dwarf_vmatoa ("x", names
.pn_length
));
5160 start
+= names
.pn_length
;
5162 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5163 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5165 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5166 && num_debug_info_entries
> 0
5167 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5168 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5169 (unsigned long) names
.pn_offset
, section
->name
);
5171 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5173 printf (_(" Length: %ld\n"),
5174 (long) names
.pn_length
);
5175 printf (_(" Version: %d\n"),
5177 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5178 (unsigned long) names
.pn_offset
);
5179 printf (_(" Size of area in .debug_info section: %ld\n"),
5180 (long) names
.pn_size
);
5182 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5184 static int warned
= 0;
5188 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5196 printf (_("\n Offset Kind Name\n"));
5198 printf (_("\n Offset\tName\n"));
5202 bfd_size_type maxprint
;
5205 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5210 data
+= offset_size
;
5213 maxprint
= (end
- data
) - 1;
5217 unsigned int kind_data
;
5218 gdb_index_symbol_kind kind
;
5219 const char *kind_name
;
5222 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5225 /* GCC computes the kind as the upper byte in the CU index
5226 word, and then right shifts it by the CU index size.
5227 Left shift KIND to where the gdb-index.h accessor macros
5229 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5230 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5231 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5232 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5233 printf (" %-6lx %s,%-10s %.*s\n",
5234 (unsigned long) offset
, is_static
? _("s") : _("g"),
5235 kind_name
, (int) maxprint
, data
);
5238 printf (" %-6lx\t%.*s\n",
5239 (unsigned long) offset
, (int) maxprint
, data
);
5241 data
+= strnlen ((char *) data
, maxprint
) + 1;
5252 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5254 return display_debug_pubnames_worker (section
, file
, 0);
5258 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5260 return display_debug_pubnames_worker (section
, file
, 1);
5264 display_debug_macinfo (struct dwarf_section
*section
,
5265 void *file ATTRIBUTE_UNUSED
)
5267 unsigned char *start
= section
->start
;
5268 unsigned char *end
= start
+ section
->size
;
5269 unsigned char *curr
= start
;
5270 enum dwarf_macinfo_record_type op
;
5272 introduce (section
, FALSE
);
5276 unsigned int lineno
;
5277 const unsigned char *string
;
5279 op
= (enum dwarf_macinfo_record_type
) *curr
;
5284 case DW_MACINFO_start_file
:
5286 unsigned int filenum
;
5288 READ_ULEB (lineno
, curr
, end
);
5289 READ_ULEB (filenum
, curr
, end
);
5290 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5295 case DW_MACINFO_end_file
:
5296 printf (_(" DW_MACINFO_end_file\n"));
5299 case DW_MACINFO_define
:
5300 READ_ULEB (lineno
, curr
, end
);
5302 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5303 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5307 case DW_MACINFO_undef
:
5308 READ_ULEB (lineno
, curr
, end
);
5310 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5311 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5315 case DW_MACINFO_vendor_ext
:
5317 unsigned int constant
;
5319 READ_ULEB (constant
, curr
, end
);
5321 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5322 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5332 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5333 filename and dirname corresponding to file name table entry with index
5334 FILEIDX. Return NULL on failure. */
5336 static unsigned char *
5337 get_line_filename_and_dirname (dwarf_vma line_offset
,
5339 unsigned char **dir_name
)
5341 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5342 unsigned char *hdrptr
, *dirtable
, *file_name
;
5343 unsigned int offset_size
, initial_length_size
;
5344 unsigned int version
, opcode_base
;
5345 dwarf_vma length
, diridx
;
5346 const unsigned char * end
;
5349 if (section
->start
== NULL
5350 || line_offset
>= section
->size
5354 hdrptr
= section
->start
+ line_offset
;
5355 end
= section
->start
+ section
->size
;
5357 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5358 if (length
== 0xffffffff)
5360 /* This section is 64-bit DWARF 3. */
5361 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5363 initial_length_size
= 12;
5368 initial_length_size
= 4;
5370 if (length
+ initial_length_size
< length
5371 || length
+ initial_length_size
> section
->size
)
5374 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5375 if (version
!= 2 && version
!= 3 && version
!= 4)
5377 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5379 hdrptr
++; /* Skip max_ops_per_insn. */
5380 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5382 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5383 if (opcode_base
== 0)
5386 hdrptr
+= opcode_base
- 1;
5391 /* Skip over dirname table. */
5392 while (*hdrptr
!= '\0')
5394 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5398 hdrptr
++; /* Skip the NUL at the end of the table. */
5400 /* Now skip over preceding filename table entries. */
5401 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5403 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5404 SKIP_ULEB (hdrptr
, end
);
5405 SKIP_ULEB (hdrptr
, end
);
5406 SKIP_ULEB (hdrptr
, end
);
5408 if (hdrptr
>= end
|| *hdrptr
== '\0')
5412 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5415 READ_ULEB (diridx
, hdrptr
, end
);
5418 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5419 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5420 if (dirtable
>= end
|| *dirtable
== '\0')
5422 *dir_name
= dirtable
;
5427 display_debug_macro (struct dwarf_section
*section
,
5430 unsigned char *start
= section
->start
;
5431 unsigned char *end
= start
+ section
->size
;
5432 unsigned char *curr
= start
;
5433 unsigned char *extended_op_buf
[256];
5435 load_debug_section_with_follow (str
, file
);
5436 load_debug_section_with_follow (line
, file
);
5437 load_debug_section_with_follow (str_index
, file
);
5439 introduce (section
, FALSE
);
5443 unsigned int lineno
, version
, flags
;
5444 unsigned int offset_size
= 4;
5445 const unsigned char *string
;
5446 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5447 unsigned char **extended_ops
= NULL
;
5449 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5450 if (version
!= 4 && version
!= 5)
5452 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5457 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5460 printf (_(" Offset: 0x%lx\n"),
5461 (unsigned long) sec_offset
);
5462 printf (_(" Version: %d\n"), version
);
5463 printf (_(" Offset size: %d\n"), offset_size
);
5466 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5467 printf (_(" Offset into .debug_line: 0x%lx\n"),
5468 (unsigned long) line_offset
);
5472 unsigned int i
, count
, op
;
5475 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5477 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5478 extended_ops
= extended_op_buf
;
5481 printf (_(" Extension opcode arguments:\n"));
5482 for (i
= 0; i
< count
; i
++)
5484 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5485 extended_ops
[op
] = curr
;
5486 READ_ULEB (nargs
, curr
, end
);
5488 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5491 printf (_(" DW_MACRO_%02x arguments: "), op
);
5492 for (n
= 0; n
< nargs
; n
++)
5496 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5497 printf ("%s%s", get_FORM_name (form
),
5498 n
== nargs
- 1 ? "\n" : ", ");
5508 case DW_FORM_block1
:
5509 case DW_FORM_block2
:
5510 case DW_FORM_block4
:
5512 case DW_FORM_string
:
5514 case DW_FORM_sec_offset
:
5517 error (_("Invalid extension opcode form %s\n"),
5518 get_FORM_name (form
));
5534 error (_(".debug_macro section not zero terminated\n"));
5538 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5544 case DW_MACRO_define
:
5545 READ_ULEB (lineno
, curr
, end
);
5547 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5548 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5552 case DW_MACRO_undef
:
5553 READ_ULEB (lineno
, curr
, end
);
5555 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5556 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5560 case DW_MACRO_start_file
:
5562 unsigned int filenum
;
5563 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5565 READ_ULEB (lineno
, curr
, end
);
5566 READ_ULEB (filenum
, curr
, end
);
5568 if ((flags
& 2) == 0)
5569 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5572 = get_line_filename_and_dirname (line_offset
, filenum
,
5574 if (file_name
== NULL
)
5575 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5578 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5580 dir_name
!= NULL
? (const char *) dir_name
: "",
5581 dir_name
!= NULL
? "/" : "", file_name
);
5585 case DW_MACRO_end_file
:
5586 printf (_(" DW_MACRO_end_file\n"));
5589 case DW_MACRO_define_strp
:
5590 READ_ULEB (lineno
, curr
, end
);
5591 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5592 string
= fetch_indirect_string (offset
);
5593 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5597 case DW_MACRO_undef_strp
:
5598 READ_ULEB (lineno
, curr
, end
);
5599 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5600 string
= fetch_indirect_string (offset
);
5601 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5605 case DW_MACRO_import
:
5606 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5607 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5608 (unsigned long) offset
);
5611 case DW_MACRO_define_sup
:
5612 READ_ULEB (lineno
, curr
, end
);
5613 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5614 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5615 lineno
, (unsigned long) offset
);
5618 case DW_MACRO_undef_sup
:
5619 READ_ULEB (lineno
, curr
, end
);
5620 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5621 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5622 lineno
, (unsigned long) offset
);
5625 case DW_MACRO_import_sup
:
5626 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5627 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5628 (unsigned long) offset
);
5631 case DW_MACRO_define_strx
:
5632 case DW_MACRO_undef_strx
:
5633 READ_ULEB (lineno
, curr
, end
);
5634 READ_ULEB (offset
, curr
, end
);
5635 string
= (const unsigned char *)
5636 fetch_indexed_string (offset
, NULL
, offset_size
, FALSE
);
5637 if (op
== DW_MACRO_define_strx
)
5638 printf (" DW_MACRO_define_strx ");
5640 printf (" DW_MACRO_undef_strx ");
5642 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
5643 printf (_("lineno : %d macro : %s\n"),
5648 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
5650 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
5654 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5656 error (_(" Unknown macro opcode %02x seen\n"), op
);
5661 /* Skip over unhandled opcodes. */
5663 unsigned char *desc
= extended_ops
[op
];
5664 READ_ULEB (nargs
, desc
, end
);
5667 printf (_(" DW_MACRO_%02x\n"), op
);
5670 printf (_(" DW_MACRO_%02x -"), op
);
5671 for (n
= 0; n
< nargs
; n
++)
5675 /* DW_FORM_implicit_const is not expected here. */
5676 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5678 = read_and_display_attr_value (0, val
, 0,
5679 start
, curr
, end
, 0, 0, offset_size
,
5680 version
, NULL
, 0, NULL
,
5698 display_debug_abbrev (struct dwarf_section
*section
,
5699 void *file ATTRIBUTE_UNUSED
)
5701 abbrev_entry
*entry
;
5702 unsigned char *start
= section
->start
;
5703 unsigned char *end
= start
+ section
->size
;
5705 introduce (section
, FALSE
);
5709 unsigned char *last
;
5714 start
= process_abbrev_section (start
, end
);
5716 if (first_abbrev
== NULL
)
5719 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5721 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5725 printf (" %ld %s [%s]\n",
5727 get_TAG_name (entry
->tag
),
5728 entry
->children
? _("has children") : _("no children"));
5730 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5732 printf (" %-18s %s",
5733 get_AT_name (attr
->attribute
),
5734 get_FORM_name (attr
->form
));
5735 if (attr
->form
== DW_FORM_implicit_const
)
5736 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5748 /* Return true when ADDR is the maximum address, when addresses are
5749 POINTER_SIZE bytes long. */
5752 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5754 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5755 return ((addr
& mask
) == mask
);
5758 /* Display a view pair list starting at *VSTART_PTR and ending at
5759 VLISTEND within SECTION. */
5762 display_view_pair_list (struct dwarf_section
*section
,
5763 unsigned char **vstart_ptr
,
5764 unsigned int debug_info_entry
,
5765 unsigned char *vlistend
)
5767 unsigned char *vstart
= *vstart_ptr
;
5768 unsigned char *section_end
= section
->start
+ section
->size
;
5769 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5771 if (vlistend
< section_end
)
5772 section_end
= vlistend
;
5776 while (vstart
< section_end
)
5778 dwarf_vma off
= vstart
- section
->start
;
5779 dwarf_vma vbegin
, vend
;
5781 READ_ULEB (vbegin
, vstart
, section_end
);
5782 if (vstart
== section_end
)
5785 READ_ULEB (vend
, vstart
, section_end
);
5786 printf (" %8.8lx ", (unsigned long) off
);
5788 print_dwarf_view (vbegin
, pointer_size
, 1);
5789 print_dwarf_view (vend
, pointer_size
, 1);
5790 printf (_("location view pair\n"));
5794 *vstart_ptr
= vstart
;
5797 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5800 display_loc_list (struct dwarf_section
*section
,
5801 unsigned char **start_ptr
,
5802 unsigned int debug_info_entry
,
5804 dwarf_vma base_address
,
5805 unsigned char **vstart_ptr
,
5808 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5809 unsigned char *section_end
= section
->start
+ section
->size
;
5810 unsigned long cu_offset
;
5811 unsigned int pointer_size
;
5812 unsigned int offset_size
;
5817 unsigned short length
;
5818 int need_frame_base
;
5820 if (debug_info_entry
>= num_debug_info_entries
)
5822 warn (_("No debug information available for loc lists of entry: %u\n"),
5827 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5828 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5829 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5830 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5832 if (pointer_size
< 2 || pointer_size
> 8)
5834 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5835 pointer_size
, debug_info_entry
);
5841 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5842 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5844 if (start
+ 2 * pointer_size
> section_end
)
5846 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5847 (unsigned long) offset
);
5851 printf (" %8.8lx ", (unsigned long) off
);
5853 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5854 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5856 if (begin
== 0 && end
== 0)
5858 /* PR 18374: In a object file we can have a location list that
5859 starts with a begin and end of 0 because there are relocations
5860 that need to be applied to the addresses. Actually applying
5861 the relocations now does not help as they will probably resolve
5862 to 0, since the object file has not been fully linked. Real
5863 end of list markers will not have any relocations against them. */
5864 if (! reloc_at (section
, off
)
5865 && ! reloc_at (section
, off
+ pointer_size
))
5867 printf (_("<End of list>\n"));
5872 /* Check base address specifiers. */
5873 if (is_max_address (begin
, pointer_size
)
5874 && !is_max_address (end
, pointer_size
))
5877 print_dwarf_vma (begin
, pointer_size
);
5878 print_dwarf_vma (end
, pointer_size
);
5879 printf (_("(base address)\n"));
5885 off
= offset
+ (vstart
- *start_ptr
);
5887 READ_ULEB (vbegin
, vstart
, section_end
);
5888 print_dwarf_view (vbegin
, pointer_size
, 1);
5890 READ_ULEB (vend
, vstart
, section_end
);
5891 print_dwarf_view (vend
, pointer_size
, 1);
5893 printf (_("views at %8.8lx for:\n %*s "),
5894 (unsigned long) off
, 8, "");
5897 if (start
+ 2 > section_end
)
5899 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5900 (unsigned long) offset
);
5904 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5906 if (start
+ length
> section_end
)
5908 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5909 (unsigned long) offset
);
5913 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5914 print_dwarf_vma (end
+ base_address
, pointer_size
);
5917 need_frame_base
= decode_location_expression (start
,
5922 cu_offset
, section
);
5925 if (need_frame_base
&& !has_frame_base
)
5926 printf (_(" [without DW_AT_frame_base]"));
5928 if (begin
== end
&& vbegin
== vend
)
5929 fputs (_(" (start == end)"), stdout
);
5930 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5931 fputs (_(" (start > end)"), stdout
);
5939 *vstart_ptr
= vstart
;
5942 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5945 display_loclists_list (struct dwarf_section
*section
,
5946 unsigned char **start_ptr
,
5947 unsigned int debug_info_entry
,
5949 dwarf_vma base_address
,
5950 unsigned char **vstart_ptr
,
5953 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5954 unsigned char *section_end
= section
->start
+ section
->size
;
5955 unsigned long cu_offset
;
5956 unsigned int pointer_size
;
5957 unsigned int offset_size
;
5960 /* Initialize it due to a false compiler warning. */
5961 dwarf_vma begin
= -1, vbegin
= -1;
5962 dwarf_vma end
= -1, vend
= -1;
5964 int need_frame_base
;
5966 if (debug_info_entry
>= num_debug_info_entries
)
5968 warn (_("No debug information available for "
5969 "loclists lists of entry: %u\n"),
5974 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5975 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5976 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5977 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5979 if (pointer_size
< 2 || pointer_size
> 8)
5981 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5982 pointer_size
, debug_info_entry
);
5988 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5989 enum dwarf_location_list_entry_type llet
;
5991 if (start
+ 1 > section_end
)
5993 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5994 (unsigned long) offset
);
5998 printf (" %8.8lx ", (unsigned long) off
);
6000 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6002 if (vstart
&& llet
== DW_LLE_offset_pair
)
6004 off
= offset
+ (vstart
- *start_ptr
);
6006 READ_ULEB (vbegin
, vstart
, section_end
);
6007 print_dwarf_view (vbegin
, pointer_size
, 1);
6009 READ_ULEB (vend
, vstart
, section_end
);
6010 print_dwarf_view (vend
, pointer_size
, 1);
6012 printf (_("views at %8.8lx for:\n %*s "),
6013 (unsigned long) off
, 8, "");
6018 case DW_LLE_end_of_list
:
6019 printf (_("<End of list>\n"));
6021 case DW_LLE_offset_pair
:
6022 READ_ULEB (begin
, start
, section_end
);
6023 READ_ULEB (end
, start
, section_end
);
6025 case DW_LLE_base_address
:
6026 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6028 print_dwarf_vma (base_address
, pointer_size
);
6029 printf (_("(base address)\n"));
6031 #ifdef DW_LLE_view_pair
6032 case DW_LLE_view_pair
:
6034 printf (_("View pair entry in loclist with locviews attribute\n"));
6035 READ_ULEB (vbegin
, start
, section_end
);
6036 print_dwarf_view (vbegin
, pointer_size
, 1);
6038 READ_ULEB (vend
, start
, section_end
);
6039 print_dwarf_view (vend
, pointer_size
, 1);
6041 printf (_("views for:\n"));
6045 error (_("Invalid location list entry type %d\n"), llet
);
6048 if (llet
== DW_LLE_end_of_list
)
6050 if (llet
!= DW_LLE_offset_pair
)
6053 if (start
+ 2 > section_end
)
6055 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6056 (unsigned long) offset
);
6060 READ_ULEB (length
, start
, section_end
);
6062 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6063 print_dwarf_vma (end
+ base_address
, pointer_size
);
6066 need_frame_base
= decode_location_expression (start
,
6071 cu_offset
, section
);
6074 if (need_frame_base
&& !has_frame_base
)
6075 printf (_(" [without DW_AT_frame_base]"));
6077 if (begin
== end
&& vbegin
== vend
)
6078 fputs (_(" (start == end)"), stdout
);
6079 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6080 fputs (_(" (start > end)"), stdout
);
6088 if (vbegin
!= vm1
|| vend
!= vm1
)
6089 printf (_("Trailing view pair not used in a range"));
6092 *vstart_ptr
= vstart
;
6095 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6096 right-adjusted in a field of length LEN, and followed by a space. */
6099 print_addr_index (unsigned int idx
, unsigned int len
)
6101 static char buf
[15];
6102 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6103 printf ("%*s ", len
, buf
);
6106 /* Display a location list from a .dwo section. It uses address indexes rather
6107 than embedded addresses. This code closely follows display_loc_list, but the
6108 two are sufficiently different that combining things is very ugly. */
6111 display_loc_list_dwo (struct dwarf_section
*section
,
6112 unsigned char **start_ptr
,
6113 unsigned int debug_info_entry
,
6115 unsigned char **vstart_ptr
,
6118 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6119 unsigned char *section_end
= section
->start
+ section
->size
;
6120 unsigned long cu_offset
;
6121 unsigned int pointer_size
;
6122 unsigned int offset_size
;
6125 unsigned short length
;
6126 int need_frame_base
;
6129 if (debug_info_entry
>= num_debug_info_entries
)
6131 warn (_("No debug information for loc lists of entry: %u\n"),
6136 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6137 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6138 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6139 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6141 if (pointer_size
< 2 || pointer_size
> 8)
6143 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6144 pointer_size
, debug_info_entry
);
6150 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6152 if (start
>= section_end
)
6154 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6155 (unsigned long) offset
);
6159 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6172 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6174 READ_ULEB (view
, vstart
, section_end
);
6175 print_dwarf_view (view
, 8, 1);
6177 READ_ULEB (view
, vstart
, section_end
);
6178 print_dwarf_view (view
, 8, 1);
6180 printf (_("views at %8.8lx for:\n %*s "),
6181 (unsigned long) off
, 8, "");
6189 case 0: /* A terminating entry. */
6191 *vstart_ptr
= vstart
;
6192 printf (_("<End of list>\n"));
6194 case 1: /* A base-address entry. */
6195 READ_ULEB (idx
, start
, section_end
);
6196 print_addr_index (idx
, 8);
6197 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6198 printf (_("(base address selection entry)\n"));
6200 case 2: /* A start/end entry. */
6201 READ_ULEB (idx
, start
, section_end
);
6202 print_addr_index (idx
, 8);
6203 READ_ULEB (idx
, start
, section_end
);
6204 print_addr_index (idx
, 8);
6206 case 3: /* A start/length entry. */
6207 READ_ULEB (idx
, start
, section_end
);
6208 print_addr_index (idx
, 8);
6209 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6210 printf ("%08x ", idx
);
6212 case 4: /* An offset pair entry. */
6213 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6214 printf ("%08x ", idx
);
6215 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6216 printf ("%08x ", idx
);
6219 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6221 *vstart_ptr
= vstart
;
6225 if (start
+ 2 > section_end
)
6227 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6228 (unsigned long) offset
);
6232 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6233 if (start
+ length
> section_end
)
6235 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6236 (unsigned long) offset
);
6241 need_frame_base
= decode_location_expression (start
,
6246 cu_offset
, section
);
6249 if (need_frame_base
&& !has_frame_base
)
6250 printf (_(" [without DW_AT_frame_base]"));
6258 *vstart_ptr
= vstart
;
6261 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6264 static dwarf_vma
*loc_offsets
, *loc_views
;
6267 loc_offsets_compar (const void *ap
, const void *bp
)
6269 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6270 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6272 int ret
= (a
> b
) - (b
> a
);
6276 a
= loc_views
[*(const unsigned int *) ap
];
6277 b
= loc_views
[*(const unsigned int *) bp
];
6279 ret
= (a
> b
) - (b
> a
);
6285 display_debug_loc (struct dwarf_section
*section
, void *file
)
6287 unsigned char *start
= section
->start
, *vstart
= NULL
;
6288 unsigned long bytes
;
6289 unsigned char *section_begin
= start
;
6290 unsigned int num_loc_list
= 0;
6291 unsigned long last_offset
= 0;
6292 unsigned long last_view
= 0;
6293 unsigned int first
= 0;
6296 int seen_first_offset
= 0;
6297 int locs_sorted
= 1;
6298 unsigned char *next
= start
, *vnext
= vstart
;
6299 unsigned int *array
= NULL
;
6300 const char *suffix
= strrchr (section
->name
, '.');
6301 bfd_boolean is_dwo
= FALSE
;
6302 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6303 dwarf_vma expected_start
= 0;
6305 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6308 bytes
= section
->size
;
6312 printf (_("\nThe %s section is empty.\n"), section
->name
);
6318 unsigned char *hdrptr
= section_begin
;
6319 dwarf_vma ll_length
;
6320 unsigned short ll_version
;
6321 unsigned char *end
= section_begin
+ section
->size
;
6322 unsigned char address_size
, segment_selector_size
;
6323 uint32_t offset_entry_count
;
6325 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6326 if (ll_length
== 0xffffffff)
6327 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6329 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6330 if (ll_version
!= 5)
6332 warn (_("The %s section contains corrupt or "
6333 "unsupported version number: %d.\n"),
6334 section
->name
, ll_version
);
6338 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6340 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6341 if (segment_selector_size
!= 0)
6343 warn (_("The %s section contains "
6344 "unsupported segment selector size: %d.\n"),
6345 section
->name
, segment_selector_size
);
6349 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6350 if (offset_entry_count
!= 0)
6352 warn (_("The %s section contains "
6353 "unsupported offset entry count: %d.\n"),
6354 section
->name
, offset_entry_count
);
6358 expected_start
= hdrptr
- section_begin
;
6361 if (load_debug_info (file
) == 0)
6363 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6368 /* Check the order of location list in .debug_info section. If
6369 offsets of location lists are in the ascending order, we can
6370 use `debug_information' directly. */
6371 for (i
= 0; i
< num_debug_info_entries
; i
++)
6375 num
= debug_information
[i
].num_loc_offsets
;
6376 if (num
> num_loc_list
)
6379 /* Check if we can use `debug_information' directly. */
6380 if (locs_sorted
&& num
!= 0)
6382 if (!seen_first_offset
)
6384 /* This is the first location list. */
6385 last_offset
= debug_information
[i
].loc_offsets
[0];
6386 last_view
= debug_information
[i
].loc_views
[0];
6388 seen_first_offset
= 1;
6394 for (; j
< num
; j
++)
6397 debug_information
[i
].loc_offsets
[j
]
6398 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6399 && last_view
> debug_information
[i
].loc_views
[j
]))
6404 last_offset
= debug_information
[i
].loc_offsets
[j
];
6405 last_view
= debug_information
[i
].loc_views
[j
];
6410 if (!seen_first_offset
)
6411 error (_("No location lists in .debug_info section!\n"));
6413 if (debug_information
[first
].num_loc_offsets
> 0
6414 && debug_information
[first
].loc_offsets
[0] != expected_start
6415 && debug_information
[first
].loc_views
[0] != expected_start
)
6416 warn (_("Location lists in %s section start at 0x%s\n"),
6418 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6421 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6423 introduce (section
, FALSE
);
6425 if (reloc_at (section
, 0))
6426 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6428 printf (_(" Offset Begin End Expression\n"));
6430 seen_first_offset
= 0;
6431 for (i
= first
; i
< num_debug_info_entries
; i
++)
6433 dwarf_vma offset
, voffset
;
6434 dwarf_vma base_address
;
6440 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6442 loc_offsets
= debug_information
[i
].loc_offsets
;
6443 loc_views
= debug_information
[i
].loc_views
;
6444 qsort (array
, debug_information
[i
].num_loc_offsets
,
6445 sizeof (*array
), loc_offsets_compar
);
6448 int adjacent_view_loclists
= 1;
6449 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6451 j
= locs_sorted
? k
: array
[k
];
6453 && (debug_information
[i
].loc_offsets
[locs_sorted
6454 ? k
- 1 : array
[k
- 1]]
6455 == debug_information
[i
].loc_offsets
[j
])
6456 && (debug_information
[i
].loc_views
[locs_sorted
6457 ? k
- 1 : array
[k
- 1]]
6458 == debug_information
[i
].loc_views
[j
]))
6460 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6461 offset
= debug_information
[i
].loc_offsets
[j
];
6462 next
= section_begin
+ offset
;
6463 voffset
= debug_information
[i
].loc_views
[j
];
6465 vnext
= section_begin
+ voffset
;
6468 base_address
= debug_information
[i
].base_address
;
6470 if (vnext
&& vnext
< next
)
6473 display_view_pair_list (section
, &vstart
, i
, next
);
6478 if (!seen_first_offset
|| !adjacent_view_loclists
)
6479 seen_first_offset
= 1;
6483 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6484 (unsigned long) (start
- section_begin
),
6485 (unsigned long) offset
);
6486 else if (start
> next
)
6487 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6488 (unsigned long) (start
- section_begin
),
6489 (unsigned long) offset
);
6494 if (offset
>= bytes
)
6496 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6497 (unsigned long) offset
);
6501 if (vnext
&& voffset
>= bytes
)
6503 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6504 (unsigned long) voffset
);
6511 display_loc_list_dwo (section
, &start
, i
, offset
,
6512 &vstart
, has_frame_base
);
6514 display_loc_list (section
, &start
, i
, offset
, base_address
,
6515 &vstart
, has_frame_base
);
6520 warn (_("DWO is not yet supported.\n"));
6522 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6523 &vstart
, has_frame_base
);
6526 /* FIXME: this arrangement is quite simplistic. Nothing
6527 requires locview lists to be adjacent to corresponding
6528 loclists, and a single loclist could be augmented by
6529 different locview lists, and vice-versa, unlikely as it
6530 is that it would make sense to do so. Hopefully we'll
6531 have view pair support built into loclists before we ever
6532 need to address all these possibilities. */
6533 if (adjacent_view_loclists
&& vnext
6534 && vnext
!= start
&& vstart
!= next
)
6536 adjacent_view_loclists
= 0;
6537 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6540 if (vnext
&& vnext
== start
)
6541 display_view_pair_list (section
, &start
, i
, vstart
);
6545 if (start
< section
->start
+ section
->size
)
6546 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6547 "There are %ld unused bytes at the end of section %s\n",
6548 (long) (section
->start
+ section
->size
- start
)),
6549 (long) (section
->start
+ section
->size
- start
), section
->name
);
6556 display_debug_str (struct dwarf_section
*section
,
6557 void *file ATTRIBUTE_UNUSED
)
6559 unsigned char *start
= section
->start
;
6560 unsigned long bytes
= section
->size
;
6561 dwarf_vma addr
= section
->address
;
6565 printf (_("\nThe %s section is empty.\n"), section
->name
);
6569 introduce (section
, FALSE
);
6577 lbytes
= (bytes
> 16 ? 16 : bytes
);
6579 printf (" 0x%8.8lx ", (unsigned long) addr
);
6581 for (j
= 0; j
< 16; j
++)
6584 printf ("%2.2x", start
[j
]);
6592 for (j
= 0; j
< lbytes
; j
++)
6595 if (k
>= ' ' && k
< 0x80)
6614 display_debug_info (struct dwarf_section
*section
, void *file
)
6616 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6620 display_debug_types (struct dwarf_section
*section
, void *file
)
6622 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6626 display_trace_info (struct dwarf_section
*section
, void *file
)
6628 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6632 display_debug_aranges (struct dwarf_section
*section
,
6633 void *file ATTRIBUTE_UNUSED
)
6635 unsigned char *start
= section
->start
;
6636 unsigned char *end
= start
+ section
->size
;
6638 introduce (section
, FALSE
);
6640 /* It does not matter if this load fails,
6641 we test for that later on. */
6642 load_debug_info (file
);
6646 unsigned char *hdrptr
;
6647 DWARF2_Internal_ARange arange
;
6648 unsigned char *addr_ranges
;
6651 unsigned long sec_off
;
6652 unsigned char address_size
;
6654 unsigned int offset_size
;
6655 unsigned int initial_length_size
;
6659 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6660 if (arange
.ar_length
== 0xffffffff)
6662 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6664 initial_length_size
= 12;
6669 initial_length_size
= 4;
6672 sec_off
= hdrptr
- section
->start
;
6673 if (sec_off
+ arange
.ar_length
< sec_off
6674 || sec_off
+ arange
.ar_length
> section
->size
)
6676 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6678 sec_off
- initial_length_size
,
6679 dwarf_vmatoa ("x", arange
.ar_length
));
6683 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6684 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6686 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6687 && num_debug_info_entries
> 0
6688 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6689 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6690 (unsigned long) arange
.ar_info_offset
, section
->name
);
6692 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6693 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6695 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6697 /* PR 19872: A version number of 0 probably means that there is
6698 padding at the end of the .debug_aranges section. Gold puts
6699 it there when performing an incremental link, for example.
6700 So do not generate a warning in this case. */
6701 if (arange
.ar_version
)
6702 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6706 printf (_(" Length: %ld\n"),
6707 (long) arange
.ar_length
);
6708 printf (_(" Version: %d\n"), arange
.ar_version
);
6709 printf (_(" Offset into .debug_info: 0x%lx\n"),
6710 (unsigned long) arange
.ar_info_offset
);
6711 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6712 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6714 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6716 /* PR 17512: file: 001-108546-0.001:0.1. */
6717 if (address_size
== 0 || address_size
> 8)
6719 error (_("Invalid address size in %s section!\n"),
6724 /* The DWARF spec does not require that the address size be a power
6725 of two, but we do. This will have to change if we ever encounter
6726 an uneven architecture. */
6727 if ((address_size
& (address_size
- 1)) != 0)
6729 warn (_("Pointer size + Segment size is not a power of two.\n"));
6733 if (address_size
> 4)
6734 printf (_("\n Address Length\n"));
6736 printf (_("\n Address Length\n"));
6738 addr_ranges
= hdrptr
;
6740 /* Must pad to an alignment boundary that is twice the address size. */
6741 excess
= (hdrptr
- start
) % (2 * address_size
);
6743 addr_ranges
+= (2 * address_size
) - excess
;
6745 start
+= arange
.ar_length
+ initial_length_size
;
6747 while (addr_ranges
+ 2 * address_size
<= start
)
6749 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6750 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6753 print_dwarf_vma (address
, address_size
);
6754 print_dwarf_vma (length
, address_size
);
6764 /* Comparison function for qsort. */
6766 comp_addr_base (const void * v0
, const void * v1
)
6768 debug_info
*info0
= *(debug_info
**) v0
;
6769 debug_info
*info1
= *(debug_info
**) v1
;
6770 return info0
->addr_base
- info1
->addr_base
;
6773 /* Display the debug_addr section. */
6775 display_debug_addr (struct dwarf_section
*section
,
6778 debug_info
**debug_addr_info
;
6779 unsigned char *entry
;
6784 if (section
->size
== 0)
6786 printf (_("\nThe %s section is empty.\n"), section
->name
);
6790 if (load_debug_info (file
) == 0)
6792 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6797 introduce (section
, FALSE
);
6799 /* PR 17531: file: cf38d01b.
6800 We use xcalloc because a corrupt file may not have initialised all of the
6801 fields in the debug_info structure, which means that the sort below might
6802 try to move uninitialised data. */
6803 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6804 sizeof (debug_info
*));
6807 for (i
= 0; i
< num_debug_info_entries
; i
++)
6808 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6810 /* PR 17531: file: cf38d01b. */
6811 if (debug_information
[i
].addr_base
>= section
->size
)
6812 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6813 (unsigned long) debug_information
[i
].addr_base
, i
);
6815 debug_addr_info
[count
++] = debug_information
+ i
;
6818 /* Add a sentinel to make iteration convenient. */
6819 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6820 debug_addr_info
[count
]->addr_base
= section
->size
;
6821 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6823 for (i
= 0; i
< count
; i
++)
6826 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6828 printf (_(" For compilation unit at offset 0x%s:\n"),
6829 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6831 printf (_("\tIndex\tAddress\n"));
6832 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6833 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6837 dwarf_vma base
= byte_get (entry
, address_size
);
6838 printf (_("\t%d:\t"), idx
);
6839 print_dwarf_vma (base
, address_size
);
6841 entry
+= address_size
;
6847 free (debug_addr_info
);
6851 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6854 display_debug_str_offsets (struct dwarf_section
*section
,
6855 void *file ATTRIBUTE_UNUSED
)
6859 if (section
->size
== 0)
6861 printf (_("\nThe %s section is empty.\n"), section
->name
);
6865 unsigned char *start
= section
->start
;
6866 unsigned char *end
= start
+ section
->size
;
6867 unsigned char *curr
= start
;
6869 const char * suffix
= strrchr (section
->name
, '.');
6870 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
6873 load_debug_section_with_follow (str_dwo
, file
);
6875 load_debug_section_with_follow (str
, file
);
6877 introduce (section
, FALSE
);
6882 dwarf_vma entry_length
;
6884 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
6885 /* FIXME: We assume that this means 64-bit DWARF is being used. */
6886 if (length
== 0xffffffff)
6888 SAFE_BYTE_GET (length
, curr
, 8, end
);
6896 /* This is probably an old style .debug_str_offset section which
6897 just contains offsets and no header (and the first offset is 0). */
6898 length
= section
->size
;
6899 curr
= section
->start
;
6901 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6902 printf (_(" Index Offset [String]\n"));
6907 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6909 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
6912 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
6914 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
6916 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6917 printf (_(" Version: %#lx\n"), (unsigned long) version
);
6918 printf (_(" Index Offset [String]\n"));
6921 for (idx
= 0; length
>= entry_length
&& curr
< end
; idx
++)
6924 const unsigned char * string
;
6926 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, end
);
6928 string
= (const unsigned char *)
6929 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
6931 string
= fetch_indirect_string (offset
);
6933 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
6941 /* Each debug_information[x].range_lists[y] gets this representation for
6942 sorting purposes. */
6946 /* The debug_information[x].range_lists[y] value. */
6947 dwarf_vma ranges_offset
;
6949 /* Original debug_information to find parameters of the data. */
6950 debug_info
*debug_info_p
;
6953 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6956 range_entry_compar (const void *ap
, const void *bp
)
6958 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6959 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6960 const dwarf_vma a
= a_re
->ranges_offset
;
6961 const dwarf_vma b
= b_re
->ranges_offset
;
6963 return (a
> b
) - (b
> a
);
6967 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6968 unsigned int pointer_size
, unsigned long offset
,
6969 unsigned long base_address
)
6971 while (start
< finish
)
6976 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6977 if (start
>= finish
)
6979 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6982 printf (" %8.8lx ", offset
);
6984 if (begin
== 0 && end
== 0)
6986 printf (_("<End of list>\n"));
6990 /* Check base address specifiers. */
6991 if (is_max_address (begin
, pointer_size
)
6992 && !is_max_address (end
, pointer_size
))
6995 print_dwarf_vma (begin
, pointer_size
);
6996 print_dwarf_vma (end
, pointer_size
);
6997 printf ("(base address)\n");
7001 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7002 print_dwarf_vma (end
+ base_address
, pointer_size
);
7005 fputs (_("(start == end)"), stdout
);
7006 else if (begin
> end
)
7007 fputs (_("(start > end)"), stdout
);
7014 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7015 unsigned int pointer_size
, unsigned long offset
,
7016 unsigned long base_address
)
7018 unsigned char *next
= start
;
7022 unsigned long off
= offset
+ (start
- next
);
7023 enum dwarf_range_list_entry rlet
;
7024 /* Initialize it due to a false compiler warning. */
7025 dwarf_vma begin
= -1, length
, end
= -1;
7027 if (start
+ 1 > finish
)
7029 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7034 printf (" %8.8lx ", off
);
7036 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7040 case DW_RLE_end_of_list
:
7041 printf (_("<End of list>\n"));
7043 case DW_RLE_base_address
:
7044 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7045 print_dwarf_vma (base_address
, pointer_size
);
7046 printf (_("(base address)\n"));
7048 case DW_RLE_start_length
:
7049 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7050 READ_ULEB (length
, start
, finish
);
7051 end
= begin
+ length
;
7053 case DW_RLE_offset_pair
:
7054 READ_ULEB (begin
, start
, finish
);
7055 READ_ULEB (end
, start
, finish
);
7057 case DW_RLE_start_end
:
7058 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7059 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7062 error (_("Invalid range list entry type %d\n"), rlet
);
7063 rlet
= DW_RLE_end_of_list
;
7066 if (rlet
== DW_RLE_end_of_list
)
7068 if (rlet
== DW_RLE_base_address
)
7071 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7072 print_dwarf_vma (end
+ base_address
, pointer_size
);
7075 fputs (_("(start == end)"), stdout
);
7076 else if (begin
> end
)
7077 fputs (_("(start > end)"), stdout
);
7084 display_debug_ranges (struct dwarf_section
*section
,
7085 void *file ATTRIBUTE_UNUSED
)
7087 unsigned char *start
= section
->start
;
7088 unsigned char *last_start
= start
;
7089 unsigned long bytes
= section
->size
;
7090 unsigned char *section_begin
= start
;
7091 unsigned char *finish
= start
+ bytes
;
7092 unsigned int num_range_list
, i
;
7093 struct range_entry
*range_entries
, *range_entry_fill
;
7094 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7095 /* Initialize it due to a false compiler warning. */
7096 unsigned char address_size
= 0;
7097 dwarf_vma last_offset
= 0;
7101 printf (_("\nThe %s section is empty.\n"), section
->name
);
7107 dwarf_vma initial_length
;
7108 unsigned int initial_length_size
;
7109 unsigned char segment_selector_size
;
7110 unsigned int offset_size
, offset_entry_count
;
7111 unsigned short version
;
7113 /* Get and check the length of the block. */
7114 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7116 if (initial_length
== 0xffffffff)
7118 /* This section is 64-bit DWARF 3. */
7119 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7121 initial_length_size
= 12;
7126 initial_length_size
= 4;
7129 if (initial_length
+ initial_length_size
> section
->size
)
7131 /* If the length field has a relocation against it, then we should
7132 not complain if it is inaccurate (and probably negative).
7133 It is copied from .debug_line handling code. */
7134 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7136 initial_length
= (finish
- start
) - initial_length_size
;
7140 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7141 (long) initial_length
);
7146 /* Get and check the version number. */
7147 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7151 warn (_("Only DWARF version 5 debug_rnglists info "
7152 "is currently supported.\n"));
7156 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7158 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7159 if (segment_selector_size
!= 0)
7161 warn (_("The %s section contains "
7162 "unsupported segment selector size: %d.\n"),
7163 section
->name
, segment_selector_size
);
7167 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7168 if (offset_entry_count
!= 0)
7170 warn (_("The %s section contains "
7171 "unsupported offset entry count: %u.\n"),
7172 section
->name
, offset_entry_count
);
7177 if (load_debug_info (file
) == 0)
7179 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7185 for (i
= 0; i
< num_debug_info_entries
; i
++)
7186 num_range_list
+= debug_information
[i
].num_range_lists
;
7188 if (num_range_list
== 0)
7190 /* This can happen when the file was compiled with -gsplit-debug
7191 which removes references to range lists from the primary .o file. */
7192 printf (_("No range lists in .debug_info section.\n"));
7196 range_entries
= (struct range_entry
*)
7197 xmalloc (sizeof (*range_entries
) * num_range_list
);
7198 range_entry_fill
= range_entries
;
7200 for (i
= 0; i
< num_debug_info_entries
; i
++)
7202 debug_info
*debug_info_p
= &debug_information
[i
];
7205 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7207 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7208 range_entry_fill
->debug_info_p
= debug_info_p
;
7213 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7214 range_entry_compar
);
7216 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7217 warn (_("Range lists in %s section start at 0x%lx\n"),
7218 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7220 introduce (section
, FALSE
);
7222 printf (_(" Offset Begin End\n"));
7224 for (i
= 0; i
< num_range_list
; i
++)
7226 struct range_entry
*range_entry
= &range_entries
[i
];
7227 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7228 unsigned int pointer_size
;
7230 unsigned char *next
;
7231 dwarf_vma base_address
;
7233 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7234 offset
= range_entry
->ranges_offset
;
7235 next
= section_begin
+ offset
;
7236 base_address
= debug_info_p
->base_address
;
7238 /* PR 17512: file: 001-101485-0.001:0.1. */
7239 if (pointer_size
< 2 || pointer_size
> 8)
7241 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7242 pointer_size
, (unsigned long) offset
);
7246 if (next
< section_begin
|| next
>= finish
)
7248 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7249 (unsigned long) offset
, i
);
7253 /* If multiple DWARF entities reference the same range then we will
7254 have multiple entries in the `range_entries' list for the same
7255 offset. Thanks to the sort above these will all be consecutive in
7256 the `range_entries' list, so we can easily ignore duplicates
7258 if (i
> 0 && last_offset
== offset
)
7260 last_offset
= offset
;
7262 if (dwarf_check
!= 0 && i
> 0)
7265 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7266 (unsigned long) (start
- section_begin
),
7267 (unsigned long) (next
- section_begin
), section
->name
);
7268 else if (start
> next
)
7270 if (next
== last_start
)
7272 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7273 (unsigned long) (start
- section_begin
),
7274 (unsigned long) (next
- section_begin
), section
->name
);
7281 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7282 (start
, finish
, pointer_size
, offset
, base_address
);
7286 free (range_entries
);
7291 typedef struct Frame_Chunk
7293 struct Frame_Chunk
*next
;
7294 unsigned char *chunk_start
;
7296 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7297 short int *col_type
;
7300 unsigned int code_factor
;
7304 unsigned int cfa_reg
;
7305 dwarf_vma cfa_offset
;
7307 unsigned char fde_encoding
;
7308 unsigned char cfa_exp
;
7309 unsigned char ptr_size
;
7310 unsigned char segment_size
;
7314 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7315 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7316 static const char *const *dwarf_regnames
;
7317 static unsigned int dwarf_regnames_count
;
7320 /* A marker for a col_type that means this column was never referenced
7321 in the frame info. */
7322 #define DW_CFA_unreferenced (-1)
7324 /* Return 0 if no more space is needed, 1 if more space is needed,
7325 -1 for invalid reg. */
7328 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7330 unsigned int prev
= fc
->ncols
;
7332 if (reg
< (unsigned int) fc
->ncols
)
7335 if (dwarf_regnames_count
> 0
7336 && reg
> dwarf_regnames_count
)
7339 fc
->ncols
= reg
+ 1;
7340 /* PR 17512: file: 10450-2643-0.004.
7341 If reg == -1 then this can happen... */
7345 /* PR 17512: file: 2844a11d. */
7346 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7348 error (_("Unfeasibly large register number: %u\n"), reg
);
7350 /* FIXME: 1024 is an arbitrary limit. Increase it if
7351 we ever encounter a valid binary that exceeds it. */
7355 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7356 sizeof (short int));
7357 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7358 /* PR 17512: file:002-10025-0.005. */
7359 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7361 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7367 while (prev
< fc
->ncols
)
7369 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7370 fc
->col_offset
[prev
] = 0;
7376 static const char *const dwarf_regnames_i386
[] =
7378 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7379 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7380 "eip", "eflags", NULL
, /* 8 - 10 */
7381 "st0", "st1", "st2", "st3", /* 11 - 14 */
7382 "st4", "st5", "st6", "st7", /* 15 - 18 */
7383 NULL
, NULL
, /* 19 - 20 */
7384 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7385 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7386 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7387 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7388 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7389 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7390 "tr", "ldtr", /* 48 - 49 */
7391 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7392 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7393 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7394 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7395 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7396 NULL
, NULL
, NULL
, /* 90 - 92 */
7397 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7400 static const char *const dwarf_regnames_iamcu
[] =
7402 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7403 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7404 "eip", "eflags", NULL
, /* 8 - 10 */
7405 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7406 NULL
, NULL
, /* 19 - 20 */
7407 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7408 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7409 NULL
, NULL
, NULL
, /* 37 - 39 */
7410 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7411 "tr", "ldtr", /* 48 - 49 */
7412 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7413 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7414 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7415 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7416 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7417 NULL
, NULL
, NULL
, /* 90 - 92 */
7418 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7422 init_dwarf_regnames_i386 (void)
7424 dwarf_regnames
= dwarf_regnames_i386
;
7425 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7426 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7430 init_dwarf_regnames_iamcu (void)
7432 dwarf_regnames
= dwarf_regnames_iamcu
;
7433 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7434 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7437 static const char *const dwarf_regnames_x86_64
[] =
7439 "rax", "rdx", "rcx", "rbx",
7440 "rsi", "rdi", "rbp", "rsp",
7441 "r8", "r9", "r10", "r11",
7442 "r12", "r13", "r14", "r15",
7444 "xmm0", "xmm1", "xmm2", "xmm3",
7445 "xmm4", "xmm5", "xmm6", "xmm7",
7446 "xmm8", "xmm9", "xmm10", "xmm11",
7447 "xmm12", "xmm13", "xmm14", "xmm15",
7448 "st0", "st1", "st2", "st3",
7449 "st4", "st5", "st6", "st7",
7450 "mm0", "mm1", "mm2", "mm3",
7451 "mm4", "mm5", "mm6", "mm7",
7453 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7454 "fs.base", "gs.base", NULL
, NULL
,
7456 "mxcsr", "fcw", "fsw",
7457 "xmm16", "xmm17", "xmm18", "xmm19",
7458 "xmm20", "xmm21", "xmm22", "xmm23",
7459 "xmm24", "xmm25", "xmm26", "xmm27",
7460 "xmm28", "xmm29", "xmm30", "xmm31",
7461 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7462 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7463 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7464 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7465 NULL
, NULL
, NULL
, /* 115 - 117 */
7466 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7470 init_dwarf_regnames_x86_64 (void)
7472 dwarf_regnames
= dwarf_regnames_x86_64
;
7473 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7474 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7477 static const char *const dwarf_regnames_aarch64
[] =
7479 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7480 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7481 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7482 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7483 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7484 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7485 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7486 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7487 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7488 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7489 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7490 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7491 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7492 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7493 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7494 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7498 init_dwarf_regnames_aarch64 (void)
7500 dwarf_regnames
= dwarf_regnames_aarch64
;
7501 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7502 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7505 static const char *const dwarf_regnames_s390
[] =
7507 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7508 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7509 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7510 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7511 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7512 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7513 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7514 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7515 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7518 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7519 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7523 init_dwarf_regnames_s390 (void)
7525 dwarf_regnames
= dwarf_regnames_s390
;
7526 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7527 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7530 static const char *const dwarf_regnames_riscv
[] =
7532 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7533 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7534 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7535 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7536 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7537 "fs0", "fs1", /* 40 - 41 */
7538 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7539 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7540 "fs10", "fs11", /* 58 - 59 */
7541 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7544 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7545 the large number of CSRs. */
7548 regname_internal_riscv (unsigned int regno
)
7550 const char *name
= NULL
;
7552 /* Lookup in the table first, this covers GPR and FPR. */
7553 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7554 name
= dwarf_regnames_riscv
[regno
];
7555 else if (regno
>= 4096 && regno
<= 8191)
7557 /* This might be a CSR, these live in a sparse number space from 4096
7558 to 8191 These numbers are defined in the RISC-V ELF ABI
7562 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
7563 case VALUE + 4096: name = #NAME; break;
7564 #include "opcode/riscv-opc.h"
7569 static char csr_name
[10];
7570 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7581 init_dwarf_regnames_riscv (void)
7583 dwarf_regnames
= NULL
;
7584 dwarf_regnames_count
= 8192;
7585 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7589 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7591 dwarf_regnames_lookup_func
= NULL
;
7596 init_dwarf_regnames_i386 ();
7600 init_dwarf_regnames_iamcu ();
7606 init_dwarf_regnames_x86_64 ();
7610 init_dwarf_regnames_aarch64 ();
7614 init_dwarf_regnames_s390 ();
7618 init_dwarf_regnames_riscv ();
7626 /* Initialize the DWARF register name lookup state based on the
7627 architecture and specific machine type of a BFD. */
7630 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7633 dwarf_regnames_lookup_func
= NULL
;
7640 case bfd_mach_x86_64
:
7641 case bfd_mach_x86_64_intel_syntax
:
7642 case bfd_mach_x64_32
:
7643 case bfd_mach_x64_32_intel_syntax
:
7644 init_dwarf_regnames_x86_64 ();
7648 init_dwarf_regnames_i386 ();
7653 case bfd_arch_iamcu
:
7654 init_dwarf_regnames_iamcu ();
7657 case bfd_arch_aarch64
:
7658 init_dwarf_regnames_aarch64();
7662 init_dwarf_regnames_s390 ();
7665 case bfd_arch_riscv
:
7666 init_dwarf_regnames_riscv ();
7675 regname_internal_by_table_only (unsigned int regno
)
7677 if (dwarf_regnames
!= NULL
7678 && regno
< dwarf_regnames_count
7679 && dwarf_regnames
[regno
] != NULL
)
7680 return dwarf_regnames
[regno
];
7686 regname (unsigned int regno
, int name_only_p
)
7688 static char reg
[64];
7690 const char *name
= NULL
;
7692 if (dwarf_regnames_lookup_func
!= NULL
)
7693 name
= dwarf_regnames_lookup_func (regno
);
7699 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7702 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7707 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7712 if (*max_regs
!= fc
->ncols
)
7713 *max_regs
= fc
->ncols
;
7715 if (*need_col_headers
)
7717 static const char *sloc
= " LOC";
7719 *need_col_headers
= 0;
7721 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7723 for (r
= 0; r
< *max_regs
; r
++)
7724 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7729 printf ("%-5s ", regname (r
, 1));
7735 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7737 strcpy (tmp
, "exp");
7739 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7740 printf ("%-8s ", tmp
);
7742 for (r
= 0; r
< fc
->ncols
; r
++)
7744 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7746 switch (fc
->col_type
[r
])
7748 case DW_CFA_undefined
:
7751 case DW_CFA_same_value
:
7755 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7757 case DW_CFA_val_offset
:
7758 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7760 case DW_CFA_register
:
7761 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7763 case DW_CFA_expression
:
7764 strcpy (tmp
, "exp");
7766 case DW_CFA_val_expression
:
7767 strcpy (tmp
, "vexp");
7770 strcpy (tmp
, "n/a");
7773 printf ("%-5s ", tmp
);
7779 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7781 static unsigned char *
7782 read_cie (unsigned char *start
, unsigned char *end
,
7783 Frame_Chunk
**p_cie
, int *p_version
,
7784 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7788 unsigned char *augmentation_data
= NULL
;
7789 bfd_size_type augmentation_data_len
= 0;
7792 /* PR 17512: file: 001-228113-0.004. */
7796 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7797 memset (fc
, 0, sizeof (Frame_Chunk
));
7799 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7800 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7804 fc
->augmentation
= (char *) start
;
7805 /* PR 17512: file: 001-228113-0.004.
7806 Skip past augmentation name, but avoid running off the end of the data. */
7808 if (* start
++ == '\0')
7812 warn (_("No terminator for augmentation name\n"));
7816 if (strcmp (fc
->augmentation
, "eh") == 0)
7817 start
+= eh_addr_size
;
7821 GET (fc
->ptr_size
, 1);
7822 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7824 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7828 GET (fc
->segment_size
, 1);
7829 /* PR 17512: file: e99d2804. */
7830 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7832 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7836 eh_addr_size
= fc
->ptr_size
;
7840 fc
->ptr_size
= eh_addr_size
;
7841 fc
->segment_size
= 0;
7844 READ_ULEB (fc
->code_factor
, start
, end
);
7845 READ_SLEB (fc
->data_factor
, start
, end
);
7853 READ_ULEB (fc
->ra
, start
, end
);
7856 if (fc
->augmentation
[0] == 'z')
7858 READ_ULEB (augmentation_data_len
, start
, end
);
7859 augmentation_data
= start
;
7860 /* PR 17512: file: 11042-2589-0.004. */
7861 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7863 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7864 dwarf_vmatoa ("x", augmentation_data_len
),
7865 (unsigned long) (end
- start
));
7868 start
+= augmentation_data_len
;
7871 if (augmentation_data_len
)
7875 unsigned char *qend
;
7877 p
= (unsigned char *) fc
->augmentation
+ 1;
7878 q
= augmentation_data
;
7879 qend
= q
+ augmentation_data_len
;
7881 while (p
< end
&& q
< qend
)
7886 q
+= 1 + size_of_encoded_value (*q
);
7888 fc
->fde_encoding
= *q
++;
7897 /* Note - it is OK if this loop terminates with q < qend.
7898 Padding may have been inserted to align the end of the CIE. */
7903 *p_version
= version
;
7906 *p_aug_len
= augmentation_data_len
;
7907 *p_aug
= augmentation_data
;
7912 free (fc
->col_offset
);
7913 free (fc
->col_type
);
7918 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7919 If do_wide is not enabled, then formats the output to fit into 80 columns.
7920 PRINTED contains the number of characters already written to the current
7924 display_data (bfd_size_type printed
,
7925 const unsigned char * data
,
7926 const bfd_size_type len
)
7928 if (do_wide
|| len
< ((80 - printed
) / 3))
7929 for (printed
= 0; printed
< len
; ++printed
)
7930 printf (" %02x", data
[printed
]);
7933 for (printed
= 0; printed
< len
; ++printed
)
7935 if (printed
% (80 / 3) == 0)
7937 printf (" %02x", data
[printed
]);
7942 /* Prints out the contents on the augmentation data array.
7943 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7946 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7950 i
= printf (_(" Augmentation data: "));
7951 display_data (i
, data
, len
);
7955 display_debug_frames (struct dwarf_section
*section
,
7956 void *file ATTRIBUTE_UNUSED
)
7958 unsigned char *start
= section
->start
;
7959 unsigned char *end
= start
+ section
->size
;
7960 unsigned char *section_start
= start
;
7961 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7962 Frame_Chunk
*remembered_state
= NULL
;
7964 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7965 unsigned int max_regs
= 0;
7966 const char *bad_reg
= _("bad register: ");
7967 unsigned int saved_eh_addr_size
= eh_addr_size
;
7969 introduce (section
, FALSE
);
7973 unsigned char *saved_start
;
7974 unsigned char *block_end
;
7979 int need_col_headers
= 1;
7980 unsigned char *augmentation_data
= NULL
;
7981 bfd_size_type augmentation_data_len
= 0;
7982 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7983 unsigned int offset_size
;
7984 unsigned int initial_length_size
;
7985 bfd_boolean all_nops
;
7986 static Frame_Chunk fde_fc
;
7988 saved_start
= start
;
7990 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7994 printf ("\n%08lx ZERO terminator\n\n",
7995 (unsigned long)(saved_start
- section_start
));
7996 /* Skip any zero terminators that directly follow.
7997 A corrupt section size could have loaded a whole
7998 slew of zero filled memory bytes. eg
7999 PR 17512: file: 070-19381-0.004. */
8000 while (start
< end
&& * start
== 0)
8005 if (length
== 0xffffffff)
8007 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8009 initial_length_size
= 12;
8014 initial_length_size
= 4;
8017 block_end
= saved_start
+ length
+ initial_length_size
;
8018 if (block_end
> end
|| block_end
< start
)
8020 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8021 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8022 (unsigned long) (saved_start
- section_start
));
8026 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8028 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8029 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8034 start
= read_cie (start
, end
, &cie
, &version
,
8035 &augmentation_data_len
, &augmentation_data
);
8036 /* PR 17512: file: 027-135133-0.005. */
8043 fc
->chunk_start
= saved_start
;
8044 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8047 if (frame_need_space (fc
, mreg
) < 0)
8049 if (fc
->fde_encoding
)
8050 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8052 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8053 print_dwarf_vma (length
, fc
->ptr_size
);
8054 print_dwarf_vma (cie_id
, offset_size
);
8056 if (do_debug_frames_interp
)
8058 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8059 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8064 printf (" Version: %d\n", version
);
8065 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8068 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8069 printf (" Segment Size: %u\n", fc
->segment_size
);
8071 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8072 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8073 printf (" Return address column: %d\n", fc
->ra
);
8075 if (augmentation_data_len
)
8076 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8083 unsigned char *look_for
;
8084 unsigned long segment_selector
;
8088 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8089 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8092 look_for
= section_start
+ cie_id
;
8094 if (look_for
<= saved_start
)
8096 for (cie
= chunks
; cie
; cie
= cie
->next
)
8097 if (cie
->chunk_start
== look_for
)
8102 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8103 if (cie
->chunk_start
== look_for
)
8107 unsigned int off_size
;
8108 unsigned char *cie_scan
;
8110 cie_scan
= look_for
;
8112 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8113 if (length
== 0xffffffff)
8115 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8122 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8125 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8126 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8131 read_cie (cie_scan
, end
, &cie
, &version
,
8132 &augmentation_data_len
, &augmentation_data
);
8133 /* PR 17512: file: 3450-2098-0.004. */
8136 warn (_("Failed to read CIE information\n"));
8139 cie
->next
= forward_refs
;
8141 cie
->chunk_start
= look_for
;
8142 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8145 if (frame_need_space (cie
, mreg
) < 0)
8147 warn (_("Invalid max register\n"));
8150 if (cie
->fde_encoding
)
8152 = size_of_encoded_value (cie
->fde_encoding
);
8159 memset (fc
, 0, sizeof (Frame_Chunk
));
8163 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8164 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8165 (unsigned long) (saved_start
- section_start
));
8167 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8168 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8169 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8171 warn (_("Invalid max register\n"));
8175 fc
->augmentation
= "";
8176 fc
->fde_encoding
= 0;
8177 fc
->ptr_size
= eh_addr_size
;
8178 fc
->segment_size
= 0;
8182 fc
->ncols
= cie
->ncols
;
8183 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8184 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8185 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8186 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8187 fc
->augmentation
= cie
->augmentation
;
8188 fc
->ptr_size
= cie
->ptr_size
;
8189 eh_addr_size
= cie
->ptr_size
;
8190 fc
->segment_size
= cie
->segment_size
;
8191 fc
->code_factor
= cie
->code_factor
;
8192 fc
->data_factor
= cie
->data_factor
;
8193 fc
->cfa_reg
= cie
->cfa_reg
;
8194 fc
->cfa_offset
= cie
->cfa_offset
;
8196 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8198 warn (_("Invalid max register\n"));
8201 fc
->fde_encoding
= cie
->fde_encoding
;
8204 if (fc
->fde_encoding
)
8205 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8207 segment_selector
= 0;
8208 if (fc
->segment_size
)
8210 if (fc
->segment_size
> sizeof (segment_selector
))
8212 /* PR 17512: file: 9e196b3e. */
8213 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8214 fc
->segment_size
= 4;
8216 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8219 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8221 /* FIXME: It appears that sometimes the final pc_range value is
8222 encoded in less than encoded_ptr_size bytes. See the x86_64
8223 run of the "objcopy on compressed debug sections" test for an
8225 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8227 if (cie
->augmentation
[0] == 'z')
8229 READ_ULEB (augmentation_data_len
, start
, end
);
8230 augmentation_data
= start
;
8231 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8232 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8234 warn (_("Augmentation data too long: 0x%s, "
8235 "expected at most %#lx\n"),
8236 dwarf_vmatoa ("x", augmentation_data_len
),
8237 (unsigned long) (end
- start
));
8239 augmentation_data
= NULL
;
8240 augmentation_data_len
= 0;
8242 start
+= augmentation_data_len
;
8245 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8246 (unsigned long)(saved_start
- section_start
),
8247 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8248 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8249 (unsigned long)(cie
->chunk_start
- section_start
));
8251 if (fc
->segment_size
)
8252 printf ("%04lx:", segment_selector
);
8255 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8256 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8258 if (! do_debug_frames_interp
&& augmentation_data_len
)
8260 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8265 /* At this point, fc is the current chunk, cie (if any) is set, and
8266 we're about to interpret instructions for the chunk. */
8267 /* ??? At present we need to do this always, since this sizes the
8268 fc->col_type and fc->col_offset arrays, which we write into always.
8269 We should probably split the interpreted and non-interpreted bits
8270 into two different routines, since there's so much that doesn't
8271 really overlap between them. */
8272 if (1 || do_debug_frames_interp
)
8274 /* Start by making a pass over the chunk, allocating storage
8275 and taking note of what registers are used. */
8276 unsigned char *tmp
= start
;
8278 while (start
< block_end
)
8280 unsigned int reg
, op
, opa
;
8282 unsigned char * new_start
;
8289 /* Warning: if you add any more cases to this switch, be
8290 sure to add them to the corresponding switch below. */
8293 case DW_CFA_advance_loc
:
8296 SKIP_ULEB (start
, end
);
8297 if (frame_need_space (fc
, opa
) >= 0)
8298 fc
->col_type
[opa
] = DW_CFA_undefined
;
8300 case DW_CFA_restore
:
8301 if (frame_need_space (fc
, opa
) >= 0)
8302 fc
->col_type
[opa
] = DW_CFA_undefined
;
8304 case DW_CFA_set_loc
:
8305 start
+= encoded_ptr_size
;
8307 case DW_CFA_advance_loc1
:
8310 case DW_CFA_advance_loc2
:
8313 case DW_CFA_advance_loc4
:
8316 case DW_CFA_offset_extended
:
8317 case DW_CFA_val_offset
:
8318 READ_ULEB (reg
, start
, end
);
8319 SKIP_ULEB (start
, end
);
8320 if (frame_need_space (fc
, reg
) >= 0)
8321 fc
->col_type
[reg
] = DW_CFA_undefined
;
8323 case DW_CFA_restore_extended
:
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_undefined
:
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_same_value
:
8334 READ_ULEB (reg
, start
, end
);
8335 if (frame_need_space (fc
, reg
) >= 0)
8336 fc
->col_type
[reg
] = DW_CFA_undefined
;
8338 case DW_CFA_register
:
8339 READ_ULEB (reg
, start
, end
);
8340 SKIP_ULEB (start
, end
);
8341 if (frame_need_space (fc
, reg
) >= 0)
8342 fc
->col_type
[reg
] = DW_CFA_undefined
;
8344 case DW_CFA_def_cfa
:
8345 SKIP_ULEB (start
, end
);
8346 SKIP_ULEB (start
, end
);
8348 case DW_CFA_def_cfa_register
:
8349 SKIP_ULEB (start
, end
);
8351 case DW_CFA_def_cfa_offset
:
8352 SKIP_ULEB (start
, end
);
8354 case DW_CFA_def_cfa_expression
:
8355 READ_ULEB (temp
, start
, end
);
8356 new_start
= start
+ temp
;
8357 if (new_start
< start
)
8359 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8365 case DW_CFA_expression
:
8366 case DW_CFA_val_expression
:
8367 READ_ULEB (reg
, start
, end
);
8368 READ_ULEB (temp
, start
, end
);
8369 new_start
= start
+ temp
;
8370 if (new_start
< start
)
8372 /* PR 17512: file:306-192417-0.005. */
8373 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8378 if (frame_need_space (fc
, reg
) >= 0)
8379 fc
->col_type
[reg
] = DW_CFA_undefined
;
8381 case DW_CFA_offset_extended_sf
:
8382 case DW_CFA_val_offset_sf
:
8383 READ_ULEB (reg
, start
, end
);
8384 SKIP_SLEB (start
, end
);
8385 if (frame_need_space (fc
, reg
) >= 0)
8386 fc
->col_type
[reg
] = DW_CFA_undefined
;
8388 case DW_CFA_def_cfa_sf
:
8389 SKIP_ULEB (start
, end
);
8390 SKIP_SLEB (start
, end
);
8392 case DW_CFA_def_cfa_offset_sf
:
8393 SKIP_SLEB (start
, end
);
8395 case DW_CFA_MIPS_advance_loc8
:
8398 case DW_CFA_GNU_args_size
:
8399 SKIP_ULEB (start
, end
);
8401 case DW_CFA_GNU_negative_offset_extended
:
8402 READ_ULEB (reg
, start
, end
);
8403 SKIP_ULEB (start
, end
);
8404 if (frame_need_space (fc
, reg
) >= 0)
8405 fc
->col_type
[reg
] = DW_CFA_undefined
;
8416 /* Now we know what registers are used, make a second pass over
8417 the chunk, this time actually printing out the info. */
8419 while (start
< block_end
)
8421 unsigned char * tmp
;
8423 unsigned long ul
, roffs
;
8424 /* Note: It is tempting to use an unsigned long for 'reg' but there
8425 are various functions, notably frame_space_needed() that assume that
8426 reg is an unsigned int. */
8431 const char *reg_prefix
= "";
8438 /* Make a note if something other than DW_CFA_nop happens. */
8439 if (op
!= DW_CFA_nop
)
8442 /* Warning: if you add any more cases to this switch, be
8443 sure to add them to the corresponding switch above. */
8446 case DW_CFA_advance_loc
:
8447 if (do_debug_frames_interp
)
8448 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8450 printf (" DW_CFA_advance_loc: %d to %s\n",
8451 opa
* fc
->code_factor
,
8452 dwarf_vmatoa_1 (NULL
,
8453 fc
->pc_begin
+ opa
* fc
->code_factor
,
8455 fc
->pc_begin
+= opa
* fc
->code_factor
;
8459 READ_ULEB (roffs
, start
, end
);
8460 if (opa
>= (unsigned int) fc
->ncols
)
8461 reg_prefix
= bad_reg
;
8462 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8463 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8464 reg_prefix
, regname (opa
, 0),
8465 roffs
* fc
->data_factor
);
8466 if (*reg_prefix
== '\0')
8468 fc
->col_type
[opa
] = DW_CFA_offset
;
8469 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8473 case DW_CFA_restore
:
8474 if (opa
>= (unsigned int) fc
->ncols
)
8475 reg_prefix
= bad_reg
;
8476 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8477 printf (" DW_CFA_restore: %s%s\n",
8478 reg_prefix
, regname (opa
, 0));
8479 if (*reg_prefix
!= '\0')
8482 if (opa
>= (unsigned int) cie
->ncols
8483 || (do_debug_frames_interp
8484 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8486 fc
->col_type
[opa
] = DW_CFA_undefined
;
8487 fc
->col_offset
[opa
] = 0;
8491 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8492 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8496 case DW_CFA_set_loc
:
8497 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8498 if (do_debug_frames_interp
)
8499 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8501 printf (" DW_CFA_set_loc: %s\n",
8502 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8506 case DW_CFA_advance_loc1
:
8507 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8508 if (do_debug_frames_interp
)
8509 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8511 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8512 (unsigned long) (ofs
* fc
->code_factor
),
8513 dwarf_vmatoa_1 (NULL
,
8514 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8516 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8519 case DW_CFA_advance_loc2
:
8520 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8521 if (do_debug_frames_interp
)
8522 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8524 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8525 (unsigned long) (ofs
* fc
->code_factor
),
8526 dwarf_vmatoa_1 (NULL
,
8527 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8529 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8532 case DW_CFA_advance_loc4
:
8533 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8534 if (do_debug_frames_interp
)
8535 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8537 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8538 (unsigned long) (ofs
* fc
->code_factor
),
8539 dwarf_vmatoa_1 (NULL
,
8540 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8542 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8545 case DW_CFA_offset_extended
:
8546 READ_ULEB (reg
, start
, end
);
8547 READ_ULEB (roffs
, start
, end
);
8548 if (reg
>= (unsigned int) fc
->ncols
)
8549 reg_prefix
= bad_reg
;
8550 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8551 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8552 reg_prefix
, regname (reg
, 0),
8553 roffs
* fc
->data_factor
);
8554 if (*reg_prefix
== '\0')
8556 fc
->col_type
[reg
] = DW_CFA_offset
;
8557 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8561 case DW_CFA_val_offset
:
8562 READ_ULEB (reg
, start
, end
);
8563 READ_ULEB (roffs
, start
, end
);
8564 if (reg
>= (unsigned int) fc
->ncols
)
8565 reg_prefix
= bad_reg
;
8566 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8567 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8568 reg_prefix
, regname (reg
, 0),
8569 roffs
* fc
->data_factor
);
8570 if (*reg_prefix
== '\0')
8572 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8573 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8577 case DW_CFA_restore_extended
:
8578 READ_ULEB (reg
, start
, end
);
8579 if (reg
>= (unsigned int) fc
->ncols
)
8580 reg_prefix
= bad_reg
;
8581 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8582 printf (" DW_CFA_restore_extended: %s%s\n",
8583 reg_prefix
, regname (reg
, 0));
8584 if (*reg_prefix
!= '\0')
8587 if (reg
>= (unsigned int) cie
->ncols
)
8589 fc
->col_type
[reg
] = DW_CFA_undefined
;
8590 fc
->col_offset
[reg
] = 0;
8594 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8595 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8599 case DW_CFA_undefined
:
8600 READ_ULEB (reg
, start
, end
);
8601 if (reg
>= (unsigned int) fc
->ncols
)
8602 reg_prefix
= bad_reg
;
8603 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8604 printf (" DW_CFA_undefined: %s%s\n",
8605 reg_prefix
, regname (reg
, 0));
8606 if (*reg_prefix
== '\0')
8608 fc
->col_type
[reg
] = DW_CFA_undefined
;
8609 fc
->col_offset
[reg
] = 0;
8613 case DW_CFA_same_value
:
8614 READ_ULEB (reg
, start
, end
);
8615 if (reg
>= (unsigned int) fc
->ncols
)
8616 reg_prefix
= bad_reg
;
8617 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8618 printf (" DW_CFA_same_value: %s%s\n",
8619 reg_prefix
, regname (reg
, 0));
8620 if (*reg_prefix
== '\0')
8622 fc
->col_type
[reg
] = DW_CFA_same_value
;
8623 fc
->col_offset
[reg
] = 0;
8627 case DW_CFA_register
:
8628 READ_ULEB (reg
, start
, end
);
8629 READ_ULEB (roffs
, start
, end
);
8630 if (reg
>= (unsigned int) fc
->ncols
)
8631 reg_prefix
= bad_reg
;
8632 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8634 printf (" DW_CFA_register: %s%s in ",
8635 reg_prefix
, regname (reg
, 0));
8636 puts (regname (roffs
, 0));
8638 if (*reg_prefix
== '\0')
8640 fc
->col_type
[reg
] = DW_CFA_register
;
8641 fc
->col_offset
[reg
] = roffs
;
8645 case DW_CFA_remember_state
:
8646 if (! do_debug_frames_interp
)
8647 printf (" DW_CFA_remember_state\n");
8648 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8649 rs
->cfa_offset
= fc
->cfa_offset
;
8650 rs
->cfa_reg
= fc
->cfa_reg
;
8652 rs
->cfa_exp
= fc
->cfa_exp
;
8653 rs
->ncols
= fc
->ncols
;
8654 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8655 sizeof (* rs
->col_type
));
8656 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8657 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8658 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8659 rs
->next
= remembered_state
;
8660 remembered_state
= rs
;
8663 case DW_CFA_restore_state
:
8664 if (! do_debug_frames_interp
)
8665 printf (" DW_CFA_restore_state\n");
8666 rs
= remembered_state
;
8669 remembered_state
= rs
->next
;
8670 fc
->cfa_offset
= rs
->cfa_offset
;
8671 fc
->cfa_reg
= rs
->cfa_reg
;
8673 fc
->cfa_exp
= rs
->cfa_exp
;
8674 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8676 warn (_("Invalid column number in saved frame state\n"));
8680 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8681 memcpy (fc
->col_offset
, rs
->col_offset
,
8682 rs
->ncols
* sizeof (* rs
->col_offset
));
8683 free (rs
->col_type
);
8684 free (rs
->col_offset
);
8687 else if (do_debug_frames_interp
)
8688 printf ("Mismatched DW_CFA_restore_state\n");
8691 case DW_CFA_def_cfa
:
8692 READ_ULEB (fc
->cfa_reg
, start
, end
);
8693 READ_ULEB (fc
->cfa_offset
, start
, end
);
8695 if (! do_debug_frames_interp
)
8696 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8697 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8700 case DW_CFA_def_cfa_register
:
8701 READ_ULEB (fc
->cfa_reg
, start
, end
);
8703 if (! do_debug_frames_interp
)
8704 printf (" DW_CFA_def_cfa_register: %s\n",
8705 regname (fc
->cfa_reg
, 0));
8708 case DW_CFA_def_cfa_offset
:
8709 READ_ULEB (fc
->cfa_offset
, start
, end
);
8710 if (! do_debug_frames_interp
)
8711 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8715 if (! do_debug_frames_interp
)
8716 printf (" DW_CFA_nop\n");
8719 case DW_CFA_def_cfa_expression
:
8720 READ_ULEB (ul
, start
, end
);
8721 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8723 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8726 if (! do_debug_frames_interp
)
8728 printf (" DW_CFA_def_cfa_expression (");
8729 decode_location_expression (start
, eh_addr_size
, 0, -1,
8737 case DW_CFA_expression
:
8738 READ_ULEB (reg
, start
, end
);
8739 READ_ULEB (ul
, start
, end
);
8740 if (reg
>= (unsigned int) fc
->ncols
)
8741 reg_prefix
= bad_reg
;
8742 /* PR 17512: file: 069-133014-0.006. */
8743 /* PR 17512: file: 98c02eb4. */
8745 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8747 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8750 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8752 printf (" DW_CFA_expression: %s%s (",
8753 reg_prefix
, regname (reg
, 0));
8754 decode_location_expression (start
, eh_addr_size
, 0, -1,
8758 if (*reg_prefix
== '\0')
8759 fc
->col_type
[reg
] = DW_CFA_expression
;
8763 case DW_CFA_val_expression
:
8764 READ_ULEB (reg
, start
, end
);
8765 READ_ULEB (ul
, start
, end
);
8766 if (reg
>= (unsigned int) fc
->ncols
)
8767 reg_prefix
= bad_reg
;
8769 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8771 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8774 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8776 printf (" DW_CFA_val_expression: %s%s (",
8777 reg_prefix
, regname (reg
, 0));
8778 decode_location_expression (start
, eh_addr_size
, 0, -1,
8782 if (*reg_prefix
== '\0')
8783 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8787 case DW_CFA_offset_extended_sf
:
8788 READ_ULEB (reg
, start
, end
);
8789 READ_SLEB (l
, start
, end
);
8790 if (frame_need_space (fc
, reg
) < 0)
8791 reg_prefix
= bad_reg
;
8792 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8793 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8794 reg_prefix
, regname (reg
, 0),
8795 (long)(l
* fc
->data_factor
));
8796 if (*reg_prefix
== '\0')
8798 fc
->col_type
[reg
] = DW_CFA_offset
;
8799 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8803 case DW_CFA_val_offset_sf
:
8804 READ_ULEB (reg
, start
, end
);
8805 READ_SLEB (l
, start
, end
);
8806 if (frame_need_space (fc
, reg
) < 0)
8807 reg_prefix
= bad_reg
;
8808 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8809 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8810 reg_prefix
, regname (reg
, 0),
8811 (long)(l
* fc
->data_factor
));
8812 if (*reg_prefix
== '\0')
8814 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8815 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8819 case DW_CFA_def_cfa_sf
:
8820 READ_ULEB (fc
->cfa_reg
, start
, end
);
8821 READ_ULEB (fc
->cfa_offset
, start
, end
);
8822 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8824 if (! do_debug_frames_interp
)
8825 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8826 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8829 case DW_CFA_def_cfa_offset_sf
:
8830 READ_ULEB (fc
->cfa_offset
, start
, end
);
8831 fc
->cfa_offset
*= fc
->data_factor
;
8832 if (! do_debug_frames_interp
)
8833 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8836 case DW_CFA_MIPS_advance_loc8
:
8837 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8838 if (do_debug_frames_interp
)
8839 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8841 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8842 (unsigned long) (ofs
* fc
->code_factor
),
8843 dwarf_vmatoa_1 (NULL
,
8844 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8846 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8849 case DW_CFA_GNU_window_save
:
8850 if (! do_debug_frames_interp
)
8851 printf (" DW_CFA_GNU_window_save\n");
8854 case DW_CFA_GNU_args_size
:
8855 READ_ULEB (ul
, start
, end
);
8856 if (! do_debug_frames_interp
)
8857 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8860 case DW_CFA_GNU_negative_offset_extended
:
8861 READ_ULEB (reg
, start
, end
);
8862 READ_SLEB (l
, start
, end
);
8864 if (frame_need_space (fc
, reg
) < 0)
8865 reg_prefix
= bad_reg
;
8866 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8867 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8868 reg_prefix
, regname (reg
, 0),
8869 (long)(l
* fc
->data_factor
));
8870 if (*reg_prefix
== '\0')
8872 fc
->col_type
[reg
] = DW_CFA_offset
;
8873 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8878 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8879 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8881 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8886 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8887 if (do_debug_frames_interp
&& ! all_nops
)
8888 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8890 if (fde_fc
.col_type
!= NULL
)
8892 free (fde_fc
.col_type
);
8893 fde_fc
.col_type
= NULL
;
8895 if (fde_fc
.col_offset
!= NULL
)
8897 free (fde_fc
.col_offset
);
8898 fde_fc
.col_offset
= NULL
;
8902 eh_addr_size
= saved_eh_addr_size
;
8907 while (remembered_state
!= NULL
)
8909 rs
= remembered_state
;
8910 remembered_state
= rs
->next
;
8911 free (rs
->col_type
);
8912 free (rs
->col_offset
);
8913 rs
->next
= NULL
; /* Paranoia. */
8917 while (chunks
!= NULL
)
8921 free (rs
->col_type
);
8922 free (rs
->col_offset
);
8923 rs
->next
= NULL
; /* Paranoia. */
8927 while (forward_refs
!= NULL
)
8930 forward_refs
= rs
->next
;
8931 free (rs
->col_type
);
8932 free (rs
->col_offset
);
8933 rs
->next
= NULL
; /* Paranoia. */
8943 display_debug_names (struct dwarf_section
*section
, void *file
)
8945 unsigned char *hdrptr
= section
->start
;
8946 dwarf_vma unit_length
;
8947 unsigned char *unit_start
;
8948 const unsigned char *const section_end
= section
->start
+ section
->size
;
8949 unsigned char *unit_end
;
8951 introduce (section
, FALSE
);
8953 load_debug_section_with_follow (str
, file
);
8955 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8957 unsigned int offset_size
;
8958 uint16_t dwarf_version
, padding
;
8959 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8960 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8961 uint32_t augmentation_string_size
;
8963 unsigned long sec_off
;
8964 bfd_boolean augmentation_printable
;
8965 const char *augmentation_string
;
8967 unit_start
= hdrptr
;
8969 /* Get and check the length of the block. */
8970 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8972 if (unit_length
== 0xffffffff)
8974 /* This section is 64-bit DWARF. */
8975 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8980 unit_end
= hdrptr
+ unit_length
;
8982 sec_off
= hdrptr
- section
->start
;
8983 if (sec_off
+ unit_length
< sec_off
8984 || sec_off
+ unit_length
> section
->size
)
8986 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8988 (unsigned long) (unit_start
- section
->start
),
8989 dwarf_vmatoa ("x", unit_length
));
8993 /* Get and check the version number. */
8994 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8995 printf (_("Version %ld\n"), (long) dwarf_version
);
8997 /* Prior versions did not exist, and future versions may not be
8998 backwards compatible. */
8999 if (dwarf_version
!= 5)
9001 warn (_("Only DWARF version 5 .debug_names "
9002 "is currently supported.\n"));
9006 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9008 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9011 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9012 if (comp_unit_count
== 0)
9013 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9015 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9016 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9017 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9018 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9019 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9021 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9022 if (augmentation_string_size
% 4 != 0)
9024 warn (_("Augmentation string length %u must be rounded up "
9025 "to a multiple of 4 in .debug_names.\n"),
9026 augmentation_string_size
);
9027 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9030 printf (_("Augmentation string:"));
9032 augmentation_printable
= TRUE
;
9033 augmentation_string
= (const char *) hdrptr
;
9035 for (i
= 0; i
< augmentation_string_size
; i
++)
9039 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9040 printf (" %02x", uc
);
9042 if (uc
!= 0 && !ISPRINT (uc
))
9043 augmentation_printable
= FALSE
;
9046 if (augmentation_printable
)
9050 i
< augmentation_string_size
&& augmentation_string
[i
];
9052 putchar (augmentation_string
[i
]);
9057 printf (_("CU table:\n"));
9058 for (i
= 0; i
< comp_unit_count
; i
++)
9062 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9063 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9067 printf (_("TU table:\n"));
9068 for (i
= 0; i
< local_type_unit_count
; i
++)
9072 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9073 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9077 printf (_("Foreign TU table:\n"));
9078 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9082 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9083 printf (_("[%3u] "), i
);
9084 print_dwarf_vma (signature
, 8);
9089 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9090 hdrptr
+= bucket_count
* sizeof (uint32_t);
9091 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9092 hdrptr
+= name_count
* sizeof (uint32_t);
9093 unsigned char *const name_table_string_offsets
= hdrptr
;
9094 hdrptr
+= name_count
* offset_size
;
9095 unsigned char *const name_table_entry_offsets
= hdrptr
;
9096 hdrptr
+= name_count
* offset_size
;
9097 unsigned char *const abbrev_table
= hdrptr
;
9098 hdrptr
+= abbrev_table_size
;
9099 const unsigned char *const abbrev_table_end
= hdrptr
;
9100 unsigned char *const entry_pool
= hdrptr
;
9101 if (hdrptr
> unit_end
)
9103 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9104 "for unit 0x%lx in the debug_names\n"),
9105 (long) (hdrptr
- section
->start
),
9106 (long) (unit_end
- section
->start
),
9107 (long) (unit_start
- section
->start
));
9111 size_t buckets_filled
= 0;
9113 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9115 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9120 printf (ngettext ("Used %zu of %lu bucket.\n",
9121 "Used %zu of %lu buckets.\n",
9123 buckets_filled
, (unsigned long) bucket_count
);
9125 uint32_t hash_prev
= 0;
9126 size_t hash_clash_count
= 0;
9127 size_t longest_clash
= 0;
9128 size_t this_length
= 0;
9130 for (hashi
= 0; hashi
< name_count
; hashi
++)
9132 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9136 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9140 longest_clash
= MAX (longest_clash
, this_length
);
9145 hash_prev
= hash_this
;
9147 printf (_("Out of %lu items there are %zu bucket clashes"
9148 " (longest of %zu entries).\n"),
9149 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9150 assert (name_count
== buckets_filled
+ hash_clash_count
);
9152 struct abbrev_lookup_entry
9154 dwarf_vma abbrev_tag
;
9155 unsigned char *abbrev_lookup_ptr
;
9157 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9158 size_t abbrev_lookup_used
= 0;
9159 size_t abbrev_lookup_allocated
= 0;
9161 unsigned char *abbrevptr
= abbrev_table
;
9164 dwarf_vma abbrev_tag
;
9166 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9167 if (abbrev_tag
== 0)
9169 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9171 abbrev_lookup_allocated
= MAX (0x100,
9172 abbrev_lookup_allocated
* 2);
9173 abbrev_lookup
= xrealloc (abbrev_lookup
,
9174 (abbrev_lookup_allocated
9175 * sizeof (*abbrev_lookup
)));
9177 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9178 struct abbrev_lookup_entry
*entry
;
9179 for (entry
= abbrev_lookup
;
9180 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9182 if (entry
->abbrev_tag
== abbrev_tag
)
9184 warn (_("Duplicate abbreviation tag %lu "
9185 "in unit 0x%lx in the debug_names\n"),
9186 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9189 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9190 entry
->abbrev_tag
= abbrev_tag
;
9191 entry
->abbrev_lookup_ptr
= abbrevptr
;
9193 /* Skip DWARF tag. */
9194 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9197 dwarf_vma xindex
, form
;
9199 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9200 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9201 if (xindex
== 0 && form
== 0)
9206 printf (_("\nSymbol table:\n"));
9208 for (namei
= 0; namei
< name_count
; ++namei
)
9210 uint64_t string_offset
, entry_offset
;
9212 SAFE_BYTE_GET (string_offset
,
9213 name_table_string_offsets
+ namei
* offset_size
,
9214 offset_size
, unit_end
);
9215 SAFE_BYTE_GET (entry_offset
,
9216 name_table_entry_offsets
+ namei
* offset_size
,
9217 offset_size
, unit_end
);
9219 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9220 fetch_indirect_string (string_offset
));
9222 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9224 /* We need to scan first whether there is a single or multiple
9225 entries. TAGNO is -2 for the first entry, it is -1 for the
9226 initial tag read of the second entry, then it becomes 0 for the
9227 first entry for real printing etc. */
9229 /* Initialize it due to a false compiler warning. */
9230 dwarf_vma second_abbrev_tag
= -1;
9233 dwarf_vma abbrev_tag
;
9234 dwarf_vma dwarf_tag
;
9235 const struct abbrev_lookup_entry
*entry
;
9237 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9240 second_abbrev_tag
= abbrev_tag
;
9242 entryptr
= entry_pool
+ entry_offset
;
9245 if (abbrev_tag
== 0)
9249 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9250 (unsigned long) abbrev_tag
);
9252 for (entry
= abbrev_lookup
;
9253 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9255 if (entry
->abbrev_tag
== abbrev_tag
)
9257 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9259 warn (_("Undefined abbreviation tag %lu "
9260 "in unit 0x%lx in the debug_names\n"),
9262 (long) (unit_start
- section
->start
));
9265 abbrevptr
= entry
->abbrev_lookup_ptr
;
9266 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9268 printf (" %s", get_TAG_name (dwarf_tag
));
9271 dwarf_vma xindex
, form
;
9273 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9274 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9275 if (xindex
== 0 && form
== 0)
9279 printf (" %s", get_IDX_name (xindex
));
9280 entryptr
= read_and_display_attr_value (0, form
, 0,
9281 unit_start
, entryptr
, unit_end
,
9283 dwarf_version
, NULL
,
9290 printf (_(" <no entries>"));
9294 free (abbrev_lookup
);
9301 display_debug_links (struct dwarf_section
* section
,
9302 void * file ATTRIBUTE_UNUSED
)
9304 const unsigned char * filename
;
9305 unsigned int filelen
;
9307 introduce (section
, FALSE
);
9309 /* The .gnu_debuglink section is formatted as:
9310 (c-string) Filename.
9311 (padding) If needed to reach a 4 byte boundary.
9312 (uint32_t) CRC32 value.
9314 The .gun_debugaltlink section is formatted as:
9315 (c-string) Filename.
9316 (binary) Build-ID. */
9318 filename
= section
->start
;
9319 filelen
= strnlen ((const char *) filename
, section
->size
);
9320 if (filelen
== section
->size
)
9322 warn (_("The debuglink filename is corrupt/missing\n"));
9326 printf (_(" Separate debug info file: %s\n"), filename
);
9328 if (const_strneq (section
->name
, ".gnu_debuglink"))
9331 unsigned int crc_offset
;
9333 crc_offset
= filelen
+ 1;
9334 crc_offset
= (crc_offset
+ 3) & ~3;
9335 if (crc_offset
+ 4 > section
->size
)
9337 warn (_("CRC offset missing/truncated\n"));
9341 crc32
= byte_get (filename
+ crc_offset
, 4);
9343 printf (_(" CRC value: %#x\n"), crc32
);
9345 if (crc_offset
+ 4 < section
->size
)
9347 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9348 (long)(section
->size
- (crc_offset
+ 4)));
9352 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9354 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9355 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9356 bfd_size_type printed
;
9358 /* FIXME: Should we support smaller build-id notes ? */
9359 if (build_id_len
< 0x14)
9361 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9365 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9366 display_data (printed
, build_id
, build_id_len
);
9375 display_gdb_index (struct dwarf_section
*section
,
9376 void *file ATTRIBUTE_UNUSED
)
9378 unsigned char *start
= section
->start
;
9380 uint32_t cu_list_offset
, tu_list_offset
;
9381 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9382 unsigned int cu_list_elements
, tu_list_elements
;
9383 unsigned int address_table_size
, symbol_table_slots
;
9384 unsigned char *cu_list
, *tu_list
;
9385 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9388 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9390 introduce (section
, FALSE
);
9392 if (section
->size
< 6 * sizeof (uint32_t))
9394 warn (_("Truncated header in the %s section.\n"), section
->name
);
9398 version
= byte_get_little_endian (start
, 4);
9399 printf (_("Version %ld\n"), (long) version
);
9401 /* Prior versions are obsolete, and future versions may not be
9402 backwards compatible. */
9403 if (version
< 3 || version
> 8)
9405 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9409 warn (_("The address table data in version 3 may be wrong.\n"));
9411 warn (_("Version 4 does not support case insensitive lookups.\n"));
9413 warn (_("Version 5 does not include inlined functions.\n"));
9415 warn (_("Version 6 does not include symbol attributes.\n"));
9416 /* Version 7 indices generated by Gold have bad type unit references,
9417 PR binutils/15021. But we don't know if the index was generated by
9418 Gold or not, so to avoid worrying users with gdb-generated indices
9419 we say nothing for version 7 here. */
9421 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9422 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9423 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9424 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9425 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9427 if (cu_list_offset
> section
->size
9428 || tu_list_offset
> section
->size
9429 || address_table_offset
> section
->size
9430 || symbol_table_offset
> section
->size
9431 || constant_pool_offset
> section
->size
)
9433 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9437 /* PR 17531: file: 418d0a8a. */
9438 if (tu_list_offset
< cu_list_offset
)
9440 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9441 tu_list_offset
, cu_list_offset
);
9445 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9447 if (address_table_offset
< tu_list_offset
)
9449 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9450 address_table_offset
, tu_list_offset
);
9454 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9456 /* PR 17531: file: 18a47d3d. */
9457 if (symbol_table_offset
< address_table_offset
)
9459 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9460 symbol_table_offset
, address_table_offset
);
9464 address_table_size
= symbol_table_offset
- address_table_offset
;
9466 if (constant_pool_offset
< symbol_table_offset
)
9468 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9469 constant_pool_offset
, symbol_table_offset
);
9473 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9475 cu_list
= start
+ cu_list_offset
;
9476 tu_list
= start
+ tu_list_offset
;
9477 address_table
= start
+ address_table_offset
;
9478 symbol_table
= start
+ symbol_table_offset
;
9479 constant_pool
= start
+ constant_pool_offset
;
9481 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9483 warn (_("Address table extends beyond end of section.\n"));
9487 printf (_("\nCU table:\n"));
9488 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9490 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9491 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9493 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9494 (unsigned long) cu_offset
,
9495 (unsigned long) (cu_offset
+ cu_length
- 1));
9498 printf (_("\nTU table:\n"));
9499 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9501 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9502 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9503 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9505 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9506 (unsigned long) tu_offset
,
9507 (unsigned long) type_offset
);
9508 print_dwarf_vma (signature
, 8);
9512 printf (_("\nAddress table:\n"));
9513 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9516 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9517 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9518 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9520 print_dwarf_vma (low
, 8);
9521 print_dwarf_vma (high
, 8);
9522 printf (_("%lu\n"), (unsigned long) cu_index
);
9525 printf (_("\nSymbol table:\n"));
9526 for (i
= 0; i
< symbol_table_slots
; ++i
)
9528 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9529 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9530 uint32_t num_cus
, cu
;
9532 if (name_offset
!= 0
9533 || cu_vector_offset
!= 0)
9536 unsigned char * adr
;
9538 adr
= constant_pool
+ name_offset
;
9539 /* PR 17531: file: 5b7b07ad. */
9540 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9542 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9543 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9547 printf ("[%3u] %.*s:", i
,
9548 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9549 constant_pool
+ name_offset
);
9551 adr
= constant_pool
+ cu_vector_offset
;
9552 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9554 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9555 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9556 cu_vector_offset
, i
);
9560 num_cus
= byte_get_little_endian (adr
, 4);
9562 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9563 if (num_cus
* 4 < num_cus
9564 || adr
>= section
->start
+ section
->size
9565 || adr
< constant_pool
)
9567 printf ("<invalid number of CUs: %d>\n", num_cus
);
9568 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9576 for (j
= 0; j
< num_cus
; ++j
)
9579 gdb_index_symbol_kind kind
;
9581 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9582 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9583 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9584 cu
= GDB_INDEX_CU_VALUE (cu
);
9585 /* Convert to TU number if it's for a type unit. */
9586 if (cu
>= cu_list_elements
/ 2)
9587 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9588 (unsigned long) (cu
- cu_list_elements
/ 2));
9590 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9592 printf (" [%s, %s]",
9593 is_static
? _("static") : _("global"),
9594 get_gdb_index_symbol_kind_name (kind
));
9606 /* Pre-allocate enough space for the CU/TU sets needed. */
9609 prealloc_cu_tu_list (unsigned int nshndx
)
9611 if (shndx_pool
== NULL
)
9613 shndx_pool_size
= nshndx
;
9614 shndx_pool_used
= 0;
9615 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9616 sizeof (unsigned int));
9620 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9621 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9622 sizeof (unsigned int));
9627 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9629 if (shndx_pool_used
>= shndx_pool_size
)
9631 error (_("Internal error: out of space in the shndx pool.\n"));
9634 shndx_pool
[shndx_pool_used
++] = shndx
;
9638 end_cu_tu_entry (void)
9640 if (shndx_pool_used
>= shndx_pool_size
)
9642 error (_("Internal error: out of space in the shndx pool.\n"));
9645 shndx_pool
[shndx_pool_used
++] = 0;
9648 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9651 get_DW_SECT_short_name (unsigned int dw_sect
)
9653 static char buf
[16];
9661 case DW_SECT_ABBREV
:
9667 case DW_SECT_STR_OFFSETS
:
9669 case DW_SECT_MACINFO
:
9677 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9681 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9682 These sections are extensions for Fission.
9683 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9686 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9688 unsigned char *phdr
= section
->start
;
9689 unsigned char *limit
= phdr
+ section
->size
;
9690 unsigned char *phash
;
9691 unsigned char *pindex
;
9692 unsigned char *ppool
;
9693 unsigned int version
;
9694 unsigned int ncols
= 0;
9696 unsigned int nslots
;
9699 dwarf_vma signature_high
;
9700 dwarf_vma signature_low
;
9703 /* PR 17512: file: 002-168123-0.004. */
9706 warn (_("Section %s is empty\n"), section
->name
);
9709 /* PR 17512: file: 002-376-0.004. */
9710 if (section
->size
< 24)
9712 warn (_("Section %s is too small to contain a CU/TU header\n"),
9717 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9719 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9720 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9721 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9724 pindex
= phash
+ (size_t) nslots
* 8;
9725 ppool
= pindex
+ (size_t) nslots
* 4;
9729 introduce (section
, FALSE
);
9731 printf (_(" Version: %u\n"), version
);
9733 printf (_(" Number of columns: %u\n"), ncols
);
9734 printf (_(" Number of used entries: %u\n"), nused
);
9735 printf (_(" Number of slots: %u\n\n"), nslots
);
9738 /* PR 17531: file: 45d69832. */
9739 if ((size_t) nslots
* 8 / 8 != nslots
9740 || phash
< phdr
|| phash
> limit
9741 || pindex
< phash
|| pindex
> limit
9742 || ppool
< pindex
|| ppool
> limit
)
9744 warn (ngettext ("Section %s is too small for %u slot\n",
9745 "Section %s is too small for %u slots\n",
9747 section
->name
, nslots
);
9754 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9755 for (i
= 0; i
< nslots
; i
++)
9757 unsigned char *shndx_list
;
9760 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9761 if (signature_high
!= 0 || signature_low
!= 0)
9763 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9764 shndx_list
= ppool
+ j
* 4;
9765 /* PR 17531: file: 705e010d. */
9766 if (shndx_list
< ppool
)
9768 warn (_("Section index pool located before start of section\n"));
9773 printf (_(" [%3d] Signature: 0x%s Sections: "),
9774 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9775 buf
, sizeof (buf
)));
9778 if (shndx_list
>= limit
)
9780 warn (_("Section %s too small for shndx pool\n"),
9784 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9788 printf (" %d", shndx
);
9790 add_shndx_to_cu_tu_entry (shndx
);
9802 else if (version
== 2)
9805 unsigned int dw_sect
;
9806 unsigned char *ph
= phash
;
9807 unsigned char *pi
= pindex
;
9808 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9809 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9810 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9811 bfd_boolean is_tu_index
;
9812 struct cu_tu_set
*this_set
= NULL
;
9814 unsigned char *prow
;
9816 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9818 /* PR 17531: file: 0dd159bf.
9819 Check for integer overflow (can occur when size_t is 32-bit)
9820 with overlarge ncols or nused values. */
9822 && ((size_t) ncols
* 4 / 4 != ncols
9823 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9824 || poffsets
< ppool
|| poffsets
> limit
9825 || psizes
< poffsets
|| psizes
> limit
9826 || pend
< psizes
|| pend
> limit
))
9828 warn (_("Section %s too small for offset and size tables\n"),
9835 printf (_(" Offset table\n"));
9836 printf (" slot %-16s ",
9837 is_tu_index
? _("signature") : _("dwo_id"));
9844 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9850 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9857 for (j
= 0; j
< ncols
; j
++)
9859 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9860 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9865 for (i
= 0; i
< nslots
; i
++)
9867 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9869 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9872 /* PR 17531: file: a05f6ab3. */
9875 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9882 size_t num_copy
= sizeof (uint64_t);
9884 /* PR 23064: Beware of buffer overflow. */
9885 if (ph
+ num_copy
< limit
)
9886 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9889 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9894 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9895 /* PR 17531: file: b8ce60a8. */
9896 if (prow
< poffsets
|| prow
> limit
)
9898 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9904 printf (_(" [%3d] 0x%s"),
9905 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9906 buf
, sizeof (buf
)));
9907 for (j
= 0; j
< ncols
; j
++)
9909 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9911 printf (" %8d", val
);
9914 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9916 /* PR 17531: file: 10796eb3. */
9917 if (dw_sect
>= DW_SECT_MAX
)
9918 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9920 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9936 printf (_(" Size table\n"));
9937 printf (" slot %-16s ",
9938 is_tu_index
? _("signature") : _("dwo_id"));
9941 for (j
= 0; j
< ncols
; j
++)
9943 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9945 printf (" %8s", get_DW_SECT_short_name (val
));
9951 for (i
= 0; i
< nslots
; i
++)
9953 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9955 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9958 prow
= psizes
+ (row
- 1) * ncols
* 4;
9961 printf (_(" [%3d] 0x%s"),
9962 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9963 buf
, sizeof (buf
)));
9965 for (j
= 0; j
< ncols
; j
++)
9967 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9969 printf (" %8d", val
);
9972 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9973 if (dw_sect
>= DW_SECT_MAX
)
9974 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9976 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9988 else if (do_display
)
9989 printf (_(" Unsupported version (%d)\n"), version
);
9997 /* Load the CU and TU indexes if present. This will build a list of
9998 section sets that we can use to associate a .debug_info.dwo section
9999 with its associated .debug_abbrev.dwo section in a .dwp file. */
10002 load_cu_tu_indexes (void *file
)
10004 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10006 /* If we have already loaded (or tried to load) the CU and TU indexes
10007 then do not bother to repeat the task. */
10008 if (cu_tu_indexes_read
== -1)
10010 cu_tu_indexes_read
= TRUE
;
10012 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10013 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10014 cu_tu_indexes_read
= FALSE
;
10016 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10017 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10018 cu_tu_indexes_read
= FALSE
;
10021 return (bfd_boolean
) cu_tu_indexes_read
;
10024 /* Find the set of sections that includes section SHNDX. */
10027 find_cu_tu_set (void *file
, unsigned int shndx
)
10031 if (! load_cu_tu_indexes (file
))
10034 /* Find SHNDX in the shndx pool. */
10035 for (i
= 0; i
< shndx_pool_used
; i
++)
10036 if (shndx_pool
[i
] == shndx
)
10039 if (i
>= shndx_pool_used
)
10042 /* Now backup to find the first entry in the set. */
10043 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10046 return shndx_pool
+ i
;
10049 /* Display a .debug_cu_index or .debug_tu_index section. */
10052 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10054 return process_cu_tu_index (section
, 1);
10058 display_debug_not_supported (struct dwarf_section
*section
,
10059 void *file ATTRIBUTE_UNUSED
)
10061 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10067 /* Like malloc, but takes two parameters like calloc.
10068 Verifies that the first parameter is not too large.
10069 Note: does *not* initialise the allocated memory to zero. */
10072 cmalloc (size_t nmemb
, size_t size
)
10074 /* Check for overflow. */
10075 if (nmemb
>= ~(size_t) 0 / size
)
10078 return xmalloc (nmemb
* size
);
10081 /* Like xmalloc, but takes two parameters like calloc.
10082 Verifies that the first parameter is not too large.
10083 Note: does *not* initialise the allocated memory to zero. */
10086 xcmalloc (size_t nmemb
, size_t size
)
10088 /* Check for overflow. */
10089 if (nmemb
>= ~(size_t) 0 / size
)
10092 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10097 return xmalloc (nmemb
* size
);
10100 /* Like xrealloc, but takes three parameters.
10101 Verifies that the second parameter is not too large.
10102 Note: does *not* initialise any new memory to zero. */
10105 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10107 /* Check for overflow. */
10108 if (nmemb
>= ~(size_t) 0 / size
)
10110 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10115 return xrealloc (ptr
, nmemb
* size
);
10118 /* Like xcalloc, but verifies that the first parameter is not too large. */
10121 xcalloc2 (size_t nmemb
, size_t size
)
10123 /* Check for overflow. */
10124 if (nmemb
>= ~(size_t) 0 / size
)
10126 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10131 return xcalloc (nmemb
, size
);
10134 static unsigned long
10135 calc_gnu_debuglink_crc32 (unsigned long crc
,
10136 const unsigned char * buf
,
10139 static const unsigned long crc32_table
[256] =
10141 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10142 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10143 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10144 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10145 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10146 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10147 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10148 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10149 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10150 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10151 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10152 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10153 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10154 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10155 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10156 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10157 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10158 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10159 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10160 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10161 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10162 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10163 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10164 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10165 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10166 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10167 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10168 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10169 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10170 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10171 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10172 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10173 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10174 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10175 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10176 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10177 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10178 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10179 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10180 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10181 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10182 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10183 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10184 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10185 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10186 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10187 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10188 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10189 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10190 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10191 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10194 const unsigned char *end
;
10196 crc
= ~crc
& 0xffffffff;
10197 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10198 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10199 return ~crc
& 0xffffffff;
10202 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10203 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10206 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10208 static unsigned char buffer
[8 * 1024];
10210 bfd_size_type count
;
10211 unsigned long crc
= 0;
10214 sep_data
= open_debug_file (pathname
);
10215 if (sep_data
== NULL
)
10218 /* Yes - we are opening the file twice... */
10219 f
= fopen (pathname
, "rb");
10222 /* Paranoia: This should never happen. */
10223 close_debug_file (sep_data
);
10224 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10228 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10229 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10233 if (crc
!= * (unsigned long *) crc_pointer
)
10235 close_debug_file (sep_data
);
10236 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10244 static const char *
10245 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10248 unsigned int crc_offset
;
10249 unsigned long * crc32
= (unsigned long *) data
;
10251 /* The name is first.
10252 The CRC value is stored after the filename, aligned up to 4 bytes. */
10253 name
= (const char *) section
->start
;
10256 crc_offset
= strnlen (name
, section
->size
) + 1;
10257 crc_offset
= (crc_offset
+ 3) & ~3;
10258 if (crc_offset
+ 4 > section
->size
)
10261 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10266 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10268 void * sep_data
= open_debug_file (filename
);
10270 if (sep_data
== NULL
)
10273 /* FIXME: We should now extract the build-id in the separate file
10279 typedef struct build_id_data
10282 const unsigned char * data
;
10285 static const char *
10286 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10289 bfd_size_type namelen
;
10290 bfd_size_type id_len
;
10291 Build_id_data
* build_id_data
;
10293 /* The name is first.
10294 The build-id follows immediately, with no padding, up to the section's end. */
10296 name
= (const char *) section
->start
;
10297 namelen
= strnlen (name
, section
->size
) + 1;
10298 if (namelen
>= section
->size
)
10301 id_len
= section
->size
- namelen
;
10305 build_id_data
= calloc (1, sizeof * build_id_data
);
10306 if (build_id_data
== NULL
)
10309 build_id_data
->len
= id_len
;
10310 build_id_data
->data
= section
->start
+ namelen
;
10312 * (Build_id_data
**) data
= build_id_data
;
10318 add_separate_debug_file (const char * filename
, void * handle
)
10320 separate_info
* i
= xmalloc (sizeof * i
);
10322 i
->filename
= filename
;
10323 i
->handle
= handle
;
10324 i
->next
= first_separate_info
;
10325 first_separate_info
= i
;
10328 #if HAVE_LIBDEBUGINFOD
10329 /* Query debuginfod servers for the target debuglink or debugaltlink
10330 file. If successful, store the path of the file in filename and
10331 return TRUE, otherwise return FALSE. */
10334 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10338 size_t build_id_len
;
10339 unsigned char * build_id
;
10341 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10343 /* Get the build-id of file. */
10344 build_id
= get_build_id (file
);
10347 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10349 /* Get the build-id of the debugaltlink file. */
10350 unsigned int filelen
;
10352 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10353 if (filelen
== section
->size
)
10354 /* Corrupt debugaltlink. */
10357 build_id
= section
->start
+ filelen
+ 1;
10358 build_id_len
= section
->size
- (filelen
+ 1);
10360 if (build_id_len
== 0)
10369 debuginfod_client
* client
;
10371 client
= debuginfod_begin ();
10372 if (client
== NULL
)
10375 /* Query debuginfod servers for the target file. If found its path
10376 will be stored in filename. */
10377 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10378 debuginfod_end (client
);
10380 /* Only free build_id if we allocated space for a hex string
10381 in get_build_id (). */
10382 if (build_id_len
== 0)
10387 /* File successfully retrieved. Close fd since we want to
10388 use open_debug_file () on filename instead. */
10399 load_separate_debug_info (const char * main_filename
,
10400 struct dwarf_section
* xlink
,
10401 parse_func_type parse_func
,
10402 check_func_type check_func
,
10404 void * file ATTRIBUTE_UNUSED
)
10406 const char * separate_filename
;
10407 char * debug_filename
;
10409 size_t canon_dirlen
;
10412 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10414 warn (_("Corrupt debuglink section: %s\n"),
10415 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10419 /* Attempt to locate the separate file.
10420 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10422 canon_dir
= lrealpath (main_filename
);
10424 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10425 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10427 canon_dir
[canon_dirlen
] = '\0';
10430 #define DEBUGDIR "/lib/debug"
10432 #ifndef EXTRA_DEBUG_ROOT1
10433 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10435 #ifndef EXTRA_DEBUG_ROOT2
10436 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10439 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10441 + strlen (".debug/")
10442 #ifdef EXTRA_DEBUG_ROOT1
10443 + strlen (EXTRA_DEBUG_ROOT1
)
10445 #ifdef EXTRA_DEBUG_ROOT2
10446 + strlen (EXTRA_DEBUG_ROOT2
)
10448 + strlen (separate_filename
)
10450 if (debug_filename
== NULL
)
10452 warn (_("Out of memory"));
10457 /* First try in the current directory. */
10458 sprintf (debug_filename
, "%s", separate_filename
);
10459 if (check_func (debug_filename
, func_data
))
10462 /* Then try in a subdirectory called .debug. */
10463 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10464 if (check_func (debug_filename
, func_data
))
10467 /* Then try in the same directory as the original file. */
10468 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10469 if (check_func (debug_filename
, func_data
))
10472 /* And the .debug subdirectory of that directory. */
10473 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10474 if (check_func (debug_filename
, func_data
))
10477 #ifdef EXTRA_DEBUG_ROOT1
10478 /* Try the first extra debug file root. */
10479 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10480 if (check_func (debug_filename
, func_data
))
10483 /* Try the first extra debug file root. */
10484 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10485 if (check_func (debug_filename
, func_data
))
10489 #ifdef EXTRA_DEBUG_ROOT2
10490 /* Try the second extra debug file root. */
10491 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10492 if (check_func (debug_filename
, func_data
))
10496 /* Then try in the global debug_filename directory. */
10497 strcpy (debug_filename
, DEBUGDIR
);
10498 dirlen
= strlen (DEBUGDIR
) - 1;
10499 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10500 strcat (debug_filename
, "/");
10501 strcat (debug_filename
, (const char *) separate_filename
);
10503 if (check_func (debug_filename
, func_data
))
10506 #if HAVE_LIBDEBUGINFOD
10508 char * tmp_filename
;
10510 if (debuginfod_fetch_separate_debug_info (xlink
,
10514 /* File successfully downloaded from server, replace
10515 debug_filename with the file's path. */
10516 free (debug_filename
);
10517 debug_filename
= tmp_filename
;
10523 /* Failed to find the file. */
10524 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10525 warn (_("tried: %s\n"), debug_filename
);
10527 #ifdef EXTRA_DEBUG_ROOT2
10528 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10529 warn (_("tried: %s\n"), debug_filename
);
10532 #ifdef EXTRA_DEBUG_ROOT1
10533 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10534 warn (_("tried: %s\n"), debug_filename
);
10536 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10537 warn (_("tried: %s\n"), debug_filename
);
10540 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10541 warn (_("tried: %s\n"), debug_filename
);
10543 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10544 warn (_("tried: %s\n"), debug_filename
);
10546 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10547 warn (_("tried: %s\n"), debug_filename
);
10549 sprintf (debug_filename
, "%s", separate_filename
);
10550 warn (_("tried: %s\n"), debug_filename
);
10552 #if HAVE_LIBDEBUGINFOD
10554 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10558 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10563 free (debug_filename
);
10569 void * debug_handle
;
10571 /* Now open the file.... */
10572 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10574 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10575 free (debug_filename
);
10579 /* FIXME: We do not check to see if there are any other separate debug info
10580 files that would also match. */
10582 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10583 add_separate_debug_file (debug_filename
, debug_handle
);
10585 /* Do not free debug_filename - it might be referenced inside
10586 the structure returned by open_debug_file(). */
10587 return debug_handle
;
10590 /* Attempt to load a separate dwarf object file. */
10593 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10595 char * separate_filename
;
10596 void * separate_handle
;
10598 /* FIXME: Skip adding / if dwo_dir ends in /. */
10599 separate_filename
= concat (dir
, "/", name
, NULL
);
10600 if (separate_filename
== NULL
)
10602 warn (_("Out of memory allocating dwo filename\n"));
10606 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10608 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10609 free (separate_filename
);
10613 /* FIXME: We should check the dwo_id. */
10615 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10616 add_separate_debug_file (separate_filename
, separate_handle
);
10617 /* Note - separate_filename will be freed in free_debug_memory(). */
10618 return separate_handle
;
10621 /* Load the separate debug info file(s) attached to FILE, if any exist.
10622 Returns TRUE if any were found, FALSE otherwise.
10623 If TRUE is returned then the linked list starting at first_separate_info
10624 will be populated with open file handles. */
10627 load_separate_debug_files (void * file
, const char * filename
)
10629 /* Skip this operation if we are not interested in debug links. */
10630 if (! do_follow_links
&& ! do_debug_links
)
10633 /* See if there are any dwo links. */
10634 if (load_debug_section (str
, file
)
10635 && load_debug_section (abbrev
, file
)
10636 && load_debug_section (info
, file
))
10640 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10642 bfd_boolean introduced
= FALSE
;
10644 const char * dir
= NULL
;
10645 const char * id
= NULL
;
10647 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10649 switch (dwinfo
->type
)
10652 if (do_debug_links
)
10656 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10657 debug_displays
[info
].section
.uncompressed_name
);
10661 printf (_(" Name: %s\n"), dwinfo
->value
);
10662 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10664 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10666 printf (_(" ID: <unknown>\n"));
10670 if (do_follow_links
)
10671 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10675 dir
= dwinfo
->value
;
10679 id
= dwinfo
->value
;
10683 error (_("Unexpected DWO INFO type"));
10690 if (! do_follow_links
)
10691 /* The other debug links will be displayed by display_debug_links()
10692 so we do not need to do any further processing here. */
10695 /* FIXME: We do not check for the presence of both link sections in the same file. */
10696 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10697 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10698 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10700 if (load_debug_section (gnu_debugaltlink
, file
))
10702 Build_id_data
* build_id_data
;
10704 load_separate_debug_info (filename
,
10705 & debug_displays
[gnu_debugaltlink
].section
,
10706 parse_gnu_debugaltlink
,
10707 check_gnu_debugaltlink
,
10712 if (load_debug_section (gnu_debuglink
, file
))
10714 unsigned long crc32
;
10716 load_separate_debug_info (filename
,
10717 & debug_displays
[gnu_debuglink
].section
,
10718 parse_gnu_debuglink
,
10719 check_gnu_debuglink
,
10724 if (first_separate_info
!= NULL
)
10727 do_follow_links
= 0;
10732 free_debug_memory (void)
10738 for (i
= 0; i
< max
; i
++)
10739 free_debug_section ((enum dwarf_section_display_enum
) i
);
10741 if (debug_information
!= NULL
)
10743 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10745 for (i
= 0; i
< num_debug_info_entries
; i
++)
10747 if (!debug_information
[i
].max_loc_offsets
)
10749 free (debug_information
[i
].loc_offsets
);
10750 free (debug_information
[i
].have_frame_base
);
10752 if (!debug_information
[i
].max_range_lists
)
10753 free (debug_information
[i
].range_lists
);
10756 free (debug_information
);
10757 debug_information
= NULL
;
10758 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10762 separate_info
* next
;
10764 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10766 close_debug_file (d
->handle
);
10767 free ((void *) d
->filename
);
10771 first_separate_info
= NULL
;
10777 dwarf_select_sections_by_names (const char *names
)
10781 const char * option
;
10785 debug_dump_long_opts
;
10787 static const debug_dump_long_opts opts_table
[] =
10789 /* Please keep this table alpha- sorted. */
10790 { "Ranges", & do_debug_ranges
, 1 },
10791 { "abbrev", & do_debug_abbrevs
, 1 },
10792 { "addr", & do_debug_addr
, 1 },
10793 { "aranges", & do_debug_aranges
, 1 },
10794 { "cu_index", & do_debug_cu_index
, 1 },
10795 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10796 { "follow-links", & do_follow_links
, 1 },
10797 { "frames", & do_debug_frames
, 1 },
10798 { "frames-interp", & do_debug_frames_interp
, 1 },
10799 /* The special .gdb_index section. */
10800 { "gdb_index", & do_gdb_index
, 1 },
10801 { "info", & do_debug_info
, 1 },
10802 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10803 { "links", & do_debug_links
, 1 },
10804 { "loc", & do_debug_loc
, 1 },
10805 { "macro", & do_debug_macinfo
, 1 },
10806 { "pubnames", & do_debug_pubnames
, 1 },
10807 { "pubtypes", & do_debug_pubtypes
, 1 },
10808 /* This entry is for compatibility
10809 with earlier versions of readelf. */
10810 { "ranges", & do_debug_aranges
, 1 },
10811 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10812 { "str", & do_debug_str
, 1 },
10813 { "str-offsets", & do_debug_str_offsets
, 1 },
10814 /* These trace_* sections are used by Itanium VMS. */
10815 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10816 { "trace_aranges", & do_trace_aranges
, 1 },
10817 { "trace_info", & do_trace_info
, 1 },
10826 const debug_dump_long_opts
* entry
;
10828 for (entry
= opts_table
; entry
->option
; entry
++)
10830 size_t len
= strlen (entry
->option
);
10832 if (strncmp (p
, entry
->option
, len
) == 0
10833 && (p
[len
] == ',' || p
[len
] == '\0'))
10835 * entry
->variable
|= entry
->val
;
10837 /* The --debug-dump=frames-interp option also
10838 enables the --debug-dump=frames option. */
10839 if (do_debug_frames_interp
)
10840 do_debug_frames
= 1;
10847 if (entry
->option
== NULL
)
10849 warn (_("Unrecognized debug option '%s'\n"), p
);
10850 p
= strchr (p
, ',');
10861 dwarf_select_sections_by_letters (const char *letters
)
10863 unsigned int lindex
= 0;
10865 while (letters
[lindex
])
10866 switch (letters
[lindex
++])
10868 case 'A': do_debug_addr
= 1; break;
10869 case 'a': do_debug_abbrevs
= 1; break;
10870 case 'c': do_debug_cu_index
= 1; break;
10871 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10872 case 'f': do_debug_frames
= 1; break;
10873 case 'g': do_gdb_index
= 1; break;
10874 case 'i': do_debug_info
= 1; break;
10875 case 'K': do_follow_links
= 1; break;
10876 case 'k': do_debug_links
= 1; break;
10877 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10878 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10879 case 'm': do_debug_macinfo
= 1; break;
10880 case 'O': do_debug_str_offsets
= 1; break;
10881 case 'o': do_debug_loc
= 1; break;
10882 case 'p': do_debug_pubnames
= 1; break;
10883 case 'R': do_debug_ranges
= 1; break;
10884 case 'r': do_debug_aranges
= 1; break;
10885 case 's': do_debug_str
= 1; break;
10886 case 'T': do_trace_aranges
= 1; break;
10887 case 't': do_debug_pubtypes
= 1; break;
10888 case 'U': do_trace_info
= 1; break;
10889 case 'u': do_trace_abbrevs
= 1; break;
10892 warn (_("Unrecognized debug option '%s'\n"), letters
);
10898 dwarf_select_sections_all (void)
10901 do_debug_abbrevs
= 1;
10902 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10903 do_debug_pubnames
= 1;
10904 do_debug_pubtypes
= 1;
10905 do_debug_aranges
= 1;
10906 do_debug_ranges
= 1;
10907 do_debug_frames
= 1;
10908 do_debug_macinfo
= 1;
10913 do_trace_abbrevs
= 1;
10914 do_trace_aranges
= 1;
10916 do_debug_cu_index
= 1;
10917 do_follow_links
= 1;
10918 do_debug_links
= 1;
10919 do_debug_str_offsets
= 1;
10922 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10923 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10925 /* N.B. The order here must match the order in section_display_enum. */
10927 struct dwarf_section_display debug_displays
[] =
10929 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10930 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10931 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10932 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10933 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10934 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10935 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10936 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10937 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10938 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10939 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10940 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10941 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10942 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10943 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10944 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10945 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10946 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10947 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10948 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10949 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10950 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10951 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10952 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10953 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10954 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10955 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10956 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10957 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10958 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10959 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10960 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10961 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10962 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10963 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10964 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10965 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10966 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10967 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10968 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10969 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10970 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10971 /* Separate debug info files can containt their own .debug_str section,
10972 and this might be in *addition* to a .debug_str section already present
10973 in the main file. Hence we need to have two entries for .debug_str. */
10974 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10977 /* A static assertion. */
10978 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];