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 /* A row with end_seq set to true has a meaningful address, but
4992 the other information in the same row is not significant.
4993 In such a row, print line as "-", and don't print
4995 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4997 if (linfo
.li_max_ops_per_insn
== 1)
4999 if (xop
== -DW_LNE_end_sequence
)
5000 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5002 state_machine_regs
.address
);
5004 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5005 newFileName
, state_machine_regs
.line
,
5006 state_machine_regs
.address
);
5010 if (xop
== -DW_LNE_end_sequence
)
5011 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5013 state_machine_regs
.address
,
5014 state_machine_regs
.op_index
);
5016 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5017 newFileName
, state_machine_regs
.line
,
5018 state_machine_regs
.address
,
5019 state_machine_regs
.op_index
);
5024 if (linfo
.li_max_ops_per_insn
== 1)
5026 if (xop
== -DW_LNE_end_sequence
)
5027 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5029 state_machine_regs
.address
);
5031 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5032 newFileName
, state_machine_regs
.line
,
5033 state_machine_regs
.address
);
5037 if (xop
== -DW_LNE_end_sequence
)
5038 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5040 state_machine_regs
.address
,
5041 state_machine_regs
.op_index
);
5043 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5044 newFileName
, state_machine_regs
.line
,
5045 state_machine_regs
.address
,
5046 state_machine_regs
.op_index
);
5050 if (xop
!= -DW_LNE_end_sequence
)
5052 if (state_machine_regs
.view
)
5053 printf (" %6u", state_machine_regs
.view
);
5057 if (state_machine_regs
.is_stmt
)
5062 state_machine_regs
.view
++;
5064 if (xop
== -DW_LNE_end_sequence
)
5066 reset_state_machine (linfo
.li_default_is_stmt
);
5081 if (directory_table
)
5083 free (directory_table
);
5084 directory_table
= NULL
;
5095 display_debug_lines (struct dwarf_section
*section
, void *file
)
5097 unsigned char *data
= section
->start
;
5098 unsigned char *end
= data
+ section
->size
;
5100 int retValDecoded
= 1;
5102 if (do_debug_lines
== 0)
5103 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5105 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5106 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5108 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5109 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5111 if (!retValRaw
|| !retValDecoded
)
5118 find_debug_info_for_offset (unsigned long offset
)
5122 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5125 for (i
= 0; i
< num_debug_info_entries
; i
++)
5126 if (debug_information
[i
].cu_offset
== offset
)
5127 return debug_information
+ i
;
5133 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5135 /* See gdb/gdb-index.h. */
5136 static const char * const kinds
[] =
5148 return _ (kinds
[kind
]);
5152 display_debug_pubnames_worker (struct dwarf_section
*section
,
5153 void *file ATTRIBUTE_UNUSED
,
5156 DWARF2_Internal_PubNames names
;
5157 unsigned char *start
= section
->start
;
5158 unsigned char *end
= start
+ section
->size
;
5160 /* It does not matter if this load fails,
5161 we test for that later on. */
5162 load_debug_info (file
);
5164 introduce (section
, FALSE
);
5168 unsigned char *data
;
5169 unsigned long sec_off
;
5170 unsigned int offset_size
, initial_length_size
;
5172 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5173 if (names
.pn_length
== 0xffffffff)
5175 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5177 initial_length_size
= 12;
5182 initial_length_size
= 4;
5185 sec_off
= start
- section
->start
;
5186 if (sec_off
+ names
.pn_length
< sec_off
5187 || sec_off
+ names
.pn_length
> section
->size
)
5189 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5191 sec_off
- initial_length_size
,
5192 dwarf_vmatoa ("x", names
.pn_length
));
5197 start
+= names
.pn_length
;
5199 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5200 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5202 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5203 && num_debug_info_entries
> 0
5204 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5205 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5206 (unsigned long) names
.pn_offset
, section
->name
);
5208 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5210 printf (_(" Length: %ld\n"),
5211 (long) names
.pn_length
);
5212 printf (_(" Version: %d\n"),
5214 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5215 (unsigned long) names
.pn_offset
);
5216 printf (_(" Size of area in .debug_info section: %ld\n"),
5217 (long) names
.pn_size
);
5219 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5221 static int warned
= 0;
5225 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5233 printf (_("\n Offset Kind Name\n"));
5235 printf (_("\n Offset\tName\n"));
5239 bfd_size_type maxprint
;
5242 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5247 data
+= offset_size
;
5250 maxprint
= (end
- data
) - 1;
5254 unsigned int kind_data
;
5255 gdb_index_symbol_kind kind
;
5256 const char *kind_name
;
5259 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5262 /* GCC computes the kind as the upper byte in the CU index
5263 word, and then right shifts it by the CU index size.
5264 Left shift KIND to where the gdb-index.h accessor macros
5266 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5267 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5268 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5269 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5270 printf (" %-6lx %s,%-10s %.*s\n",
5271 (unsigned long) offset
, is_static
? _("s") : _("g"),
5272 kind_name
, (int) maxprint
, data
);
5275 printf (" %-6lx\t%.*s\n",
5276 (unsigned long) offset
, (int) maxprint
, data
);
5278 data
+= strnlen ((char *) data
, maxprint
) + 1;
5289 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5291 return display_debug_pubnames_worker (section
, file
, 0);
5295 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5297 return display_debug_pubnames_worker (section
, file
, 1);
5301 display_debug_macinfo (struct dwarf_section
*section
,
5302 void *file ATTRIBUTE_UNUSED
)
5304 unsigned char *start
= section
->start
;
5305 unsigned char *end
= start
+ section
->size
;
5306 unsigned char *curr
= start
;
5307 enum dwarf_macinfo_record_type op
;
5309 introduce (section
, FALSE
);
5313 unsigned int lineno
;
5314 const unsigned char *string
;
5316 op
= (enum dwarf_macinfo_record_type
) *curr
;
5321 case DW_MACINFO_start_file
:
5323 unsigned int filenum
;
5325 READ_ULEB (lineno
, curr
, end
);
5326 READ_ULEB (filenum
, curr
, end
);
5327 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5332 case DW_MACINFO_end_file
:
5333 printf (_(" DW_MACINFO_end_file\n"));
5336 case DW_MACINFO_define
:
5337 READ_ULEB (lineno
, curr
, end
);
5339 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5340 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5344 case DW_MACINFO_undef
:
5345 READ_ULEB (lineno
, curr
, end
);
5347 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5348 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5352 case DW_MACINFO_vendor_ext
:
5354 unsigned int constant
;
5356 READ_ULEB (constant
, curr
, end
);
5358 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5359 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5369 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5370 filename and dirname corresponding to file name table entry with index
5371 FILEIDX. Return NULL on failure. */
5373 static unsigned char *
5374 get_line_filename_and_dirname (dwarf_vma line_offset
,
5376 unsigned char **dir_name
)
5378 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5379 unsigned char *hdrptr
, *dirtable
, *file_name
;
5380 unsigned int offset_size
, initial_length_size
;
5381 unsigned int version
, opcode_base
;
5382 dwarf_vma length
, diridx
;
5383 const unsigned char * end
;
5386 if (section
->start
== NULL
5387 || line_offset
>= section
->size
5391 hdrptr
= section
->start
+ line_offset
;
5392 end
= section
->start
+ section
->size
;
5394 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5395 if (length
== 0xffffffff)
5397 /* This section is 64-bit DWARF 3. */
5398 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5400 initial_length_size
= 12;
5405 initial_length_size
= 4;
5407 if (length
+ initial_length_size
< length
5408 || length
+ initial_length_size
> section
->size
)
5411 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5412 if (version
!= 2 && version
!= 3 && version
!= 4)
5414 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5416 hdrptr
++; /* Skip max_ops_per_insn. */
5417 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5419 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5420 if (opcode_base
== 0)
5423 hdrptr
+= opcode_base
- 1;
5428 /* Skip over dirname table. */
5429 while (*hdrptr
!= '\0')
5431 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5435 hdrptr
++; /* Skip the NUL at the end of the table. */
5437 /* Now skip over preceding filename table entries. */
5438 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5440 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5441 SKIP_ULEB (hdrptr
, end
);
5442 SKIP_ULEB (hdrptr
, end
);
5443 SKIP_ULEB (hdrptr
, end
);
5445 if (hdrptr
>= end
|| *hdrptr
== '\0')
5449 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5452 READ_ULEB (diridx
, hdrptr
, end
);
5455 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5456 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5457 if (dirtable
>= end
|| *dirtable
== '\0')
5459 *dir_name
= dirtable
;
5464 display_debug_macro (struct dwarf_section
*section
,
5467 unsigned char *start
= section
->start
;
5468 unsigned char *end
= start
+ section
->size
;
5469 unsigned char *curr
= start
;
5470 unsigned char *extended_op_buf
[256];
5472 load_debug_section_with_follow (str
, file
);
5473 load_debug_section_with_follow (line
, file
);
5474 load_debug_section_with_follow (str_index
, file
);
5476 introduce (section
, FALSE
);
5480 unsigned int lineno
, version
, flags
;
5481 unsigned int offset_size
= 4;
5482 const unsigned char *string
;
5483 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5484 unsigned char **extended_ops
= NULL
;
5486 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5487 if (version
!= 4 && version
!= 5)
5489 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5494 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5497 printf (_(" Offset: 0x%lx\n"),
5498 (unsigned long) sec_offset
);
5499 printf (_(" Version: %d\n"), version
);
5500 printf (_(" Offset size: %d\n"), offset_size
);
5503 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5504 printf (_(" Offset into .debug_line: 0x%lx\n"),
5505 (unsigned long) line_offset
);
5509 unsigned int i
, count
, op
;
5512 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5514 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5515 extended_ops
= extended_op_buf
;
5518 printf (_(" Extension opcode arguments:\n"));
5519 for (i
= 0; i
< count
; i
++)
5521 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5522 extended_ops
[op
] = curr
;
5523 READ_ULEB (nargs
, curr
, end
);
5525 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5528 printf (_(" DW_MACRO_%02x arguments: "), op
);
5529 for (n
= 0; n
< nargs
; n
++)
5533 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5534 printf ("%s%s", get_FORM_name (form
),
5535 n
== nargs
- 1 ? "\n" : ", ");
5545 case DW_FORM_block1
:
5546 case DW_FORM_block2
:
5547 case DW_FORM_block4
:
5549 case DW_FORM_string
:
5551 case DW_FORM_sec_offset
:
5554 error (_("Invalid extension opcode form %s\n"),
5555 get_FORM_name (form
));
5571 error (_(".debug_macro section not zero terminated\n"));
5575 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5581 case DW_MACRO_define
:
5582 READ_ULEB (lineno
, curr
, end
);
5584 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5585 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5589 case DW_MACRO_undef
:
5590 READ_ULEB (lineno
, curr
, end
);
5592 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5593 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5597 case DW_MACRO_start_file
:
5599 unsigned int filenum
;
5600 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5602 READ_ULEB (lineno
, curr
, end
);
5603 READ_ULEB (filenum
, curr
, end
);
5605 if ((flags
& 2) == 0)
5606 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5609 = get_line_filename_and_dirname (line_offset
, filenum
,
5611 if (file_name
== NULL
)
5612 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5615 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5617 dir_name
!= NULL
? (const char *) dir_name
: "",
5618 dir_name
!= NULL
? "/" : "", file_name
);
5622 case DW_MACRO_end_file
:
5623 printf (_(" DW_MACRO_end_file\n"));
5626 case DW_MACRO_define_strp
:
5627 READ_ULEB (lineno
, curr
, end
);
5628 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5629 string
= fetch_indirect_string (offset
);
5630 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5634 case DW_MACRO_undef_strp
:
5635 READ_ULEB (lineno
, curr
, end
);
5636 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5637 string
= fetch_indirect_string (offset
);
5638 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5642 case DW_MACRO_import
:
5643 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5644 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5645 (unsigned long) offset
);
5648 case DW_MACRO_define_sup
:
5649 READ_ULEB (lineno
, curr
, end
);
5650 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5651 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5652 lineno
, (unsigned long) offset
);
5655 case DW_MACRO_undef_sup
:
5656 READ_ULEB (lineno
, curr
, end
);
5657 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5658 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5659 lineno
, (unsigned long) offset
);
5662 case DW_MACRO_import_sup
:
5663 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5664 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5665 (unsigned long) offset
);
5668 case DW_MACRO_define_strx
:
5669 case DW_MACRO_undef_strx
:
5670 READ_ULEB (lineno
, curr
, end
);
5671 READ_ULEB (offset
, curr
, end
);
5672 string
= (const unsigned char *)
5673 fetch_indexed_string (offset
, NULL
, offset_size
, FALSE
);
5674 if (op
== DW_MACRO_define_strx
)
5675 printf (" DW_MACRO_define_strx ");
5677 printf (" DW_MACRO_undef_strx ");
5679 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
5680 printf (_("lineno : %d macro : %s\n"),
5685 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
5687 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
5691 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5693 error (_(" Unknown macro opcode %02x seen\n"), op
);
5698 /* Skip over unhandled opcodes. */
5700 unsigned char *desc
= extended_ops
[op
];
5701 READ_ULEB (nargs
, desc
, end
);
5704 printf (_(" DW_MACRO_%02x\n"), op
);
5707 printf (_(" DW_MACRO_%02x -"), op
);
5708 for (n
= 0; n
< nargs
; n
++)
5712 /* DW_FORM_implicit_const is not expected here. */
5713 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5715 = read_and_display_attr_value (0, val
, 0,
5716 start
, curr
, end
, 0, 0, offset_size
,
5717 version
, NULL
, 0, NULL
,
5735 display_debug_abbrev (struct dwarf_section
*section
,
5736 void *file ATTRIBUTE_UNUSED
)
5738 abbrev_entry
*entry
;
5739 unsigned char *start
= section
->start
;
5740 unsigned char *end
= start
+ section
->size
;
5742 introduce (section
, FALSE
);
5746 unsigned char *last
;
5751 start
= process_abbrev_section (start
, end
);
5753 if (first_abbrev
== NULL
)
5756 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5758 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5762 printf (" %ld %s [%s]\n",
5764 get_TAG_name (entry
->tag
),
5765 entry
->children
? _("has children") : _("no children"));
5767 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5769 printf (" %-18s %s",
5770 get_AT_name (attr
->attribute
),
5771 get_FORM_name (attr
->form
));
5772 if (attr
->form
== DW_FORM_implicit_const
)
5773 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5785 /* Return true when ADDR is the maximum address, when addresses are
5786 POINTER_SIZE bytes long. */
5789 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5791 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5792 return ((addr
& mask
) == mask
);
5795 /* Display a view pair list starting at *VSTART_PTR and ending at
5796 VLISTEND within SECTION. */
5799 display_view_pair_list (struct dwarf_section
*section
,
5800 unsigned char **vstart_ptr
,
5801 unsigned int debug_info_entry
,
5802 unsigned char *vlistend
)
5804 unsigned char *vstart
= *vstart_ptr
;
5805 unsigned char *section_end
= section
->start
+ section
->size
;
5806 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5808 if (vlistend
< section_end
)
5809 section_end
= vlistend
;
5813 while (vstart
< section_end
)
5815 dwarf_vma off
= vstart
- section
->start
;
5816 dwarf_vma vbegin
, vend
;
5818 READ_ULEB (vbegin
, vstart
, section_end
);
5819 if (vstart
== section_end
)
5822 READ_ULEB (vend
, vstart
, section_end
);
5823 printf (" %8.8lx ", (unsigned long) off
);
5825 print_dwarf_view (vbegin
, pointer_size
, 1);
5826 print_dwarf_view (vend
, pointer_size
, 1);
5827 printf (_("location view pair\n"));
5831 *vstart_ptr
= vstart
;
5834 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5837 display_loc_list (struct dwarf_section
*section
,
5838 unsigned char **start_ptr
,
5839 unsigned int debug_info_entry
,
5841 dwarf_vma base_address
,
5842 unsigned char **vstart_ptr
,
5845 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5846 unsigned char *section_end
= section
->start
+ section
->size
;
5847 unsigned long cu_offset
;
5848 unsigned int pointer_size
;
5849 unsigned int offset_size
;
5854 unsigned short length
;
5855 int need_frame_base
;
5857 if (debug_info_entry
>= num_debug_info_entries
)
5859 warn (_("No debug information available for loc lists of entry: %u\n"),
5864 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5865 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5866 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5867 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5869 if (pointer_size
< 2 || pointer_size
> 8)
5871 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5872 pointer_size
, debug_info_entry
);
5878 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5879 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5881 if (start
+ 2 * pointer_size
> section_end
)
5883 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5884 (unsigned long) offset
);
5888 printf (" %8.8lx ", (unsigned long) off
);
5890 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5891 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5893 if (begin
== 0 && end
== 0)
5895 /* PR 18374: In a object file we can have a location list that
5896 starts with a begin and end of 0 because there are relocations
5897 that need to be applied to the addresses. Actually applying
5898 the relocations now does not help as they will probably resolve
5899 to 0, since the object file has not been fully linked. Real
5900 end of list markers will not have any relocations against them. */
5901 if (! reloc_at (section
, off
)
5902 && ! reloc_at (section
, off
+ pointer_size
))
5904 printf (_("<End of list>\n"));
5909 /* Check base address specifiers. */
5910 if (is_max_address (begin
, pointer_size
)
5911 && !is_max_address (end
, pointer_size
))
5914 print_dwarf_vma (begin
, pointer_size
);
5915 print_dwarf_vma (end
, pointer_size
);
5916 printf (_("(base address)\n"));
5922 off
= offset
+ (vstart
- *start_ptr
);
5924 READ_ULEB (vbegin
, vstart
, section_end
);
5925 print_dwarf_view (vbegin
, pointer_size
, 1);
5927 READ_ULEB (vend
, vstart
, section_end
);
5928 print_dwarf_view (vend
, pointer_size
, 1);
5930 printf (_("views at %8.8lx for:\n %*s "),
5931 (unsigned long) off
, 8, "");
5934 if (start
+ 2 > section_end
)
5936 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5937 (unsigned long) offset
);
5941 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5943 if (start
+ length
> section_end
)
5945 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5946 (unsigned long) offset
);
5950 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5951 print_dwarf_vma (end
+ base_address
, pointer_size
);
5954 need_frame_base
= decode_location_expression (start
,
5959 cu_offset
, section
);
5962 if (need_frame_base
&& !has_frame_base
)
5963 printf (_(" [without DW_AT_frame_base]"));
5965 if (begin
== end
&& vbegin
== vend
)
5966 fputs (_(" (start == end)"), stdout
);
5967 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5968 fputs (_(" (start > end)"), stdout
);
5976 *vstart_ptr
= vstart
;
5979 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5982 display_loclists_list (struct dwarf_section
*section
,
5983 unsigned char **start_ptr
,
5984 unsigned int debug_info_entry
,
5986 dwarf_vma base_address
,
5987 unsigned char **vstart_ptr
,
5990 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5991 unsigned char *section_end
= section
->start
+ section
->size
;
5992 unsigned long cu_offset
;
5993 unsigned int pointer_size
;
5994 unsigned int offset_size
;
5997 /* Initialize it due to a false compiler warning. */
5998 dwarf_vma begin
= -1, vbegin
= -1;
5999 dwarf_vma end
= -1, vend
= -1;
6001 int need_frame_base
;
6003 if (debug_info_entry
>= num_debug_info_entries
)
6005 warn (_("No debug information available for "
6006 "loclists lists of entry: %u\n"),
6011 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6012 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6013 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6014 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6016 if (pointer_size
< 2 || pointer_size
> 8)
6018 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6019 pointer_size
, debug_info_entry
);
6025 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6026 enum dwarf_location_list_entry_type llet
;
6028 if (start
+ 1 > section_end
)
6030 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6031 (unsigned long) offset
);
6035 printf (" %8.8lx ", (unsigned long) off
);
6037 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6039 if (vstart
&& llet
== DW_LLE_offset_pair
)
6041 off
= offset
+ (vstart
- *start_ptr
);
6043 READ_ULEB (vbegin
, vstart
, section_end
);
6044 print_dwarf_view (vbegin
, pointer_size
, 1);
6046 READ_ULEB (vend
, vstart
, section_end
);
6047 print_dwarf_view (vend
, pointer_size
, 1);
6049 printf (_("views at %8.8lx for:\n %*s "),
6050 (unsigned long) off
, 8, "");
6055 case DW_LLE_end_of_list
:
6056 printf (_("<End of list>\n"));
6058 case DW_LLE_offset_pair
:
6059 READ_ULEB (begin
, start
, section_end
);
6060 READ_ULEB (end
, start
, section_end
);
6062 case DW_LLE_base_address
:
6063 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6065 print_dwarf_vma (base_address
, pointer_size
);
6066 printf (_("(base address)\n"));
6068 #ifdef DW_LLE_view_pair
6069 case DW_LLE_view_pair
:
6071 printf (_("View pair entry in loclist with locviews attribute\n"));
6072 READ_ULEB (vbegin
, start
, section_end
);
6073 print_dwarf_view (vbegin
, pointer_size
, 1);
6075 READ_ULEB (vend
, start
, section_end
);
6076 print_dwarf_view (vend
, pointer_size
, 1);
6078 printf (_("views for:\n"));
6082 error (_("Invalid location list entry type %d\n"), llet
);
6085 if (llet
== DW_LLE_end_of_list
)
6087 if (llet
!= DW_LLE_offset_pair
)
6090 if (start
+ 2 > section_end
)
6092 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6093 (unsigned long) offset
);
6097 READ_ULEB (length
, start
, section_end
);
6099 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6100 print_dwarf_vma (end
+ base_address
, pointer_size
);
6103 need_frame_base
= decode_location_expression (start
,
6108 cu_offset
, section
);
6111 if (need_frame_base
&& !has_frame_base
)
6112 printf (_(" [without DW_AT_frame_base]"));
6114 if (begin
== end
&& vbegin
== vend
)
6115 fputs (_(" (start == end)"), stdout
);
6116 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6117 fputs (_(" (start > end)"), stdout
);
6125 if (vbegin
!= vm1
|| vend
!= vm1
)
6126 printf (_("Trailing view pair not used in a range"));
6129 *vstart_ptr
= vstart
;
6132 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6133 right-adjusted in a field of length LEN, and followed by a space. */
6136 print_addr_index (unsigned int idx
, unsigned int len
)
6138 static char buf
[15];
6139 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6140 printf ("%*s ", len
, buf
);
6143 /* Display a location list from a .dwo section. It uses address indexes rather
6144 than embedded addresses. This code closely follows display_loc_list, but the
6145 two are sufficiently different that combining things is very ugly. */
6148 display_loc_list_dwo (struct dwarf_section
*section
,
6149 unsigned char **start_ptr
,
6150 unsigned int debug_info_entry
,
6152 unsigned char **vstart_ptr
,
6155 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6156 unsigned char *section_end
= section
->start
+ section
->size
;
6157 unsigned long cu_offset
;
6158 unsigned int pointer_size
;
6159 unsigned int offset_size
;
6162 unsigned short length
;
6163 int need_frame_base
;
6166 if (debug_info_entry
>= num_debug_info_entries
)
6168 warn (_("No debug information for loc lists of entry: %u\n"),
6173 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6174 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6175 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6176 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6178 if (pointer_size
< 2 || pointer_size
> 8)
6180 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6181 pointer_size
, debug_info_entry
);
6187 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6189 if (start
>= section_end
)
6191 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6192 (unsigned long) offset
);
6196 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6209 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6211 READ_ULEB (view
, vstart
, section_end
);
6212 print_dwarf_view (view
, 8, 1);
6214 READ_ULEB (view
, vstart
, section_end
);
6215 print_dwarf_view (view
, 8, 1);
6217 printf (_("views at %8.8lx for:\n %*s "),
6218 (unsigned long) off
, 8, "");
6226 case 0: /* A terminating entry. */
6228 *vstart_ptr
= vstart
;
6229 printf (_("<End of list>\n"));
6231 case 1: /* A base-address entry. */
6232 READ_ULEB (idx
, start
, section_end
);
6233 print_addr_index (idx
, 8);
6234 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6235 printf (_("(base address selection entry)\n"));
6237 case 2: /* A start/end entry. */
6238 READ_ULEB (idx
, start
, section_end
);
6239 print_addr_index (idx
, 8);
6240 READ_ULEB (idx
, start
, section_end
);
6241 print_addr_index (idx
, 8);
6243 case 3: /* A start/length entry. */
6244 READ_ULEB (idx
, start
, section_end
);
6245 print_addr_index (idx
, 8);
6246 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6247 printf ("%08x ", idx
);
6249 case 4: /* An offset pair entry. */
6250 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6251 printf ("%08x ", idx
);
6252 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6253 printf ("%08x ", idx
);
6256 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6258 *vstart_ptr
= vstart
;
6262 if (start
+ 2 > section_end
)
6264 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6265 (unsigned long) offset
);
6269 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6270 if (start
+ length
> section_end
)
6272 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6273 (unsigned long) offset
);
6278 need_frame_base
= decode_location_expression (start
,
6283 cu_offset
, section
);
6286 if (need_frame_base
&& !has_frame_base
)
6287 printf (_(" [without DW_AT_frame_base]"));
6295 *vstart_ptr
= vstart
;
6298 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6301 static dwarf_vma
*loc_offsets
, *loc_views
;
6304 loc_offsets_compar (const void *ap
, const void *bp
)
6306 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6307 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6309 int ret
= (a
> b
) - (b
> a
);
6313 a
= loc_views
[*(const unsigned int *) ap
];
6314 b
= loc_views
[*(const unsigned int *) bp
];
6316 ret
= (a
> b
) - (b
> a
);
6322 display_debug_loc (struct dwarf_section
*section
, void *file
)
6324 unsigned char *start
= section
->start
, *vstart
= NULL
;
6325 unsigned long bytes
;
6326 unsigned char *section_begin
= start
;
6327 unsigned int num_loc_list
= 0;
6328 unsigned long last_offset
= 0;
6329 unsigned long last_view
= 0;
6330 unsigned int first
= 0;
6333 int seen_first_offset
= 0;
6334 int locs_sorted
= 1;
6335 unsigned char *next
= start
, *vnext
= vstart
;
6336 unsigned int *array
= NULL
;
6337 const char *suffix
= strrchr (section
->name
, '.');
6338 bfd_boolean is_dwo
= FALSE
;
6339 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6340 dwarf_vma expected_start
= 0;
6342 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6345 bytes
= section
->size
;
6349 printf (_("\nThe %s section is empty.\n"), section
->name
);
6355 unsigned char *hdrptr
= section_begin
;
6356 dwarf_vma ll_length
;
6357 unsigned short ll_version
;
6358 unsigned char *end
= section_begin
+ section
->size
;
6359 unsigned char address_size
, segment_selector_size
;
6360 uint32_t offset_entry_count
;
6362 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6363 if (ll_length
== 0xffffffff)
6364 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6366 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6367 if (ll_version
!= 5)
6369 warn (_("The %s section contains corrupt or "
6370 "unsupported version number: %d.\n"),
6371 section
->name
, ll_version
);
6375 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6377 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6378 if (segment_selector_size
!= 0)
6380 warn (_("The %s section contains "
6381 "unsupported segment selector size: %d.\n"),
6382 section
->name
, segment_selector_size
);
6386 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6387 if (offset_entry_count
!= 0)
6389 warn (_("The %s section contains "
6390 "unsupported offset entry count: %d.\n"),
6391 section
->name
, offset_entry_count
);
6395 expected_start
= hdrptr
- section_begin
;
6398 if (load_debug_info (file
) == 0)
6400 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6405 /* Check the order of location list in .debug_info section. If
6406 offsets of location lists are in the ascending order, we can
6407 use `debug_information' directly. */
6408 for (i
= 0; i
< num_debug_info_entries
; i
++)
6412 num
= debug_information
[i
].num_loc_offsets
;
6413 if (num
> num_loc_list
)
6416 /* Check if we can use `debug_information' directly. */
6417 if (locs_sorted
&& num
!= 0)
6419 if (!seen_first_offset
)
6421 /* This is the first location list. */
6422 last_offset
= debug_information
[i
].loc_offsets
[0];
6423 last_view
= debug_information
[i
].loc_views
[0];
6425 seen_first_offset
= 1;
6431 for (; j
< num
; j
++)
6434 debug_information
[i
].loc_offsets
[j
]
6435 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6436 && last_view
> debug_information
[i
].loc_views
[j
]))
6441 last_offset
= debug_information
[i
].loc_offsets
[j
];
6442 last_view
= debug_information
[i
].loc_views
[j
];
6447 if (!seen_first_offset
)
6448 error (_("No location lists in .debug_info section!\n"));
6450 if (debug_information
[first
].num_loc_offsets
> 0
6451 && debug_information
[first
].loc_offsets
[0] != expected_start
6452 && debug_information
[first
].loc_views
[0] != expected_start
)
6453 warn (_("Location lists in %s section start at 0x%s\n"),
6455 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6458 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6460 introduce (section
, FALSE
);
6462 if (reloc_at (section
, 0))
6463 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6465 printf (_(" Offset Begin End Expression\n"));
6467 seen_first_offset
= 0;
6468 for (i
= first
; i
< num_debug_info_entries
; i
++)
6470 dwarf_vma offset
, voffset
;
6471 dwarf_vma base_address
;
6477 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6479 loc_offsets
= debug_information
[i
].loc_offsets
;
6480 loc_views
= debug_information
[i
].loc_views
;
6481 qsort (array
, debug_information
[i
].num_loc_offsets
,
6482 sizeof (*array
), loc_offsets_compar
);
6485 int adjacent_view_loclists
= 1;
6486 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6488 j
= locs_sorted
? k
: array
[k
];
6490 && (debug_information
[i
].loc_offsets
[locs_sorted
6491 ? k
- 1 : array
[k
- 1]]
6492 == debug_information
[i
].loc_offsets
[j
])
6493 && (debug_information
[i
].loc_views
[locs_sorted
6494 ? k
- 1 : array
[k
- 1]]
6495 == debug_information
[i
].loc_views
[j
]))
6497 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6498 offset
= debug_information
[i
].loc_offsets
[j
];
6499 next
= section_begin
+ offset
;
6500 voffset
= debug_information
[i
].loc_views
[j
];
6502 vnext
= section_begin
+ voffset
;
6505 base_address
= debug_information
[i
].base_address
;
6507 if (vnext
&& vnext
< next
)
6510 display_view_pair_list (section
, &vstart
, i
, next
);
6515 if (!seen_first_offset
|| !adjacent_view_loclists
)
6516 seen_first_offset
= 1;
6520 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6521 (unsigned long) (start
- section_begin
),
6522 (unsigned long) offset
);
6523 else if (start
> next
)
6524 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6525 (unsigned long) (start
- section_begin
),
6526 (unsigned long) offset
);
6531 if (offset
>= bytes
)
6533 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6534 (unsigned long) offset
);
6538 if (vnext
&& voffset
>= bytes
)
6540 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6541 (unsigned long) voffset
);
6548 display_loc_list_dwo (section
, &start
, i
, offset
,
6549 &vstart
, has_frame_base
);
6551 display_loc_list (section
, &start
, i
, offset
, base_address
,
6552 &vstart
, has_frame_base
);
6557 warn (_("DWO is not yet supported.\n"));
6559 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6560 &vstart
, has_frame_base
);
6563 /* FIXME: this arrangement is quite simplistic. Nothing
6564 requires locview lists to be adjacent to corresponding
6565 loclists, and a single loclist could be augmented by
6566 different locview lists, and vice-versa, unlikely as it
6567 is that it would make sense to do so. Hopefully we'll
6568 have view pair support built into loclists before we ever
6569 need to address all these possibilities. */
6570 if (adjacent_view_loclists
&& vnext
6571 && vnext
!= start
&& vstart
!= next
)
6573 adjacent_view_loclists
= 0;
6574 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6577 if (vnext
&& vnext
== start
)
6578 display_view_pair_list (section
, &start
, i
, vstart
);
6582 if (start
< section
->start
+ section
->size
)
6583 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6584 "There are %ld unused bytes at the end of section %s\n",
6585 (long) (section
->start
+ section
->size
- start
)),
6586 (long) (section
->start
+ section
->size
- start
), section
->name
);
6593 display_debug_str (struct dwarf_section
*section
,
6594 void *file ATTRIBUTE_UNUSED
)
6596 unsigned char *start
= section
->start
;
6597 unsigned long bytes
= section
->size
;
6598 dwarf_vma addr
= section
->address
;
6602 printf (_("\nThe %s section is empty.\n"), section
->name
);
6606 introduce (section
, FALSE
);
6614 lbytes
= (bytes
> 16 ? 16 : bytes
);
6616 printf (" 0x%8.8lx ", (unsigned long) addr
);
6618 for (j
= 0; j
< 16; j
++)
6621 printf ("%2.2x", start
[j
]);
6629 for (j
= 0; j
< lbytes
; j
++)
6632 if (k
>= ' ' && k
< 0x80)
6651 display_debug_info (struct dwarf_section
*section
, void *file
)
6653 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6657 display_debug_types (struct dwarf_section
*section
, void *file
)
6659 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6663 display_trace_info (struct dwarf_section
*section
, void *file
)
6665 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6669 display_debug_aranges (struct dwarf_section
*section
,
6670 void *file ATTRIBUTE_UNUSED
)
6672 unsigned char *start
= section
->start
;
6673 unsigned char *end
= start
+ section
->size
;
6675 introduce (section
, FALSE
);
6677 /* It does not matter if this load fails,
6678 we test for that later on. */
6679 load_debug_info (file
);
6683 unsigned char *hdrptr
;
6684 DWARF2_Internal_ARange arange
;
6685 unsigned char *addr_ranges
;
6688 unsigned long sec_off
;
6689 unsigned char address_size
;
6691 unsigned int offset_size
;
6692 unsigned int initial_length_size
;
6696 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6697 if (arange
.ar_length
== 0xffffffff)
6699 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6701 initial_length_size
= 12;
6706 initial_length_size
= 4;
6709 sec_off
= hdrptr
- section
->start
;
6710 if (sec_off
+ arange
.ar_length
< sec_off
6711 || sec_off
+ arange
.ar_length
> section
->size
)
6713 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6715 sec_off
- initial_length_size
,
6716 dwarf_vmatoa ("x", arange
.ar_length
));
6720 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6721 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6723 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6724 && num_debug_info_entries
> 0
6725 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6726 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6727 (unsigned long) arange
.ar_info_offset
, section
->name
);
6729 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6730 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6732 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6734 /* PR 19872: A version number of 0 probably means that there is
6735 padding at the end of the .debug_aranges section. Gold puts
6736 it there when performing an incremental link, for example.
6737 So do not generate a warning in this case. */
6738 if (arange
.ar_version
)
6739 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6743 printf (_(" Length: %ld\n"),
6744 (long) arange
.ar_length
);
6745 printf (_(" Version: %d\n"), arange
.ar_version
);
6746 printf (_(" Offset into .debug_info: 0x%lx\n"),
6747 (unsigned long) arange
.ar_info_offset
);
6748 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6749 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6751 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6753 /* PR 17512: file: 001-108546-0.001:0.1. */
6754 if (address_size
== 0 || address_size
> 8)
6756 error (_("Invalid address size in %s section!\n"),
6761 /* The DWARF spec does not require that the address size be a power
6762 of two, but we do. This will have to change if we ever encounter
6763 an uneven architecture. */
6764 if ((address_size
& (address_size
- 1)) != 0)
6766 warn (_("Pointer size + Segment size is not a power of two.\n"));
6770 if (address_size
> 4)
6771 printf (_("\n Address Length\n"));
6773 printf (_("\n Address Length\n"));
6775 addr_ranges
= hdrptr
;
6777 /* Must pad to an alignment boundary that is twice the address size. */
6778 excess
= (hdrptr
- start
) % (2 * address_size
);
6780 addr_ranges
+= (2 * address_size
) - excess
;
6782 start
+= arange
.ar_length
+ initial_length_size
;
6784 while (addr_ranges
+ 2 * address_size
<= start
)
6786 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6787 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6790 print_dwarf_vma (address
, address_size
);
6791 print_dwarf_vma (length
, address_size
);
6801 /* Comparison function for qsort. */
6803 comp_addr_base (const void * v0
, const void * v1
)
6805 debug_info
*info0
= *(debug_info
**) v0
;
6806 debug_info
*info1
= *(debug_info
**) v1
;
6807 return info0
->addr_base
- info1
->addr_base
;
6810 /* Display the debug_addr section. */
6812 display_debug_addr (struct dwarf_section
*section
,
6815 debug_info
**debug_addr_info
;
6816 unsigned char *entry
;
6821 if (section
->size
== 0)
6823 printf (_("\nThe %s section is empty.\n"), section
->name
);
6827 if (load_debug_info (file
) == 0)
6829 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6834 introduce (section
, FALSE
);
6836 /* PR 17531: file: cf38d01b.
6837 We use xcalloc because a corrupt file may not have initialised all of the
6838 fields in the debug_info structure, which means that the sort below might
6839 try to move uninitialised data. */
6840 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6841 sizeof (debug_info
*));
6844 for (i
= 0; i
< num_debug_info_entries
; i
++)
6845 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6847 /* PR 17531: file: cf38d01b. */
6848 if (debug_information
[i
].addr_base
>= section
->size
)
6849 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6850 (unsigned long) debug_information
[i
].addr_base
, i
);
6852 debug_addr_info
[count
++] = debug_information
+ i
;
6855 /* Add a sentinel to make iteration convenient. */
6856 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6857 debug_addr_info
[count
]->addr_base
= section
->size
;
6858 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6860 for (i
= 0; i
< count
; i
++)
6863 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6865 printf (_(" For compilation unit at offset 0x%s:\n"),
6866 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6868 printf (_("\tIndex\tAddress\n"));
6869 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6870 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6874 dwarf_vma base
= byte_get (entry
, address_size
);
6875 printf (_("\t%d:\t"), idx
);
6876 print_dwarf_vma (base
, address_size
);
6878 entry
+= address_size
;
6884 free (debug_addr_info
);
6888 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6891 display_debug_str_offsets (struct dwarf_section
*section
,
6892 void *file ATTRIBUTE_UNUSED
)
6896 if (section
->size
== 0)
6898 printf (_("\nThe %s section is empty.\n"), section
->name
);
6902 unsigned char *start
= section
->start
;
6903 unsigned char *end
= start
+ section
->size
;
6904 unsigned char *curr
= start
;
6906 const char * suffix
= strrchr (section
->name
, '.');
6907 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
6910 load_debug_section_with_follow (str_dwo
, file
);
6912 load_debug_section_with_follow (str
, file
);
6914 introduce (section
, FALSE
);
6919 dwarf_vma entry_length
;
6921 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
6922 /* FIXME: We assume that this means 64-bit DWARF is being used. */
6923 if (length
== 0xffffffff)
6925 SAFE_BYTE_GET (length
, curr
, 8, end
);
6933 /* This is probably an old style .debug_str_offset section which
6934 just contains offsets and no header (and the first offset is 0). */
6935 length
= section
->size
;
6936 curr
= section
->start
;
6938 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6939 printf (_(" Index Offset [String]\n"));
6944 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
6946 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
6949 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
6951 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
6953 printf (_(" Length: %#lx\n"), (unsigned long) length
);
6954 printf (_(" Version: %#lx\n"), (unsigned long) version
);
6955 printf (_(" Index Offset [String]\n"));
6958 for (idx
= 0; length
>= entry_length
&& curr
< end
; idx
++)
6961 const unsigned char * string
;
6963 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, end
);
6965 string
= (const unsigned char *)
6966 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
6968 string
= fetch_indirect_string (offset
);
6970 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
6978 /* Each debug_information[x].range_lists[y] gets this representation for
6979 sorting purposes. */
6983 /* The debug_information[x].range_lists[y] value. */
6984 dwarf_vma ranges_offset
;
6986 /* Original debug_information to find parameters of the data. */
6987 debug_info
*debug_info_p
;
6990 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6993 range_entry_compar (const void *ap
, const void *bp
)
6995 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6996 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6997 const dwarf_vma a
= a_re
->ranges_offset
;
6998 const dwarf_vma b
= b_re
->ranges_offset
;
7000 return (a
> b
) - (b
> a
);
7004 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7005 unsigned int pointer_size
, unsigned long offset
,
7006 unsigned long base_address
)
7008 while (start
< finish
)
7013 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7014 if (start
>= finish
)
7016 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7019 printf (" %8.8lx ", offset
);
7021 if (begin
== 0 && end
== 0)
7023 printf (_("<End of list>\n"));
7027 /* Check base address specifiers. */
7028 if (is_max_address (begin
, pointer_size
)
7029 && !is_max_address (end
, pointer_size
))
7032 print_dwarf_vma (begin
, pointer_size
);
7033 print_dwarf_vma (end
, pointer_size
);
7034 printf ("(base address)\n");
7038 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7039 print_dwarf_vma (end
+ base_address
, pointer_size
);
7042 fputs (_("(start == end)"), stdout
);
7043 else if (begin
> end
)
7044 fputs (_("(start > end)"), stdout
);
7051 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7052 unsigned int pointer_size
, unsigned long offset
,
7053 unsigned long base_address
)
7055 unsigned char *next
= start
;
7059 unsigned long off
= offset
+ (start
- next
);
7060 enum dwarf_range_list_entry rlet
;
7061 /* Initialize it due to a false compiler warning. */
7062 dwarf_vma begin
= -1, length
, end
= -1;
7064 if (start
+ 1 > finish
)
7066 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7071 printf (" %8.8lx ", off
);
7073 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7077 case DW_RLE_end_of_list
:
7078 printf (_("<End of list>\n"));
7080 case DW_RLE_base_address
:
7081 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7082 print_dwarf_vma (base_address
, pointer_size
);
7083 printf (_("(base address)\n"));
7085 case DW_RLE_start_length
:
7086 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7087 READ_ULEB (length
, start
, finish
);
7088 end
= begin
+ length
;
7090 case DW_RLE_offset_pair
:
7091 READ_ULEB (begin
, start
, finish
);
7092 READ_ULEB (end
, start
, finish
);
7094 case DW_RLE_start_end
:
7095 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7096 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7099 error (_("Invalid range list entry type %d\n"), rlet
);
7100 rlet
= DW_RLE_end_of_list
;
7103 if (rlet
== DW_RLE_end_of_list
)
7105 if (rlet
== DW_RLE_base_address
)
7108 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7109 print_dwarf_vma (end
+ base_address
, pointer_size
);
7112 fputs (_("(start == end)"), stdout
);
7113 else if (begin
> end
)
7114 fputs (_("(start > end)"), stdout
);
7121 display_debug_ranges (struct dwarf_section
*section
,
7122 void *file ATTRIBUTE_UNUSED
)
7124 unsigned char *start
= section
->start
;
7125 unsigned char *last_start
= start
;
7126 unsigned long bytes
= section
->size
;
7127 unsigned char *section_begin
= start
;
7128 unsigned char *finish
= start
+ bytes
;
7129 unsigned int num_range_list
, i
;
7130 struct range_entry
*range_entries
, *range_entry_fill
;
7131 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7132 /* Initialize it due to a false compiler warning. */
7133 unsigned char address_size
= 0;
7134 dwarf_vma last_offset
= 0;
7138 printf (_("\nThe %s section is empty.\n"), section
->name
);
7144 dwarf_vma initial_length
;
7145 unsigned int initial_length_size
;
7146 unsigned char segment_selector_size
;
7147 unsigned int offset_size
, offset_entry_count
;
7148 unsigned short version
;
7150 /* Get and check the length of the block. */
7151 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7153 if (initial_length
== 0xffffffff)
7155 /* This section is 64-bit DWARF 3. */
7156 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7158 initial_length_size
= 12;
7163 initial_length_size
= 4;
7166 if (initial_length
+ initial_length_size
> section
->size
)
7168 /* If the length field has a relocation against it, then we should
7169 not complain if it is inaccurate (and probably negative).
7170 It is copied from .debug_line handling code. */
7171 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7173 initial_length
= (finish
- start
) - initial_length_size
;
7177 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7178 (long) initial_length
);
7183 /* Get and check the version number. */
7184 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7188 warn (_("Only DWARF version 5 debug_rnglists info "
7189 "is currently supported.\n"));
7193 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7195 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7196 if (segment_selector_size
!= 0)
7198 warn (_("The %s section contains "
7199 "unsupported segment selector size: %d.\n"),
7200 section
->name
, segment_selector_size
);
7204 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7205 if (offset_entry_count
!= 0)
7207 warn (_("The %s section contains "
7208 "unsupported offset entry count: %u.\n"),
7209 section
->name
, offset_entry_count
);
7214 if (load_debug_info (file
) == 0)
7216 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7222 for (i
= 0; i
< num_debug_info_entries
; i
++)
7223 num_range_list
+= debug_information
[i
].num_range_lists
;
7225 if (num_range_list
== 0)
7227 /* This can happen when the file was compiled with -gsplit-debug
7228 which removes references to range lists from the primary .o file. */
7229 printf (_("No range lists in .debug_info section.\n"));
7233 range_entries
= (struct range_entry
*)
7234 xmalloc (sizeof (*range_entries
) * num_range_list
);
7235 range_entry_fill
= range_entries
;
7237 for (i
= 0; i
< num_debug_info_entries
; i
++)
7239 debug_info
*debug_info_p
= &debug_information
[i
];
7242 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7244 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7245 range_entry_fill
->debug_info_p
= debug_info_p
;
7250 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7251 range_entry_compar
);
7253 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7254 warn (_("Range lists in %s section start at 0x%lx\n"),
7255 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7257 introduce (section
, FALSE
);
7259 printf (_(" Offset Begin End\n"));
7261 for (i
= 0; i
< num_range_list
; i
++)
7263 struct range_entry
*range_entry
= &range_entries
[i
];
7264 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7265 unsigned int pointer_size
;
7267 unsigned char *next
;
7268 dwarf_vma base_address
;
7270 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7271 offset
= range_entry
->ranges_offset
;
7272 next
= section_begin
+ offset
;
7273 base_address
= debug_info_p
->base_address
;
7275 /* PR 17512: file: 001-101485-0.001:0.1. */
7276 if (pointer_size
< 2 || pointer_size
> 8)
7278 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7279 pointer_size
, (unsigned long) offset
);
7283 if (next
< section_begin
|| next
>= finish
)
7285 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7286 (unsigned long) offset
, i
);
7290 /* If multiple DWARF entities reference the same range then we will
7291 have multiple entries in the `range_entries' list for the same
7292 offset. Thanks to the sort above these will all be consecutive in
7293 the `range_entries' list, so we can easily ignore duplicates
7295 if (i
> 0 && last_offset
== offset
)
7297 last_offset
= offset
;
7299 if (dwarf_check
!= 0 && i
> 0)
7302 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7303 (unsigned long) (start
- section_begin
),
7304 (unsigned long) (next
- section_begin
), section
->name
);
7305 else if (start
> next
)
7307 if (next
== last_start
)
7309 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7310 (unsigned long) (start
- section_begin
),
7311 (unsigned long) (next
- section_begin
), section
->name
);
7318 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7319 (start
, finish
, pointer_size
, offset
, base_address
);
7323 free (range_entries
);
7328 typedef struct Frame_Chunk
7330 struct Frame_Chunk
*next
;
7331 unsigned char *chunk_start
;
7333 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7334 short int *col_type
;
7337 unsigned int code_factor
;
7341 unsigned int cfa_reg
;
7342 dwarf_vma cfa_offset
;
7344 unsigned char fde_encoding
;
7345 unsigned char cfa_exp
;
7346 unsigned char ptr_size
;
7347 unsigned char segment_size
;
7351 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7352 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7353 static const char *const *dwarf_regnames
;
7354 static unsigned int dwarf_regnames_count
;
7357 /* A marker for a col_type that means this column was never referenced
7358 in the frame info. */
7359 #define DW_CFA_unreferenced (-1)
7361 /* Return 0 if no more space is needed, 1 if more space is needed,
7362 -1 for invalid reg. */
7365 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7367 unsigned int prev
= fc
->ncols
;
7369 if (reg
< (unsigned int) fc
->ncols
)
7372 if (dwarf_regnames_count
> 0
7373 && reg
> dwarf_regnames_count
)
7376 fc
->ncols
= reg
+ 1;
7377 /* PR 17512: file: 10450-2643-0.004.
7378 If reg == -1 then this can happen... */
7382 /* PR 17512: file: 2844a11d. */
7383 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7385 error (_("Unfeasibly large register number: %u\n"), reg
);
7387 /* FIXME: 1024 is an arbitrary limit. Increase it if
7388 we ever encounter a valid binary that exceeds it. */
7392 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7393 sizeof (short int));
7394 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7395 /* PR 17512: file:002-10025-0.005. */
7396 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7398 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7404 while (prev
< fc
->ncols
)
7406 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7407 fc
->col_offset
[prev
] = 0;
7413 static const char *const dwarf_regnames_i386
[] =
7415 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7416 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7417 "eip", "eflags", NULL
, /* 8 - 10 */
7418 "st0", "st1", "st2", "st3", /* 11 - 14 */
7419 "st4", "st5", "st6", "st7", /* 15 - 18 */
7420 NULL
, NULL
, /* 19 - 20 */
7421 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7422 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7423 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7424 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7425 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7426 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7427 "tr", "ldtr", /* 48 - 49 */
7428 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7429 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7430 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7431 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7432 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7433 NULL
, NULL
, NULL
, /* 90 - 92 */
7434 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7437 static const char *const dwarf_regnames_iamcu
[] =
7439 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7440 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7441 "eip", "eflags", NULL
, /* 8 - 10 */
7442 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7443 NULL
, NULL
, /* 19 - 20 */
7444 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7445 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7446 NULL
, NULL
, NULL
, /* 37 - 39 */
7447 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7448 "tr", "ldtr", /* 48 - 49 */
7449 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7450 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7451 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7452 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7453 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7454 NULL
, NULL
, NULL
, /* 90 - 92 */
7455 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7459 init_dwarf_regnames_i386 (void)
7461 dwarf_regnames
= dwarf_regnames_i386
;
7462 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7463 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7467 init_dwarf_regnames_iamcu (void)
7469 dwarf_regnames
= dwarf_regnames_iamcu
;
7470 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7471 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7474 static const char *const dwarf_regnames_x86_64
[] =
7476 "rax", "rdx", "rcx", "rbx",
7477 "rsi", "rdi", "rbp", "rsp",
7478 "r8", "r9", "r10", "r11",
7479 "r12", "r13", "r14", "r15",
7481 "xmm0", "xmm1", "xmm2", "xmm3",
7482 "xmm4", "xmm5", "xmm6", "xmm7",
7483 "xmm8", "xmm9", "xmm10", "xmm11",
7484 "xmm12", "xmm13", "xmm14", "xmm15",
7485 "st0", "st1", "st2", "st3",
7486 "st4", "st5", "st6", "st7",
7487 "mm0", "mm1", "mm2", "mm3",
7488 "mm4", "mm5", "mm6", "mm7",
7490 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7491 "fs.base", "gs.base", NULL
, NULL
,
7493 "mxcsr", "fcw", "fsw",
7494 "xmm16", "xmm17", "xmm18", "xmm19",
7495 "xmm20", "xmm21", "xmm22", "xmm23",
7496 "xmm24", "xmm25", "xmm26", "xmm27",
7497 "xmm28", "xmm29", "xmm30", "xmm31",
7498 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7499 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7500 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7501 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7502 NULL
, NULL
, NULL
, /* 115 - 117 */
7503 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7507 init_dwarf_regnames_x86_64 (void)
7509 dwarf_regnames
= dwarf_regnames_x86_64
;
7510 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7511 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7514 static const char *const dwarf_regnames_aarch64
[] =
7516 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7517 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7518 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7519 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7520 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7521 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7522 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7523 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7524 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7525 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7526 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7527 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7528 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7529 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7530 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7531 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7535 init_dwarf_regnames_aarch64 (void)
7537 dwarf_regnames
= dwarf_regnames_aarch64
;
7538 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7539 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7542 static const char *const dwarf_regnames_s390
[] =
7544 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7545 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7546 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7547 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7548 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7549 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7550 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7551 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7552 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7555 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7556 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7560 init_dwarf_regnames_s390 (void)
7562 dwarf_regnames
= dwarf_regnames_s390
;
7563 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7564 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7567 static const char *const dwarf_regnames_riscv
[] =
7569 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7570 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7571 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7572 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7573 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7574 "fs0", "fs1", /* 40 - 41 */
7575 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7576 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7577 "fs10", "fs11", /* 58 - 59 */
7578 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7581 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7582 the large number of CSRs. */
7585 regname_internal_riscv (unsigned int regno
)
7587 const char *name
= NULL
;
7589 /* Lookup in the table first, this covers GPR and FPR. */
7590 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7591 name
= dwarf_regnames_riscv
[regno
];
7592 else if (regno
>= 4096 && regno
<= 8191)
7594 /* This might be a CSR, these live in a sparse number space from 4096
7595 to 8191 These numbers are defined in the RISC-V ELF ABI
7599 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
7600 case VALUE + 4096: name = #NAME; break;
7601 #include "opcode/riscv-opc.h"
7606 static char csr_name
[10];
7607 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7618 init_dwarf_regnames_riscv (void)
7620 dwarf_regnames
= NULL
;
7621 dwarf_regnames_count
= 8192;
7622 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7626 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7628 dwarf_regnames_lookup_func
= NULL
;
7633 init_dwarf_regnames_i386 ();
7637 init_dwarf_regnames_iamcu ();
7643 init_dwarf_regnames_x86_64 ();
7647 init_dwarf_regnames_aarch64 ();
7651 init_dwarf_regnames_s390 ();
7655 init_dwarf_regnames_riscv ();
7663 /* Initialize the DWARF register name lookup state based on the
7664 architecture and specific machine type of a BFD. */
7667 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7670 dwarf_regnames_lookup_func
= NULL
;
7677 case bfd_mach_x86_64
:
7678 case bfd_mach_x86_64_intel_syntax
:
7679 case bfd_mach_x64_32
:
7680 case bfd_mach_x64_32_intel_syntax
:
7681 init_dwarf_regnames_x86_64 ();
7685 init_dwarf_regnames_i386 ();
7690 case bfd_arch_iamcu
:
7691 init_dwarf_regnames_iamcu ();
7694 case bfd_arch_aarch64
:
7695 init_dwarf_regnames_aarch64();
7699 init_dwarf_regnames_s390 ();
7702 case bfd_arch_riscv
:
7703 init_dwarf_regnames_riscv ();
7712 regname_internal_by_table_only (unsigned int regno
)
7714 if (dwarf_regnames
!= NULL
7715 && regno
< dwarf_regnames_count
7716 && dwarf_regnames
[regno
] != NULL
)
7717 return dwarf_regnames
[regno
];
7723 regname (unsigned int regno
, int name_only_p
)
7725 static char reg
[64];
7727 const char *name
= NULL
;
7729 if (dwarf_regnames_lookup_func
!= NULL
)
7730 name
= dwarf_regnames_lookup_func (regno
);
7736 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7739 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7744 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7749 if (*max_regs
!= fc
->ncols
)
7750 *max_regs
= fc
->ncols
;
7752 if (*need_col_headers
)
7754 static const char *sloc
= " LOC";
7756 *need_col_headers
= 0;
7758 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7760 for (r
= 0; r
< *max_regs
; r
++)
7761 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7766 printf ("%-5s ", regname (r
, 1));
7772 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7774 strcpy (tmp
, "exp");
7776 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7777 printf ("%-8s ", tmp
);
7779 for (r
= 0; r
< fc
->ncols
; r
++)
7781 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7783 switch (fc
->col_type
[r
])
7785 case DW_CFA_undefined
:
7788 case DW_CFA_same_value
:
7792 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7794 case DW_CFA_val_offset
:
7795 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7797 case DW_CFA_register
:
7798 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7800 case DW_CFA_expression
:
7801 strcpy (tmp
, "exp");
7803 case DW_CFA_val_expression
:
7804 strcpy (tmp
, "vexp");
7807 strcpy (tmp
, "n/a");
7810 printf ("%-5s ", tmp
);
7816 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7818 static unsigned char *
7819 read_cie (unsigned char *start
, unsigned char *end
,
7820 Frame_Chunk
**p_cie
, int *p_version
,
7821 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7825 unsigned char *augmentation_data
= NULL
;
7826 bfd_size_type augmentation_data_len
= 0;
7829 /* PR 17512: file: 001-228113-0.004. */
7833 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7834 memset (fc
, 0, sizeof (Frame_Chunk
));
7836 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7837 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7841 fc
->augmentation
= (char *) start
;
7842 /* PR 17512: file: 001-228113-0.004.
7843 Skip past augmentation name, but avoid running off the end of the data. */
7845 if (* start
++ == '\0')
7849 warn (_("No terminator for augmentation name\n"));
7853 if (strcmp (fc
->augmentation
, "eh") == 0)
7854 start
+= eh_addr_size
;
7858 GET (fc
->ptr_size
, 1);
7859 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7861 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7865 GET (fc
->segment_size
, 1);
7866 /* PR 17512: file: e99d2804. */
7867 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7869 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7873 eh_addr_size
= fc
->ptr_size
;
7877 fc
->ptr_size
= eh_addr_size
;
7878 fc
->segment_size
= 0;
7881 READ_ULEB (fc
->code_factor
, start
, end
);
7882 READ_SLEB (fc
->data_factor
, start
, end
);
7890 READ_ULEB (fc
->ra
, start
, end
);
7893 if (fc
->augmentation
[0] == 'z')
7895 READ_ULEB (augmentation_data_len
, start
, end
);
7896 augmentation_data
= start
;
7897 /* PR 17512: file: 11042-2589-0.004. */
7898 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7900 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7901 dwarf_vmatoa ("x", augmentation_data_len
),
7902 (unsigned long) (end
- start
));
7905 start
+= augmentation_data_len
;
7908 if (augmentation_data_len
)
7912 unsigned char *qend
;
7914 p
= (unsigned char *) fc
->augmentation
+ 1;
7915 q
= augmentation_data
;
7916 qend
= q
+ augmentation_data_len
;
7918 while (p
< end
&& q
< qend
)
7923 q
+= 1 + size_of_encoded_value (*q
);
7925 fc
->fde_encoding
= *q
++;
7934 /* Note - it is OK if this loop terminates with q < qend.
7935 Padding may have been inserted to align the end of the CIE. */
7940 *p_version
= version
;
7943 *p_aug_len
= augmentation_data_len
;
7944 *p_aug
= augmentation_data
;
7949 free (fc
->col_offset
);
7950 free (fc
->col_type
);
7955 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7956 If do_wide is not enabled, then formats the output to fit into 80 columns.
7957 PRINTED contains the number of characters already written to the current
7961 display_data (bfd_size_type printed
,
7962 const unsigned char * data
,
7963 const bfd_size_type len
)
7965 if (do_wide
|| len
< ((80 - printed
) / 3))
7966 for (printed
= 0; printed
< len
; ++printed
)
7967 printf (" %02x", data
[printed
]);
7970 for (printed
= 0; printed
< len
; ++printed
)
7972 if (printed
% (80 / 3) == 0)
7974 printf (" %02x", data
[printed
]);
7979 /* Prints out the contents on the augmentation data array.
7980 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7983 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7987 i
= printf (_(" Augmentation data: "));
7988 display_data (i
, data
, len
);
7992 display_debug_frames (struct dwarf_section
*section
,
7993 void *file ATTRIBUTE_UNUSED
)
7995 unsigned char *start
= section
->start
;
7996 unsigned char *end
= start
+ section
->size
;
7997 unsigned char *section_start
= start
;
7998 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7999 Frame_Chunk
*remembered_state
= NULL
;
8001 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8002 unsigned int max_regs
= 0;
8003 const char *bad_reg
= _("bad register: ");
8004 unsigned int saved_eh_addr_size
= eh_addr_size
;
8006 introduce (section
, FALSE
);
8010 unsigned char *saved_start
;
8011 unsigned char *block_end
;
8016 int need_col_headers
= 1;
8017 unsigned char *augmentation_data
= NULL
;
8018 bfd_size_type augmentation_data_len
= 0;
8019 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8020 unsigned int offset_size
;
8021 unsigned int initial_length_size
;
8022 bfd_boolean all_nops
;
8023 static Frame_Chunk fde_fc
;
8025 saved_start
= start
;
8027 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8031 printf ("\n%08lx ZERO terminator\n\n",
8032 (unsigned long)(saved_start
- section_start
));
8033 /* Skip any zero terminators that directly follow.
8034 A corrupt section size could have loaded a whole
8035 slew of zero filled memory bytes. eg
8036 PR 17512: file: 070-19381-0.004. */
8037 while (start
< end
&& * start
== 0)
8042 if (length
== 0xffffffff)
8044 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8046 initial_length_size
= 12;
8051 initial_length_size
= 4;
8054 block_end
= saved_start
+ length
+ initial_length_size
;
8055 if (block_end
> end
|| block_end
< start
)
8057 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8058 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8059 (unsigned long) (saved_start
- section_start
));
8063 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8065 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8066 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8071 start
= read_cie (start
, end
, &cie
, &version
,
8072 &augmentation_data_len
, &augmentation_data
);
8073 /* PR 17512: file: 027-135133-0.005. */
8080 fc
->chunk_start
= saved_start
;
8081 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8084 if (frame_need_space (fc
, mreg
) < 0)
8086 if (fc
->fde_encoding
)
8087 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8089 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8090 print_dwarf_vma (length
, fc
->ptr_size
);
8091 print_dwarf_vma (cie_id
, offset_size
);
8093 if (do_debug_frames_interp
)
8095 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8096 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8101 printf (" Version: %d\n", version
);
8102 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8105 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8106 printf (" Segment Size: %u\n", fc
->segment_size
);
8108 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8109 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8110 printf (" Return address column: %d\n", fc
->ra
);
8112 if (augmentation_data_len
)
8113 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8120 unsigned char *look_for
;
8121 unsigned long segment_selector
;
8125 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8126 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8129 look_for
= section_start
+ cie_id
;
8131 if (look_for
<= saved_start
)
8133 for (cie
= chunks
; cie
; cie
= cie
->next
)
8134 if (cie
->chunk_start
== look_for
)
8139 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8140 if (cie
->chunk_start
== look_for
)
8144 unsigned int off_size
;
8145 unsigned char *cie_scan
;
8147 cie_scan
= look_for
;
8149 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8150 if (length
== 0xffffffff)
8152 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8159 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8162 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8163 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8168 read_cie (cie_scan
, end
, &cie
, &version
,
8169 &augmentation_data_len
, &augmentation_data
);
8170 /* PR 17512: file: 3450-2098-0.004. */
8173 warn (_("Failed to read CIE information\n"));
8176 cie
->next
= forward_refs
;
8178 cie
->chunk_start
= look_for
;
8179 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8182 if (frame_need_space (cie
, mreg
) < 0)
8184 warn (_("Invalid max register\n"));
8187 if (cie
->fde_encoding
)
8189 = size_of_encoded_value (cie
->fde_encoding
);
8196 memset (fc
, 0, sizeof (Frame_Chunk
));
8200 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8201 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8202 (unsigned long) (saved_start
- section_start
));
8204 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8205 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8206 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8208 warn (_("Invalid max register\n"));
8212 fc
->augmentation
= "";
8213 fc
->fde_encoding
= 0;
8214 fc
->ptr_size
= eh_addr_size
;
8215 fc
->segment_size
= 0;
8219 fc
->ncols
= cie
->ncols
;
8220 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8221 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8222 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8223 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8224 fc
->augmentation
= cie
->augmentation
;
8225 fc
->ptr_size
= cie
->ptr_size
;
8226 eh_addr_size
= cie
->ptr_size
;
8227 fc
->segment_size
= cie
->segment_size
;
8228 fc
->code_factor
= cie
->code_factor
;
8229 fc
->data_factor
= cie
->data_factor
;
8230 fc
->cfa_reg
= cie
->cfa_reg
;
8231 fc
->cfa_offset
= cie
->cfa_offset
;
8233 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8235 warn (_("Invalid max register\n"));
8238 fc
->fde_encoding
= cie
->fde_encoding
;
8241 if (fc
->fde_encoding
)
8242 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8244 segment_selector
= 0;
8245 if (fc
->segment_size
)
8247 if (fc
->segment_size
> sizeof (segment_selector
))
8249 /* PR 17512: file: 9e196b3e. */
8250 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8251 fc
->segment_size
= 4;
8253 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8256 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8258 /* FIXME: It appears that sometimes the final pc_range value is
8259 encoded in less than encoded_ptr_size bytes. See the x86_64
8260 run of the "objcopy on compressed debug sections" test for an
8262 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8264 if (cie
->augmentation
[0] == 'z')
8266 READ_ULEB (augmentation_data_len
, start
, end
);
8267 augmentation_data
= start
;
8268 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8269 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8271 warn (_("Augmentation data too long: 0x%s, "
8272 "expected at most %#lx\n"),
8273 dwarf_vmatoa ("x", augmentation_data_len
),
8274 (unsigned long) (end
- start
));
8276 augmentation_data
= NULL
;
8277 augmentation_data_len
= 0;
8279 start
+= augmentation_data_len
;
8282 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8283 (unsigned long)(saved_start
- section_start
),
8284 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8285 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8286 (unsigned long)(cie
->chunk_start
- section_start
));
8288 if (fc
->segment_size
)
8289 printf ("%04lx:", segment_selector
);
8292 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8293 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8295 if (! do_debug_frames_interp
&& augmentation_data_len
)
8297 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8302 /* At this point, fc is the current chunk, cie (if any) is set, and
8303 we're about to interpret instructions for the chunk. */
8304 /* ??? At present we need to do this always, since this sizes the
8305 fc->col_type and fc->col_offset arrays, which we write into always.
8306 We should probably split the interpreted and non-interpreted bits
8307 into two different routines, since there's so much that doesn't
8308 really overlap between them. */
8309 if (1 || do_debug_frames_interp
)
8311 /* Start by making a pass over the chunk, allocating storage
8312 and taking note of what registers are used. */
8313 unsigned char *tmp
= start
;
8315 while (start
< block_end
)
8317 unsigned int reg
, op
, opa
;
8319 unsigned char * new_start
;
8326 /* Warning: if you add any more cases to this switch, be
8327 sure to add them to the corresponding switch below. */
8330 case DW_CFA_advance_loc
:
8333 SKIP_ULEB (start
, end
);
8334 if (frame_need_space (fc
, opa
) >= 0)
8335 fc
->col_type
[opa
] = DW_CFA_undefined
;
8337 case DW_CFA_restore
:
8338 if (frame_need_space (fc
, opa
) >= 0)
8339 fc
->col_type
[opa
] = DW_CFA_undefined
;
8341 case DW_CFA_set_loc
:
8342 start
+= encoded_ptr_size
;
8344 case DW_CFA_advance_loc1
:
8347 case DW_CFA_advance_loc2
:
8350 case DW_CFA_advance_loc4
:
8353 case DW_CFA_offset_extended
:
8354 case DW_CFA_val_offset
:
8355 READ_ULEB (reg
, start
, end
);
8356 SKIP_ULEB (start
, end
);
8357 if (frame_need_space (fc
, reg
) >= 0)
8358 fc
->col_type
[reg
] = DW_CFA_undefined
;
8360 case DW_CFA_restore_extended
:
8361 READ_ULEB (reg
, start
, end
);
8362 if (frame_need_space (fc
, reg
) >= 0)
8363 fc
->col_type
[reg
] = DW_CFA_undefined
;
8365 case DW_CFA_undefined
:
8366 READ_ULEB (reg
, start
, end
);
8367 if (frame_need_space (fc
, reg
) >= 0)
8368 fc
->col_type
[reg
] = DW_CFA_undefined
;
8370 case DW_CFA_same_value
:
8371 READ_ULEB (reg
, start
, end
);
8372 if (frame_need_space (fc
, reg
) >= 0)
8373 fc
->col_type
[reg
] = DW_CFA_undefined
;
8375 case DW_CFA_register
:
8376 READ_ULEB (reg
, start
, end
);
8377 SKIP_ULEB (start
, end
);
8378 if (frame_need_space (fc
, reg
) >= 0)
8379 fc
->col_type
[reg
] = DW_CFA_undefined
;
8381 case DW_CFA_def_cfa
:
8382 SKIP_ULEB (start
, end
);
8383 SKIP_ULEB (start
, end
);
8385 case DW_CFA_def_cfa_register
:
8386 SKIP_ULEB (start
, end
);
8388 case DW_CFA_def_cfa_offset
:
8389 SKIP_ULEB (start
, end
);
8391 case DW_CFA_def_cfa_expression
:
8392 READ_ULEB (temp
, start
, end
);
8393 new_start
= start
+ temp
;
8394 if (new_start
< start
)
8396 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8402 case DW_CFA_expression
:
8403 case DW_CFA_val_expression
:
8404 READ_ULEB (reg
, start
, end
);
8405 READ_ULEB (temp
, start
, end
);
8406 new_start
= start
+ temp
;
8407 if (new_start
< start
)
8409 /* PR 17512: file:306-192417-0.005. */
8410 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8415 if (frame_need_space (fc
, reg
) >= 0)
8416 fc
->col_type
[reg
] = DW_CFA_undefined
;
8418 case DW_CFA_offset_extended_sf
:
8419 case DW_CFA_val_offset_sf
:
8420 READ_ULEB (reg
, start
, end
);
8421 SKIP_SLEB (start
, end
);
8422 if (frame_need_space (fc
, reg
) >= 0)
8423 fc
->col_type
[reg
] = DW_CFA_undefined
;
8425 case DW_CFA_def_cfa_sf
:
8426 SKIP_ULEB (start
, end
);
8427 SKIP_SLEB (start
, end
);
8429 case DW_CFA_def_cfa_offset_sf
:
8430 SKIP_SLEB (start
, end
);
8432 case DW_CFA_MIPS_advance_loc8
:
8435 case DW_CFA_GNU_args_size
:
8436 SKIP_ULEB (start
, end
);
8438 case DW_CFA_GNU_negative_offset_extended
:
8439 READ_ULEB (reg
, start
, end
);
8440 SKIP_ULEB (start
, end
);
8441 if (frame_need_space (fc
, reg
) >= 0)
8442 fc
->col_type
[reg
] = DW_CFA_undefined
;
8453 /* Now we know what registers are used, make a second pass over
8454 the chunk, this time actually printing out the info. */
8456 while (start
< block_end
)
8458 unsigned char * tmp
;
8460 unsigned long ul
, roffs
;
8461 /* Note: It is tempting to use an unsigned long for 'reg' but there
8462 are various functions, notably frame_space_needed() that assume that
8463 reg is an unsigned int. */
8468 const char *reg_prefix
= "";
8475 /* Make a note if something other than DW_CFA_nop happens. */
8476 if (op
!= DW_CFA_nop
)
8479 /* Warning: if you add any more cases to this switch, be
8480 sure to add them to the corresponding switch above. */
8483 case DW_CFA_advance_loc
:
8484 if (do_debug_frames_interp
)
8485 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8487 printf (" DW_CFA_advance_loc: %d to %s\n",
8488 opa
* fc
->code_factor
,
8489 dwarf_vmatoa_1 (NULL
,
8490 fc
->pc_begin
+ opa
* fc
->code_factor
,
8492 fc
->pc_begin
+= opa
* fc
->code_factor
;
8496 READ_ULEB (roffs
, start
, end
);
8497 if (opa
>= (unsigned int) fc
->ncols
)
8498 reg_prefix
= bad_reg
;
8499 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8500 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8501 reg_prefix
, regname (opa
, 0),
8502 roffs
* fc
->data_factor
);
8503 if (*reg_prefix
== '\0')
8505 fc
->col_type
[opa
] = DW_CFA_offset
;
8506 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8510 case DW_CFA_restore
:
8511 if (opa
>= (unsigned int) fc
->ncols
)
8512 reg_prefix
= bad_reg
;
8513 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8514 printf (" DW_CFA_restore: %s%s\n",
8515 reg_prefix
, regname (opa
, 0));
8516 if (*reg_prefix
!= '\0')
8519 if (opa
>= (unsigned int) cie
->ncols
8520 || (do_debug_frames_interp
8521 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8523 fc
->col_type
[opa
] = DW_CFA_undefined
;
8524 fc
->col_offset
[opa
] = 0;
8528 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8529 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8533 case DW_CFA_set_loc
:
8534 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8535 if (do_debug_frames_interp
)
8536 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8538 printf (" DW_CFA_set_loc: %s\n",
8539 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8543 case DW_CFA_advance_loc1
:
8544 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8545 if (do_debug_frames_interp
)
8546 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8548 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8549 (unsigned long) (ofs
* fc
->code_factor
),
8550 dwarf_vmatoa_1 (NULL
,
8551 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8553 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8556 case DW_CFA_advance_loc2
:
8557 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8558 if (do_debug_frames_interp
)
8559 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8561 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8562 (unsigned long) (ofs
* fc
->code_factor
),
8563 dwarf_vmatoa_1 (NULL
,
8564 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8566 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8569 case DW_CFA_advance_loc4
:
8570 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8571 if (do_debug_frames_interp
)
8572 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8574 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8575 (unsigned long) (ofs
* fc
->code_factor
),
8576 dwarf_vmatoa_1 (NULL
,
8577 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8579 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8582 case DW_CFA_offset_extended
:
8583 READ_ULEB (reg
, start
, end
);
8584 READ_ULEB (roffs
, start
, end
);
8585 if (reg
>= (unsigned int) fc
->ncols
)
8586 reg_prefix
= bad_reg
;
8587 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8588 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8589 reg_prefix
, regname (reg
, 0),
8590 roffs
* fc
->data_factor
);
8591 if (*reg_prefix
== '\0')
8593 fc
->col_type
[reg
] = DW_CFA_offset
;
8594 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8598 case DW_CFA_val_offset
:
8599 READ_ULEB (reg
, start
, end
);
8600 READ_ULEB (roffs
, 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_val_offset: %s%s is cfa%+ld\n",
8605 reg_prefix
, regname (reg
, 0),
8606 roffs
* fc
->data_factor
);
8607 if (*reg_prefix
== '\0')
8609 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8610 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8614 case DW_CFA_restore_extended
:
8615 READ_ULEB (reg
, start
, end
);
8616 if (reg
>= (unsigned int) fc
->ncols
)
8617 reg_prefix
= bad_reg
;
8618 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8619 printf (" DW_CFA_restore_extended: %s%s\n",
8620 reg_prefix
, regname (reg
, 0));
8621 if (*reg_prefix
!= '\0')
8624 if (reg
>= (unsigned int) cie
->ncols
)
8626 fc
->col_type
[reg
] = DW_CFA_undefined
;
8627 fc
->col_offset
[reg
] = 0;
8631 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8632 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8636 case DW_CFA_undefined
:
8637 READ_ULEB (reg
, start
, end
);
8638 if (reg
>= (unsigned int) fc
->ncols
)
8639 reg_prefix
= bad_reg
;
8640 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8641 printf (" DW_CFA_undefined: %s%s\n",
8642 reg_prefix
, regname (reg
, 0));
8643 if (*reg_prefix
== '\0')
8645 fc
->col_type
[reg
] = DW_CFA_undefined
;
8646 fc
->col_offset
[reg
] = 0;
8650 case DW_CFA_same_value
:
8651 READ_ULEB (reg
, start
, end
);
8652 if (reg
>= (unsigned int) fc
->ncols
)
8653 reg_prefix
= bad_reg
;
8654 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8655 printf (" DW_CFA_same_value: %s%s\n",
8656 reg_prefix
, regname (reg
, 0));
8657 if (*reg_prefix
== '\0')
8659 fc
->col_type
[reg
] = DW_CFA_same_value
;
8660 fc
->col_offset
[reg
] = 0;
8664 case DW_CFA_register
:
8665 READ_ULEB (reg
, start
, end
);
8666 READ_ULEB (roffs
, start
, end
);
8667 if (reg
>= (unsigned int) fc
->ncols
)
8668 reg_prefix
= bad_reg
;
8669 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8671 printf (" DW_CFA_register: %s%s in ",
8672 reg_prefix
, regname (reg
, 0));
8673 puts (regname (roffs
, 0));
8675 if (*reg_prefix
== '\0')
8677 fc
->col_type
[reg
] = DW_CFA_register
;
8678 fc
->col_offset
[reg
] = roffs
;
8682 case DW_CFA_remember_state
:
8683 if (! do_debug_frames_interp
)
8684 printf (" DW_CFA_remember_state\n");
8685 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8686 rs
->cfa_offset
= fc
->cfa_offset
;
8687 rs
->cfa_reg
= fc
->cfa_reg
;
8689 rs
->cfa_exp
= fc
->cfa_exp
;
8690 rs
->ncols
= fc
->ncols
;
8691 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8692 sizeof (* rs
->col_type
));
8693 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8694 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8695 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8696 rs
->next
= remembered_state
;
8697 remembered_state
= rs
;
8700 case DW_CFA_restore_state
:
8701 if (! do_debug_frames_interp
)
8702 printf (" DW_CFA_restore_state\n");
8703 rs
= remembered_state
;
8706 remembered_state
= rs
->next
;
8707 fc
->cfa_offset
= rs
->cfa_offset
;
8708 fc
->cfa_reg
= rs
->cfa_reg
;
8710 fc
->cfa_exp
= rs
->cfa_exp
;
8711 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8713 warn (_("Invalid column number in saved frame state\n"));
8717 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8718 memcpy (fc
->col_offset
, rs
->col_offset
,
8719 rs
->ncols
* sizeof (* rs
->col_offset
));
8720 free (rs
->col_type
);
8721 free (rs
->col_offset
);
8724 else if (do_debug_frames_interp
)
8725 printf ("Mismatched DW_CFA_restore_state\n");
8728 case DW_CFA_def_cfa
:
8729 READ_ULEB (fc
->cfa_reg
, start
, end
);
8730 READ_ULEB (fc
->cfa_offset
, start
, end
);
8732 if (! do_debug_frames_interp
)
8733 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8734 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8737 case DW_CFA_def_cfa_register
:
8738 READ_ULEB (fc
->cfa_reg
, start
, end
);
8740 if (! do_debug_frames_interp
)
8741 printf (" DW_CFA_def_cfa_register: %s\n",
8742 regname (fc
->cfa_reg
, 0));
8745 case DW_CFA_def_cfa_offset
:
8746 READ_ULEB (fc
->cfa_offset
, start
, end
);
8747 if (! do_debug_frames_interp
)
8748 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8752 if (! do_debug_frames_interp
)
8753 printf (" DW_CFA_nop\n");
8756 case DW_CFA_def_cfa_expression
:
8757 READ_ULEB (ul
, start
, end
);
8758 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8760 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8763 if (! do_debug_frames_interp
)
8765 printf (" DW_CFA_def_cfa_expression (");
8766 decode_location_expression (start
, eh_addr_size
, 0, -1,
8774 case DW_CFA_expression
:
8775 READ_ULEB (reg
, start
, end
);
8776 READ_ULEB (ul
, start
, end
);
8777 if (reg
>= (unsigned int) fc
->ncols
)
8778 reg_prefix
= bad_reg
;
8779 /* PR 17512: file: 069-133014-0.006. */
8780 /* PR 17512: file: 98c02eb4. */
8782 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8784 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8787 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8789 printf (" DW_CFA_expression: %s%s (",
8790 reg_prefix
, regname (reg
, 0));
8791 decode_location_expression (start
, eh_addr_size
, 0, -1,
8795 if (*reg_prefix
== '\0')
8796 fc
->col_type
[reg
] = DW_CFA_expression
;
8800 case DW_CFA_val_expression
:
8801 READ_ULEB (reg
, start
, end
);
8802 READ_ULEB (ul
, start
, end
);
8803 if (reg
>= (unsigned int) fc
->ncols
)
8804 reg_prefix
= bad_reg
;
8806 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8808 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8811 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8813 printf (" DW_CFA_val_expression: %s%s (",
8814 reg_prefix
, regname (reg
, 0));
8815 decode_location_expression (start
, eh_addr_size
, 0, -1,
8819 if (*reg_prefix
== '\0')
8820 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8824 case DW_CFA_offset_extended_sf
:
8825 READ_ULEB (reg
, start
, end
);
8826 READ_SLEB (l
, start
, end
);
8827 if (frame_need_space (fc
, reg
) < 0)
8828 reg_prefix
= bad_reg
;
8829 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8830 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8831 reg_prefix
, regname (reg
, 0),
8832 (long)(l
* fc
->data_factor
));
8833 if (*reg_prefix
== '\0')
8835 fc
->col_type
[reg
] = DW_CFA_offset
;
8836 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8840 case DW_CFA_val_offset_sf
:
8841 READ_ULEB (reg
, start
, end
);
8842 READ_SLEB (l
, start
, end
);
8843 if (frame_need_space (fc
, reg
) < 0)
8844 reg_prefix
= bad_reg
;
8845 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8846 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8847 reg_prefix
, regname (reg
, 0),
8848 (long)(l
* fc
->data_factor
));
8849 if (*reg_prefix
== '\0')
8851 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8852 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8856 case DW_CFA_def_cfa_sf
:
8857 READ_ULEB (fc
->cfa_reg
, start
, end
);
8858 READ_ULEB (fc
->cfa_offset
, start
, end
);
8859 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8861 if (! do_debug_frames_interp
)
8862 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8863 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8866 case DW_CFA_def_cfa_offset_sf
:
8867 READ_ULEB (fc
->cfa_offset
, start
, end
);
8868 fc
->cfa_offset
*= fc
->data_factor
;
8869 if (! do_debug_frames_interp
)
8870 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8873 case DW_CFA_MIPS_advance_loc8
:
8874 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8875 if (do_debug_frames_interp
)
8876 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8878 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8879 (unsigned long) (ofs
* fc
->code_factor
),
8880 dwarf_vmatoa_1 (NULL
,
8881 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8883 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8886 case DW_CFA_GNU_window_save
:
8887 if (! do_debug_frames_interp
)
8888 printf (" DW_CFA_GNU_window_save\n");
8891 case DW_CFA_GNU_args_size
:
8892 READ_ULEB (ul
, start
, end
);
8893 if (! do_debug_frames_interp
)
8894 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8897 case DW_CFA_GNU_negative_offset_extended
:
8898 READ_ULEB (reg
, start
, end
);
8899 READ_SLEB (l
, start
, end
);
8901 if (frame_need_space (fc
, reg
) < 0)
8902 reg_prefix
= bad_reg
;
8903 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8904 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8905 reg_prefix
, regname (reg
, 0),
8906 (long)(l
* fc
->data_factor
));
8907 if (*reg_prefix
== '\0')
8909 fc
->col_type
[reg
] = DW_CFA_offset
;
8910 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8915 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8916 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8918 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8923 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8924 if (do_debug_frames_interp
&& ! all_nops
)
8925 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8927 if (fde_fc
.col_type
!= NULL
)
8929 free (fde_fc
.col_type
);
8930 fde_fc
.col_type
= NULL
;
8932 if (fde_fc
.col_offset
!= NULL
)
8934 free (fde_fc
.col_offset
);
8935 fde_fc
.col_offset
= NULL
;
8939 eh_addr_size
= saved_eh_addr_size
;
8944 while (remembered_state
!= NULL
)
8946 rs
= remembered_state
;
8947 remembered_state
= rs
->next
;
8948 free (rs
->col_type
);
8949 free (rs
->col_offset
);
8950 rs
->next
= NULL
; /* Paranoia. */
8954 while (chunks
!= NULL
)
8958 free (rs
->col_type
);
8959 free (rs
->col_offset
);
8960 rs
->next
= NULL
; /* Paranoia. */
8964 while (forward_refs
!= NULL
)
8967 forward_refs
= rs
->next
;
8968 free (rs
->col_type
);
8969 free (rs
->col_offset
);
8970 rs
->next
= NULL
; /* Paranoia. */
8980 display_debug_names (struct dwarf_section
*section
, void *file
)
8982 unsigned char *hdrptr
= section
->start
;
8983 dwarf_vma unit_length
;
8984 unsigned char *unit_start
;
8985 const unsigned char *const section_end
= section
->start
+ section
->size
;
8986 unsigned char *unit_end
;
8988 introduce (section
, FALSE
);
8990 load_debug_section_with_follow (str
, file
);
8992 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8994 unsigned int offset_size
;
8995 uint16_t dwarf_version
, padding
;
8996 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8997 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8998 uint32_t augmentation_string_size
;
9000 unsigned long sec_off
;
9001 bfd_boolean augmentation_printable
;
9002 const char *augmentation_string
;
9004 unit_start
= hdrptr
;
9006 /* Get and check the length of the block. */
9007 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9009 if (unit_length
== 0xffffffff)
9011 /* This section is 64-bit DWARF. */
9012 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9017 unit_end
= hdrptr
+ unit_length
;
9019 sec_off
= hdrptr
- section
->start
;
9020 if (sec_off
+ unit_length
< sec_off
9021 || sec_off
+ unit_length
> section
->size
)
9023 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9025 (unsigned long) (unit_start
- section
->start
),
9026 dwarf_vmatoa ("x", unit_length
));
9030 /* Get and check the version number. */
9031 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9032 printf (_("Version %ld\n"), (long) dwarf_version
);
9034 /* Prior versions did not exist, and future versions may not be
9035 backwards compatible. */
9036 if (dwarf_version
!= 5)
9038 warn (_("Only DWARF version 5 .debug_names "
9039 "is currently supported.\n"));
9043 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9045 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9048 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9049 if (comp_unit_count
== 0)
9050 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9052 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9053 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9054 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9055 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9056 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9058 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9059 if (augmentation_string_size
% 4 != 0)
9061 warn (_("Augmentation string length %u must be rounded up "
9062 "to a multiple of 4 in .debug_names.\n"),
9063 augmentation_string_size
);
9064 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9067 printf (_("Augmentation string:"));
9069 augmentation_printable
= TRUE
;
9070 augmentation_string
= (const char *) hdrptr
;
9072 for (i
= 0; i
< augmentation_string_size
; i
++)
9076 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9077 printf (" %02x", uc
);
9079 if (uc
!= 0 && !ISPRINT (uc
))
9080 augmentation_printable
= FALSE
;
9083 if (augmentation_printable
)
9087 i
< augmentation_string_size
&& augmentation_string
[i
];
9089 putchar (augmentation_string
[i
]);
9094 printf (_("CU table:\n"));
9095 for (i
= 0; i
< comp_unit_count
; i
++)
9099 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9100 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9104 printf (_("TU table:\n"));
9105 for (i
= 0; i
< local_type_unit_count
; i
++)
9109 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9110 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9114 printf (_("Foreign TU table:\n"));
9115 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9119 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9120 printf (_("[%3u] "), i
);
9121 print_dwarf_vma (signature
, 8);
9126 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9127 hdrptr
+= bucket_count
* sizeof (uint32_t);
9128 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9129 hdrptr
+= name_count
* sizeof (uint32_t);
9130 unsigned char *const name_table_string_offsets
= hdrptr
;
9131 hdrptr
+= name_count
* offset_size
;
9132 unsigned char *const name_table_entry_offsets
= hdrptr
;
9133 hdrptr
+= name_count
* offset_size
;
9134 unsigned char *const abbrev_table
= hdrptr
;
9135 hdrptr
+= abbrev_table_size
;
9136 const unsigned char *const abbrev_table_end
= hdrptr
;
9137 unsigned char *const entry_pool
= hdrptr
;
9138 if (hdrptr
> unit_end
)
9140 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9141 "for unit 0x%lx in the debug_names\n"),
9142 (long) (hdrptr
- section
->start
),
9143 (long) (unit_end
- section
->start
),
9144 (long) (unit_start
- section
->start
));
9148 size_t buckets_filled
= 0;
9150 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9152 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9157 printf (ngettext ("Used %zu of %lu bucket.\n",
9158 "Used %zu of %lu buckets.\n",
9160 buckets_filled
, (unsigned long) bucket_count
);
9162 uint32_t hash_prev
= 0;
9163 size_t hash_clash_count
= 0;
9164 size_t longest_clash
= 0;
9165 size_t this_length
= 0;
9167 for (hashi
= 0; hashi
< name_count
; hashi
++)
9169 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9173 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9177 longest_clash
= MAX (longest_clash
, this_length
);
9182 hash_prev
= hash_this
;
9184 printf (_("Out of %lu items there are %zu bucket clashes"
9185 " (longest of %zu entries).\n"),
9186 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9187 assert (name_count
== buckets_filled
+ hash_clash_count
);
9189 struct abbrev_lookup_entry
9191 dwarf_vma abbrev_tag
;
9192 unsigned char *abbrev_lookup_ptr
;
9194 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9195 size_t abbrev_lookup_used
= 0;
9196 size_t abbrev_lookup_allocated
= 0;
9198 unsigned char *abbrevptr
= abbrev_table
;
9201 dwarf_vma abbrev_tag
;
9203 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9204 if (abbrev_tag
== 0)
9206 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9208 abbrev_lookup_allocated
= MAX (0x100,
9209 abbrev_lookup_allocated
* 2);
9210 abbrev_lookup
= xrealloc (abbrev_lookup
,
9211 (abbrev_lookup_allocated
9212 * sizeof (*abbrev_lookup
)));
9214 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9215 struct abbrev_lookup_entry
*entry
;
9216 for (entry
= abbrev_lookup
;
9217 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9219 if (entry
->abbrev_tag
== abbrev_tag
)
9221 warn (_("Duplicate abbreviation tag %lu "
9222 "in unit 0x%lx in the debug_names\n"),
9223 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9226 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9227 entry
->abbrev_tag
= abbrev_tag
;
9228 entry
->abbrev_lookup_ptr
= abbrevptr
;
9230 /* Skip DWARF tag. */
9231 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9234 dwarf_vma xindex
, form
;
9236 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9237 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9238 if (xindex
== 0 && form
== 0)
9243 printf (_("\nSymbol table:\n"));
9245 for (namei
= 0; namei
< name_count
; ++namei
)
9247 uint64_t string_offset
, entry_offset
;
9249 SAFE_BYTE_GET (string_offset
,
9250 name_table_string_offsets
+ namei
* offset_size
,
9251 offset_size
, unit_end
);
9252 SAFE_BYTE_GET (entry_offset
,
9253 name_table_entry_offsets
+ namei
* offset_size
,
9254 offset_size
, unit_end
);
9256 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9257 fetch_indirect_string (string_offset
));
9259 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9261 /* We need to scan first whether there is a single or multiple
9262 entries. TAGNO is -2 for the first entry, it is -1 for the
9263 initial tag read of the second entry, then it becomes 0 for the
9264 first entry for real printing etc. */
9266 /* Initialize it due to a false compiler warning. */
9267 dwarf_vma second_abbrev_tag
= -1;
9270 dwarf_vma abbrev_tag
;
9271 dwarf_vma dwarf_tag
;
9272 const struct abbrev_lookup_entry
*entry
;
9274 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9277 second_abbrev_tag
= abbrev_tag
;
9279 entryptr
= entry_pool
+ entry_offset
;
9282 if (abbrev_tag
== 0)
9286 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9287 (unsigned long) abbrev_tag
);
9289 for (entry
= abbrev_lookup
;
9290 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9292 if (entry
->abbrev_tag
== abbrev_tag
)
9294 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9296 warn (_("Undefined abbreviation tag %lu "
9297 "in unit 0x%lx in the debug_names\n"),
9299 (long) (unit_start
- section
->start
));
9302 abbrevptr
= entry
->abbrev_lookup_ptr
;
9303 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9305 printf (" %s", get_TAG_name (dwarf_tag
));
9308 dwarf_vma xindex
, form
;
9310 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9311 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9312 if (xindex
== 0 && form
== 0)
9316 printf (" %s", get_IDX_name (xindex
));
9317 entryptr
= read_and_display_attr_value (0, form
, 0,
9318 unit_start
, entryptr
, unit_end
,
9320 dwarf_version
, NULL
,
9327 printf (_(" <no entries>"));
9331 free (abbrev_lookup
);
9338 display_debug_links (struct dwarf_section
* section
,
9339 void * file ATTRIBUTE_UNUSED
)
9341 const unsigned char * filename
;
9342 unsigned int filelen
;
9344 introduce (section
, FALSE
);
9346 /* The .gnu_debuglink section is formatted as:
9347 (c-string) Filename.
9348 (padding) If needed to reach a 4 byte boundary.
9349 (uint32_t) CRC32 value.
9351 The .gun_debugaltlink section is formatted as:
9352 (c-string) Filename.
9353 (binary) Build-ID. */
9355 filename
= section
->start
;
9356 filelen
= strnlen ((const char *) filename
, section
->size
);
9357 if (filelen
== section
->size
)
9359 warn (_("The debuglink filename is corrupt/missing\n"));
9363 printf (_(" Separate debug info file: %s\n"), filename
);
9365 if (const_strneq (section
->name
, ".gnu_debuglink"))
9368 unsigned int crc_offset
;
9370 crc_offset
= filelen
+ 1;
9371 crc_offset
= (crc_offset
+ 3) & ~3;
9372 if (crc_offset
+ 4 > section
->size
)
9374 warn (_("CRC offset missing/truncated\n"));
9378 crc32
= byte_get (filename
+ crc_offset
, 4);
9380 printf (_(" CRC value: %#x\n"), crc32
);
9382 if (crc_offset
+ 4 < section
->size
)
9384 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9385 (long)(section
->size
- (crc_offset
+ 4)));
9389 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9391 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9392 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9393 bfd_size_type printed
;
9395 /* FIXME: Should we support smaller build-id notes ? */
9396 if (build_id_len
< 0x14)
9398 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9402 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9403 display_data (printed
, build_id
, build_id_len
);
9412 display_gdb_index (struct dwarf_section
*section
,
9413 void *file ATTRIBUTE_UNUSED
)
9415 unsigned char *start
= section
->start
;
9417 uint32_t cu_list_offset
, tu_list_offset
;
9418 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9419 unsigned int cu_list_elements
, tu_list_elements
;
9420 unsigned int address_table_size
, symbol_table_slots
;
9421 unsigned char *cu_list
, *tu_list
;
9422 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9425 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9427 introduce (section
, FALSE
);
9429 if (section
->size
< 6 * sizeof (uint32_t))
9431 warn (_("Truncated header in the %s section.\n"), section
->name
);
9435 version
= byte_get_little_endian (start
, 4);
9436 printf (_("Version %ld\n"), (long) version
);
9438 /* Prior versions are obsolete, and future versions may not be
9439 backwards compatible. */
9440 if (version
< 3 || version
> 8)
9442 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9446 warn (_("The address table data in version 3 may be wrong.\n"));
9448 warn (_("Version 4 does not support case insensitive lookups.\n"));
9450 warn (_("Version 5 does not include inlined functions.\n"));
9452 warn (_("Version 6 does not include symbol attributes.\n"));
9453 /* Version 7 indices generated by Gold have bad type unit references,
9454 PR binutils/15021. But we don't know if the index was generated by
9455 Gold or not, so to avoid worrying users with gdb-generated indices
9456 we say nothing for version 7 here. */
9458 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9459 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9460 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9461 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9462 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9464 if (cu_list_offset
> section
->size
9465 || tu_list_offset
> section
->size
9466 || address_table_offset
> section
->size
9467 || symbol_table_offset
> section
->size
9468 || constant_pool_offset
> section
->size
)
9470 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9474 /* PR 17531: file: 418d0a8a. */
9475 if (tu_list_offset
< cu_list_offset
)
9477 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9478 tu_list_offset
, cu_list_offset
);
9482 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9484 if (address_table_offset
< tu_list_offset
)
9486 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9487 address_table_offset
, tu_list_offset
);
9491 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9493 /* PR 17531: file: 18a47d3d. */
9494 if (symbol_table_offset
< address_table_offset
)
9496 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9497 symbol_table_offset
, address_table_offset
);
9501 address_table_size
= symbol_table_offset
- address_table_offset
;
9503 if (constant_pool_offset
< symbol_table_offset
)
9505 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9506 constant_pool_offset
, symbol_table_offset
);
9510 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9512 cu_list
= start
+ cu_list_offset
;
9513 tu_list
= start
+ tu_list_offset
;
9514 address_table
= start
+ address_table_offset
;
9515 symbol_table
= start
+ symbol_table_offset
;
9516 constant_pool
= start
+ constant_pool_offset
;
9518 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9520 warn (_("Address table extends beyond end of section.\n"));
9524 printf (_("\nCU table:\n"));
9525 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9527 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9528 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9530 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9531 (unsigned long) cu_offset
,
9532 (unsigned long) (cu_offset
+ cu_length
- 1));
9535 printf (_("\nTU table:\n"));
9536 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9538 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9539 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9540 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9542 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9543 (unsigned long) tu_offset
,
9544 (unsigned long) type_offset
);
9545 print_dwarf_vma (signature
, 8);
9549 printf (_("\nAddress table:\n"));
9550 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9553 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9554 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9555 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9557 print_dwarf_vma (low
, 8);
9558 print_dwarf_vma (high
, 8);
9559 printf (_("%lu\n"), (unsigned long) cu_index
);
9562 printf (_("\nSymbol table:\n"));
9563 for (i
= 0; i
< symbol_table_slots
; ++i
)
9565 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9566 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9567 uint32_t num_cus
, cu
;
9569 if (name_offset
!= 0
9570 || cu_vector_offset
!= 0)
9573 unsigned char * adr
;
9575 adr
= constant_pool
+ name_offset
;
9576 /* PR 17531: file: 5b7b07ad. */
9577 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9579 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9580 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9584 printf ("[%3u] %.*s:", i
,
9585 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9586 constant_pool
+ name_offset
);
9588 adr
= constant_pool
+ cu_vector_offset
;
9589 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9591 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9592 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9593 cu_vector_offset
, i
);
9597 num_cus
= byte_get_little_endian (adr
, 4);
9599 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9600 if (num_cus
* 4 < num_cus
9601 || adr
>= section
->start
+ section
->size
9602 || adr
< constant_pool
)
9604 printf ("<invalid number of CUs: %d>\n", num_cus
);
9605 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9613 for (j
= 0; j
< num_cus
; ++j
)
9616 gdb_index_symbol_kind kind
;
9618 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9619 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9620 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9621 cu
= GDB_INDEX_CU_VALUE (cu
);
9622 /* Convert to TU number if it's for a type unit. */
9623 if (cu
>= cu_list_elements
/ 2)
9624 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9625 (unsigned long) (cu
- cu_list_elements
/ 2));
9627 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9629 printf (" [%s, %s]",
9630 is_static
? _("static") : _("global"),
9631 get_gdb_index_symbol_kind_name (kind
));
9643 /* Pre-allocate enough space for the CU/TU sets needed. */
9646 prealloc_cu_tu_list (unsigned int nshndx
)
9648 if (shndx_pool
== NULL
)
9650 shndx_pool_size
= nshndx
;
9651 shndx_pool_used
= 0;
9652 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9653 sizeof (unsigned int));
9657 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9658 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9659 sizeof (unsigned int));
9664 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9666 if (shndx_pool_used
>= shndx_pool_size
)
9668 error (_("Internal error: out of space in the shndx pool.\n"));
9671 shndx_pool
[shndx_pool_used
++] = shndx
;
9675 end_cu_tu_entry (void)
9677 if (shndx_pool_used
>= shndx_pool_size
)
9679 error (_("Internal error: out of space in the shndx pool.\n"));
9682 shndx_pool
[shndx_pool_used
++] = 0;
9685 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9688 get_DW_SECT_short_name (unsigned int dw_sect
)
9690 static char buf
[16];
9698 case DW_SECT_ABBREV
:
9704 case DW_SECT_STR_OFFSETS
:
9706 case DW_SECT_MACINFO
:
9714 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9718 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9719 These sections are extensions for Fission.
9720 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9723 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9725 unsigned char *phdr
= section
->start
;
9726 unsigned char *limit
= phdr
+ section
->size
;
9727 unsigned char *phash
;
9728 unsigned char *pindex
;
9729 unsigned char *ppool
;
9730 unsigned int version
;
9731 unsigned int ncols
= 0;
9733 unsigned int nslots
;
9736 dwarf_vma signature_high
;
9737 dwarf_vma signature_low
;
9740 /* PR 17512: file: 002-168123-0.004. */
9743 warn (_("Section %s is empty\n"), section
->name
);
9746 /* PR 17512: file: 002-376-0.004. */
9747 if (section
->size
< 24)
9749 warn (_("Section %s is too small to contain a CU/TU header\n"),
9754 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9756 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9757 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9758 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9761 pindex
= phash
+ (size_t) nslots
* 8;
9762 ppool
= pindex
+ (size_t) nslots
* 4;
9766 introduce (section
, FALSE
);
9768 printf (_(" Version: %u\n"), version
);
9770 printf (_(" Number of columns: %u\n"), ncols
);
9771 printf (_(" Number of used entries: %u\n"), nused
);
9772 printf (_(" Number of slots: %u\n\n"), nslots
);
9775 /* PR 17531: file: 45d69832. */
9776 if ((size_t) nslots
* 8 / 8 != nslots
9777 || phash
< phdr
|| phash
> limit
9778 || pindex
< phash
|| pindex
> limit
9779 || ppool
< pindex
|| ppool
> limit
)
9781 warn (ngettext ("Section %s is too small for %u slot\n",
9782 "Section %s is too small for %u slots\n",
9784 section
->name
, nslots
);
9791 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9792 for (i
= 0; i
< nslots
; i
++)
9794 unsigned char *shndx_list
;
9797 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9798 if (signature_high
!= 0 || signature_low
!= 0)
9800 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9801 shndx_list
= ppool
+ j
* 4;
9802 /* PR 17531: file: 705e010d. */
9803 if (shndx_list
< ppool
)
9805 warn (_("Section index pool located before start of section\n"));
9810 printf (_(" [%3d] Signature: 0x%s Sections: "),
9811 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9812 buf
, sizeof (buf
)));
9815 if (shndx_list
>= limit
)
9817 warn (_("Section %s too small for shndx pool\n"),
9821 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9825 printf (" %d", shndx
);
9827 add_shndx_to_cu_tu_entry (shndx
);
9839 else if (version
== 2)
9842 unsigned int dw_sect
;
9843 unsigned char *ph
= phash
;
9844 unsigned char *pi
= pindex
;
9845 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9846 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9847 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9848 bfd_boolean is_tu_index
;
9849 struct cu_tu_set
*this_set
= NULL
;
9851 unsigned char *prow
;
9853 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9855 /* PR 17531: file: 0dd159bf.
9856 Check for integer overflow (can occur when size_t is 32-bit)
9857 with overlarge ncols or nused values. */
9859 && ((size_t) ncols
* 4 / 4 != ncols
9860 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9861 || poffsets
< ppool
|| poffsets
> limit
9862 || psizes
< poffsets
|| psizes
> limit
9863 || pend
< psizes
|| pend
> limit
))
9865 warn (_("Section %s too small for offset and size tables\n"),
9872 printf (_(" Offset table\n"));
9873 printf (" slot %-16s ",
9874 is_tu_index
? _("signature") : _("dwo_id"));
9881 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9887 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9894 for (j
= 0; j
< ncols
; j
++)
9896 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9897 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9902 for (i
= 0; i
< nslots
; i
++)
9904 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9906 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9909 /* PR 17531: file: a05f6ab3. */
9912 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9919 size_t num_copy
= sizeof (uint64_t);
9921 /* PR 23064: Beware of buffer overflow. */
9922 if (ph
+ num_copy
< limit
)
9923 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9926 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9931 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9932 /* PR 17531: file: b8ce60a8. */
9933 if (prow
< poffsets
|| prow
> limit
)
9935 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9941 printf (_(" [%3d] 0x%s"),
9942 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9943 buf
, sizeof (buf
)));
9944 for (j
= 0; j
< ncols
; j
++)
9946 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9948 printf (" %8d", val
);
9951 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9953 /* PR 17531: file: 10796eb3. */
9954 if (dw_sect
>= DW_SECT_MAX
)
9955 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9957 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9973 printf (_(" Size table\n"));
9974 printf (" slot %-16s ",
9975 is_tu_index
? _("signature") : _("dwo_id"));
9978 for (j
= 0; j
< ncols
; j
++)
9980 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9982 printf (" %8s", get_DW_SECT_short_name (val
));
9988 for (i
= 0; i
< nslots
; i
++)
9990 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9992 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9995 prow
= psizes
+ (row
- 1) * ncols
* 4;
9998 printf (_(" [%3d] 0x%s"),
9999 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10000 buf
, sizeof (buf
)));
10002 for (j
= 0; j
< ncols
; j
++)
10004 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10006 printf (" %8d", val
);
10009 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10010 if (dw_sect
>= DW_SECT_MAX
)
10011 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10013 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10025 else if (do_display
)
10026 printf (_(" Unsupported version (%d)\n"), version
);
10034 /* Load the CU and TU indexes if present. This will build a list of
10035 section sets that we can use to associate a .debug_info.dwo section
10036 with its associated .debug_abbrev.dwo section in a .dwp file. */
10039 load_cu_tu_indexes (void *file
)
10041 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10043 /* If we have already loaded (or tried to load) the CU and TU indexes
10044 then do not bother to repeat the task. */
10045 if (cu_tu_indexes_read
== -1)
10047 cu_tu_indexes_read
= TRUE
;
10049 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10050 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10051 cu_tu_indexes_read
= FALSE
;
10053 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10054 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10055 cu_tu_indexes_read
= FALSE
;
10058 return (bfd_boolean
) cu_tu_indexes_read
;
10061 /* Find the set of sections that includes section SHNDX. */
10064 find_cu_tu_set (void *file
, unsigned int shndx
)
10068 if (! load_cu_tu_indexes (file
))
10071 /* Find SHNDX in the shndx pool. */
10072 for (i
= 0; i
< shndx_pool_used
; i
++)
10073 if (shndx_pool
[i
] == shndx
)
10076 if (i
>= shndx_pool_used
)
10079 /* Now backup to find the first entry in the set. */
10080 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10083 return shndx_pool
+ i
;
10086 /* Display a .debug_cu_index or .debug_tu_index section. */
10089 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10091 return process_cu_tu_index (section
, 1);
10095 display_debug_not_supported (struct dwarf_section
*section
,
10096 void *file ATTRIBUTE_UNUSED
)
10098 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10104 /* Like malloc, but takes two parameters like calloc.
10105 Verifies that the first parameter is not too large.
10106 Note: does *not* initialise the allocated memory to zero. */
10109 cmalloc (size_t nmemb
, size_t size
)
10111 /* Check for overflow. */
10112 if (nmemb
>= ~(size_t) 0 / size
)
10115 return xmalloc (nmemb
* size
);
10118 /* Like xmalloc, but takes two parameters like calloc.
10119 Verifies that the first parameter is not too large.
10120 Note: does *not* initialise the allocated memory to zero. */
10123 xcmalloc (size_t nmemb
, size_t size
)
10125 /* Check for overflow. */
10126 if (nmemb
>= ~(size_t) 0 / size
)
10129 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10134 return xmalloc (nmemb
* size
);
10137 /* Like xrealloc, but takes three parameters.
10138 Verifies that the second parameter is not too large.
10139 Note: does *not* initialise any new memory to zero. */
10142 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10144 /* Check for overflow. */
10145 if (nmemb
>= ~(size_t) 0 / size
)
10147 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10152 return xrealloc (ptr
, nmemb
* size
);
10155 /* Like xcalloc, but verifies that the first parameter is not too large. */
10158 xcalloc2 (size_t nmemb
, size_t size
)
10160 /* Check for overflow. */
10161 if (nmemb
>= ~(size_t) 0 / size
)
10163 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10168 return xcalloc (nmemb
, size
);
10171 static unsigned long
10172 calc_gnu_debuglink_crc32 (unsigned long crc
,
10173 const unsigned char * buf
,
10176 static const unsigned long crc32_table
[256] =
10178 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10179 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10180 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10181 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10182 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10183 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10184 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10185 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10186 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10187 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10188 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10189 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10190 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10191 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10192 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10193 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10194 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10195 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10196 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10197 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10198 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10199 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10200 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10201 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10202 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10203 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10204 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10205 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10206 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10207 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10208 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10209 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10210 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10211 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10212 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10213 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10214 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10215 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10216 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10217 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10218 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10219 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10220 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10221 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10222 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10223 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10224 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10225 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10226 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10227 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10228 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10231 const unsigned char *end
;
10233 crc
= ~crc
& 0xffffffff;
10234 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10235 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10236 return ~crc
& 0xffffffff;
10239 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10240 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10243 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10245 static unsigned char buffer
[8 * 1024];
10247 bfd_size_type count
;
10248 unsigned long crc
= 0;
10251 sep_data
= open_debug_file (pathname
);
10252 if (sep_data
== NULL
)
10255 /* Yes - we are opening the file twice... */
10256 f
= fopen (pathname
, "rb");
10259 /* Paranoia: This should never happen. */
10260 close_debug_file (sep_data
);
10261 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10265 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10266 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10270 if (crc
!= * (unsigned long *) crc_pointer
)
10272 close_debug_file (sep_data
);
10273 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10281 static const char *
10282 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10285 unsigned int crc_offset
;
10286 unsigned long * crc32
= (unsigned long *) data
;
10288 /* The name is first.
10289 The CRC value is stored after the filename, aligned up to 4 bytes. */
10290 name
= (const char *) section
->start
;
10293 crc_offset
= strnlen (name
, section
->size
) + 1;
10294 crc_offset
= (crc_offset
+ 3) & ~3;
10295 if (crc_offset
+ 4 > section
->size
)
10298 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10303 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10305 void * sep_data
= open_debug_file (filename
);
10307 if (sep_data
== NULL
)
10310 /* FIXME: We should now extract the build-id in the separate file
10316 typedef struct build_id_data
10319 const unsigned char * data
;
10322 static const char *
10323 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10326 bfd_size_type namelen
;
10327 bfd_size_type id_len
;
10328 Build_id_data
* build_id_data
;
10330 /* The name is first.
10331 The build-id follows immediately, with no padding, up to the section's end. */
10333 name
= (const char *) section
->start
;
10334 namelen
= strnlen (name
, section
->size
) + 1;
10335 if (namelen
>= section
->size
)
10338 id_len
= section
->size
- namelen
;
10342 build_id_data
= calloc (1, sizeof * build_id_data
);
10343 if (build_id_data
== NULL
)
10346 build_id_data
->len
= id_len
;
10347 build_id_data
->data
= section
->start
+ namelen
;
10349 * (Build_id_data
**) data
= build_id_data
;
10355 add_separate_debug_file (const char * filename
, void * handle
)
10357 separate_info
* i
= xmalloc (sizeof * i
);
10359 i
->filename
= filename
;
10360 i
->handle
= handle
;
10361 i
->next
= first_separate_info
;
10362 first_separate_info
= i
;
10365 #if HAVE_LIBDEBUGINFOD
10366 /* Query debuginfod servers for the target debuglink or debugaltlink
10367 file. If successful, store the path of the file in filename and
10368 return TRUE, otherwise return FALSE. */
10371 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10375 size_t build_id_len
;
10376 unsigned char * build_id
;
10378 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10380 /* Get the build-id of file. */
10381 build_id
= get_build_id (file
);
10384 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10386 /* Get the build-id of the debugaltlink file. */
10387 unsigned int filelen
;
10389 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10390 if (filelen
== section
->size
)
10391 /* Corrupt debugaltlink. */
10394 build_id
= section
->start
+ filelen
+ 1;
10395 build_id_len
= section
->size
- (filelen
+ 1);
10397 if (build_id_len
== 0)
10406 debuginfod_client
* client
;
10408 client
= debuginfod_begin ();
10409 if (client
== NULL
)
10412 /* Query debuginfod servers for the target file. If found its path
10413 will be stored in filename. */
10414 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10415 debuginfod_end (client
);
10417 /* Only free build_id if we allocated space for a hex string
10418 in get_build_id (). */
10419 if (build_id_len
== 0)
10424 /* File successfully retrieved. Close fd since we want to
10425 use open_debug_file () on filename instead. */
10436 load_separate_debug_info (const char * main_filename
,
10437 struct dwarf_section
* xlink
,
10438 parse_func_type parse_func
,
10439 check_func_type check_func
,
10441 void * file ATTRIBUTE_UNUSED
)
10443 const char * separate_filename
;
10444 char * debug_filename
;
10446 size_t canon_dirlen
;
10449 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10451 warn (_("Corrupt debuglink section: %s\n"),
10452 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10456 /* Attempt to locate the separate file.
10457 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10459 canon_dir
= lrealpath (main_filename
);
10461 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10462 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10464 canon_dir
[canon_dirlen
] = '\0';
10467 #define DEBUGDIR "/lib/debug"
10469 #ifndef EXTRA_DEBUG_ROOT1
10470 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10472 #ifndef EXTRA_DEBUG_ROOT2
10473 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10476 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10478 + strlen (".debug/")
10479 #ifdef EXTRA_DEBUG_ROOT1
10480 + strlen (EXTRA_DEBUG_ROOT1
)
10482 #ifdef EXTRA_DEBUG_ROOT2
10483 + strlen (EXTRA_DEBUG_ROOT2
)
10485 + strlen (separate_filename
)
10487 if (debug_filename
== NULL
)
10489 warn (_("Out of memory"));
10494 /* First try in the current directory. */
10495 sprintf (debug_filename
, "%s", separate_filename
);
10496 if (check_func (debug_filename
, func_data
))
10499 /* Then try in a subdirectory called .debug. */
10500 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10501 if (check_func (debug_filename
, func_data
))
10504 /* Then try in the same directory as the original file. */
10505 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10506 if (check_func (debug_filename
, func_data
))
10509 /* And the .debug subdirectory of that directory. */
10510 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10511 if (check_func (debug_filename
, func_data
))
10514 #ifdef EXTRA_DEBUG_ROOT1
10515 /* Try the first extra debug file root. */
10516 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10517 if (check_func (debug_filename
, func_data
))
10520 /* Try the first extra debug file root. */
10521 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10522 if (check_func (debug_filename
, func_data
))
10526 #ifdef EXTRA_DEBUG_ROOT2
10527 /* Try the second extra debug file root. */
10528 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10529 if (check_func (debug_filename
, func_data
))
10533 /* Then try in the global debug_filename directory. */
10534 strcpy (debug_filename
, DEBUGDIR
);
10535 dirlen
= strlen (DEBUGDIR
) - 1;
10536 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10537 strcat (debug_filename
, "/");
10538 strcat (debug_filename
, (const char *) separate_filename
);
10540 if (check_func (debug_filename
, func_data
))
10543 #if HAVE_LIBDEBUGINFOD
10545 char * tmp_filename
;
10547 if (debuginfod_fetch_separate_debug_info (xlink
,
10551 /* File successfully downloaded from server, replace
10552 debug_filename with the file's path. */
10553 free (debug_filename
);
10554 debug_filename
= tmp_filename
;
10560 /* Failed to find the file. */
10561 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10562 warn (_("tried: %s\n"), debug_filename
);
10564 #ifdef EXTRA_DEBUG_ROOT2
10565 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10566 warn (_("tried: %s\n"), debug_filename
);
10569 #ifdef EXTRA_DEBUG_ROOT1
10570 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10571 warn (_("tried: %s\n"), debug_filename
);
10573 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10574 warn (_("tried: %s\n"), debug_filename
);
10577 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10578 warn (_("tried: %s\n"), debug_filename
);
10580 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10581 warn (_("tried: %s\n"), debug_filename
);
10583 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10584 warn (_("tried: %s\n"), debug_filename
);
10586 sprintf (debug_filename
, "%s", separate_filename
);
10587 warn (_("tried: %s\n"), debug_filename
);
10589 #if HAVE_LIBDEBUGINFOD
10591 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10595 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10600 free (debug_filename
);
10606 void * debug_handle
;
10608 /* Now open the file.... */
10609 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10611 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10612 free (debug_filename
);
10616 /* FIXME: We do not check to see if there are any other separate debug info
10617 files that would also match. */
10619 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10620 add_separate_debug_file (debug_filename
, debug_handle
);
10622 /* Do not free debug_filename - it might be referenced inside
10623 the structure returned by open_debug_file(). */
10624 return debug_handle
;
10627 /* Attempt to load a separate dwarf object file. */
10630 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10632 char * separate_filename
;
10633 void * separate_handle
;
10635 /* FIXME: Skip adding / if dwo_dir ends in /. */
10636 separate_filename
= concat (dir
, "/", name
, NULL
);
10637 if (separate_filename
== NULL
)
10639 warn (_("Out of memory allocating dwo filename\n"));
10643 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10645 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10646 free (separate_filename
);
10650 /* FIXME: We should check the dwo_id. */
10652 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10653 add_separate_debug_file (separate_filename
, separate_handle
);
10654 /* Note - separate_filename will be freed in free_debug_memory(). */
10655 return separate_handle
;
10658 /* Load the separate debug info file(s) attached to FILE, if any exist.
10659 Returns TRUE if any were found, FALSE otherwise.
10660 If TRUE is returned then the linked list starting at first_separate_info
10661 will be populated with open file handles. */
10664 load_separate_debug_files (void * file
, const char * filename
)
10666 /* Skip this operation if we are not interested in debug links. */
10667 if (! do_follow_links
&& ! do_debug_links
)
10670 /* See if there are any dwo links. */
10671 if (load_debug_section (str
, file
)
10672 && load_debug_section (abbrev
, file
)
10673 && load_debug_section (info
, file
))
10677 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10679 bfd_boolean introduced
= FALSE
;
10681 const char * dir
= NULL
;
10682 const char * id
= NULL
;
10684 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10686 switch (dwinfo
->type
)
10689 if (do_debug_links
)
10693 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10694 debug_displays
[info
].section
.uncompressed_name
);
10698 printf (_(" Name: %s\n"), dwinfo
->value
);
10699 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10701 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10703 printf (_(" ID: <unknown>\n"));
10707 if (do_follow_links
)
10708 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10712 dir
= dwinfo
->value
;
10716 id
= dwinfo
->value
;
10720 error (_("Unexpected DWO INFO type"));
10727 if (! do_follow_links
)
10728 /* The other debug links will be displayed by display_debug_links()
10729 so we do not need to do any further processing here. */
10732 /* FIXME: We do not check for the presence of both link sections in the same file. */
10733 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10734 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10735 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10737 if (load_debug_section (gnu_debugaltlink
, file
))
10739 Build_id_data
* build_id_data
;
10741 load_separate_debug_info (filename
,
10742 & debug_displays
[gnu_debugaltlink
].section
,
10743 parse_gnu_debugaltlink
,
10744 check_gnu_debugaltlink
,
10749 if (load_debug_section (gnu_debuglink
, file
))
10751 unsigned long crc32
;
10753 load_separate_debug_info (filename
,
10754 & debug_displays
[gnu_debuglink
].section
,
10755 parse_gnu_debuglink
,
10756 check_gnu_debuglink
,
10761 if (first_separate_info
!= NULL
)
10764 do_follow_links
= 0;
10769 free_debug_memory (void)
10775 for (i
= 0; i
< max
; i
++)
10776 free_debug_section ((enum dwarf_section_display_enum
) i
);
10778 if (debug_information
!= NULL
)
10780 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
10782 if (debug_information
[i
].max_loc_offsets
)
10784 free (debug_information
[i
].loc_offsets
);
10785 free (debug_information
[i
].have_frame_base
);
10787 if (debug_information
[i
].max_range_lists
)
10788 free (debug_information
[i
].range_lists
);
10790 free (debug_information
);
10791 debug_information
= NULL
;
10792 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10796 separate_info
* next
;
10798 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10800 close_debug_file (d
->handle
);
10801 free ((void *) d
->filename
);
10805 first_separate_info
= NULL
;
10811 dwarf_select_sections_by_names (const char *names
)
10815 const char * option
;
10819 debug_dump_long_opts
;
10821 static const debug_dump_long_opts opts_table
[] =
10823 /* Please keep this table alpha- sorted. */
10824 { "Ranges", & do_debug_ranges
, 1 },
10825 { "abbrev", & do_debug_abbrevs
, 1 },
10826 { "addr", & do_debug_addr
, 1 },
10827 { "aranges", & do_debug_aranges
, 1 },
10828 { "cu_index", & do_debug_cu_index
, 1 },
10829 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10830 { "follow-links", & do_follow_links
, 1 },
10831 { "frames", & do_debug_frames
, 1 },
10832 { "frames-interp", & do_debug_frames_interp
, 1 },
10833 /* The special .gdb_index section. */
10834 { "gdb_index", & do_gdb_index
, 1 },
10835 { "info", & do_debug_info
, 1 },
10836 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10837 { "links", & do_debug_links
, 1 },
10838 { "loc", & do_debug_loc
, 1 },
10839 { "macro", & do_debug_macinfo
, 1 },
10840 { "pubnames", & do_debug_pubnames
, 1 },
10841 { "pubtypes", & do_debug_pubtypes
, 1 },
10842 /* This entry is for compatibility
10843 with earlier versions of readelf. */
10844 { "ranges", & do_debug_aranges
, 1 },
10845 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10846 { "str", & do_debug_str
, 1 },
10847 { "str-offsets", & do_debug_str_offsets
, 1 },
10848 /* These trace_* sections are used by Itanium VMS. */
10849 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10850 { "trace_aranges", & do_trace_aranges
, 1 },
10851 { "trace_info", & do_trace_info
, 1 },
10860 const debug_dump_long_opts
* entry
;
10862 for (entry
= opts_table
; entry
->option
; entry
++)
10864 size_t len
= strlen (entry
->option
);
10866 if (strncmp (p
, entry
->option
, len
) == 0
10867 && (p
[len
] == ',' || p
[len
] == '\0'))
10869 * entry
->variable
|= entry
->val
;
10871 /* The --debug-dump=frames-interp option also
10872 enables the --debug-dump=frames option. */
10873 if (do_debug_frames_interp
)
10874 do_debug_frames
= 1;
10881 if (entry
->option
== NULL
)
10883 warn (_("Unrecognized debug option '%s'\n"), p
);
10884 p
= strchr (p
, ',');
10895 dwarf_select_sections_by_letters (const char *letters
)
10897 unsigned int lindex
= 0;
10899 while (letters
[lindex
])
10900 switch (letters
[lindex
++])
10902 case 'A': do_debug_addr
= 1; break;
10903 case 'a': do_debug_abbrevs
= 1; break;
10904 case 'c': do_debug_cu_index
= 1; break;
10905 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10906 case 'f': do_debug_frames
= 1; break;
10907 case 'g': do_gdb_index
= 1; break;
10908 case 'i': do_debug_info
= 1; break;
10909 case 'K': do_follow_links
= 1; break;
10910 case 'k': do_debug_links
= 1; break;
10911 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10912 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10913 case 'm': do_debug_macinfo
= 1; break;
10914 case 'O': do_debug_str_offsets
= 1; break;
10915 case 'o': do_debug_loc
= 1; break;
10916 case 'p': do_debug_pubnames
= 1; break;
10917 case 'R': do_debug_ranges
= 1; break;
10918 case 'r': do_debug_aranges
= 1; break;
10919 case 's': do_debug_str
= 1; break;
10920 case 'T': do_trace_aranges
= 1; break;
10921 case 't': do_debug_pubtypes
= 1; break;
10922 case 'U': do_trace_info
= 1; break;
10923 case 'u': do_trace_abbrevs
= 1; break;
10926 warn (_("Unrecognized debug option '%s'\n"), letters
);
10932 dwarf_select_sections_all (void)
10935 do_debug_abbrevs
= 1;
10936 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10937 do_debug_pubnames
= 1;
10938 do_debug_pubtypes
= 1;
10939 do_debug_aranges
= 1;
10940 do_debug_ranges
= 1;
10941 do_debug_frames
= 1;
10942 do_debug_macinfo
= 1;
10947 do_trace_abbrevs
= 1;
10948 do_trace_aranges
= 1;
10950 do_debug_cu_index
= 1;
10951 do_follow_links
= 1;
10952 do_debug_links
= 1;
10953 do_debug_str_offsets
= 1;
10956 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10957 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10959 /* N.B. The order here must match the order in section_display_enum. */
10961 struct dwarf_section_display debug_displays
[] =
10963 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10964 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10965 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10966 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10967 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10968 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10969 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10970 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10971 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10972 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10973 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10974 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10975 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10976 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10977 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10978 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10979 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10980 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10981 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10982 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10983 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10984 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10985 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10986 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10987 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10988 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10989 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10990 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10991 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10992 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10993 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10994 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10995 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10996 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10997 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10998 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
10999 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11000 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
11001 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11002 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11003 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11004 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11005 /* Separate debug info files can containt their own .debug_str section,
11006 and this might be in *addition* to a .debug_str section already present
11007 in the main file. Hence we need to have two entries for .debug_str. */
11008 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11011 /* A static assertion. */
11012 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];